From f6f6036f208fa4938c1c22e22a95b6f49540d2cf Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 19:34:10 +0100 Subject: [PATCH 01/17] WIP #89 stage 1: SP-14 registered; kernel-term builder; certificate E as a core module (data path, legacy-import rendering, data audit, notation record) --- CONFORMANCE.md | 1 + README.md | 2 +- SPEC.md | 3 +- crates/conformance/src/cases/preservation.rs | 24 + crates/conformance/src/cases/repository.rs | 2 +- crates/conformance/tests/conformance.rs | 5 + crates/lexlean/src/backend/core.rs | 28 +- crates/lexlean/src/ir/core.rs | 10 +- crates/lexlean/src/production/certificate.rs | 37 +- .../src/production/certificate/data.rs | 1426 +++++++++++++++++ crates/lexlean/src/production/kernel.rs | 607 +++++++ crates/lexlean/src/production/mod.rs | 1 + crates/lexlean/src/production/preserve.rs | 197 ++- crates/lexlean/src/production/rust_cert.rs | 2 + crates/lexlean/src/verify/mod.rs | 19 +- features/suites/preservation.feature | 7 + model/ids.toml | 6 + xtask/src/spec_links.rs | 4 +- 18 files changed, 2355 insertions(+), 26 deletions(-) create mode 100644 crates/lexlean/src/production/certificate/data.rs create mode 100644 crates/lexlean/src/production/kernel.rs diff --git a/CONFORMANCE.md b/CONFORMANCE.md index b98cb78d0..f428c2d43 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -337,6 +337,7 @@ the error registry does not sanction (R5, `ERRORS.md`). | `SP-10` | `build` | A production root whose parameters can hold a map, set, or graph, directly or inside options, results, products, lists, document types, and recursive groups of them, is lowered with a generated entry function that calls the root only when the generated validators of each such parameter accept it and returns none otherwise; certificate A proves each validator decides exactly the proposition §17.12 states of its type and the entry's two outcomes; a validator is called only by the entry and by validators, so no proof-only invariant becomes a runtime check, and a validator called from inside the program is refused by the lowering; and a validator dropped from the entry, one weakened to admit an equal key, and a rendering whose entry drops a validator are each refused by Lean at the relation they change; a lowering whose entry skips a validated parameter is refused by the generator, which judges the validated parameters from the source types alone, and the differentials break each validated parameter's invariant in turn, which the interpreter, Lean, the declared machine, and rustc each refuse with none. | | `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. | +| `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 95fc11d17..d3a5dd471 100644 --- a/README.md +++ b/README.md @@ -137,7 +137,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 379 registered conformance IDs are implemented and pass; `just vv` runs clean from a checkout with the pinned toolchain installed. +All 380 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. diff --git a/SPEC.md b/SPEC.md index b1070ea48..6f24b1d7b 100644 --- a/SPEC.md +++ b/SPEC.md @@ -9121,6 +9121,7 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `SP-10` | `preservation` | A production root whose parameters can hold a map, set, or graph, directly or inside options, results, products, lists, document types, and recursive groups of them, is lowered with a generated entry function that calls the root only when the generated validators of each such parameter accept it and returns none otherwise; certificate A proves each validator decides exactly the proposition §17.12 states of its type and the entry's two outcomes; a validator is called only by the entry and by validators, so no proof-only invariant becomes a runtime check, and a validator called from inside the program is refused by the lowering; and a validator dropped from the entry, one weakened to admit an equal key, and a rendering whose entry drops a validator are each refused by Lean at the relation they change; a lowering whose entry skips a validated parameter is refused by the generator, which judges the validated parameters from the source types alone, and the differentials break each validated parameter's invariant in turn, which the interpreter, Lean, the declared machine, and rustc each refuse with none. | §17.12, §17.17 | | `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. | §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 | @@ -9192,7 +9193,7 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `AU-11` | `authoring` | Malformed core notation fails closed and never panics: an unclosed delimiter, a keyword used as a name, a label that is not the number of its node, a reference to a node not yet written, a numeral with a redundant leading zero, a statement that defines no node, a nesting beyond the bound, and every single-token deletion and duplication of a committed module fail with a registered code at a position in the notation or link to a module that decodes. | §17.21.8 | | `AU-12` | `authoring` | A core module written with names for its statements and its variables reads to exactly the module its canonical notation reads to, and the canonical notation keeps the names of the binders and writes the numbers of the statements: a variable is written by the name of its binder exactly when no nearer binder has the name, a constant a binder in scope is named like is written as a string, a theorem added to the certification library by name reads to the committed module and is written as the committed bytes, and an unknown or repeated statement name and a variable given universe levels are refused with a position. | §17.21.8 | -**Total required capability IDs:** 379. +**Total required capability IDs:** 380. 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/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index 7f4d66681..1bb8aab84 100644 --- a/crates/conformance/src/cases/preservation.rs +++ b/crates/conformance/src/cases/preservation.rs @@ -2926,6 +2926,30 @@ 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" => { + 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}" + ); + } + } + } + } _ => 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 76dbcde98..a51407cc4 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(), 379, "§31 has 379 rows"); + assert_eq!(table.len(), 380, "§31 has 380 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/tests/conformance.rs b/crates/conformance/tests/conformance.rs index 041b58b42..96d3631f5 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -1555,6 +1555,11 @@ fn conformance_sp_12() { repo_conformance::cases::run("SP-12"); } +#[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/backend/core.rs b/crates/lexlean/src/backend/core.rs index 5256fd47e..21723aaca 100644 --- a/crates/lexlean/src/backend/core.rs +++ b/crates/lexlean/src/backend/core.rs @@ -1382,9 +1382,33 @@ 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, true) +} + +/// 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. 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) -> Result { + lean_text_with(core, false) +} + +fn lean_text_with(core: &CoreModule, module_system: bool) -> Result { + let mut text = String::new(); + if module_system { + text.push_str("module\n"); + } for import in &core.imports { - text.push_str(&format!("public import {import}\n")); + if module_system { + 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", diff --git a/crates/lexlean/src/ir/core.rs b/crates/lexlean/src/ir/core.rs index d7be93040..2f75beb25 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 ad60753c8..d1ff58e04 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::lower::{fixed_kind, Layout, Lowered, Origin, Validation}; use super::source::{Constructor, Local, Site, Source}; @@ -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,20 +444,42 @@ 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) + .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), }) } +/// 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) +} + /// `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 { @@ -595,6 +624,8 @@ pub fn certificate( denote: format!("{module}.denote"), text, imports, + data: None, + source: None, }) } diff --git a/crates/lexlean/src/production/certificate/data.rs b/crates/lexlean/src/production/certificate/data.rs new file mode 100644 index 000000000..018b9b4d5 --- /dev/null +++ b/crates/lexlean/src/production/certificate/data.rs @@ -0,0 +1,1426 @@ +//! 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}")) + } + + /// A library lemma applied to `args`, with the resulting type. + fn apply_typed(&mut self, name: &str, args: &[Arg]) -> Result<(Term, Term), String> { + let (head, ty) = self.lemma(name)?; + self.b + .apply_pi(head, ty, args) + .map(|applied| (applied.term, applied.ty)) + .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)); + } + 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 row `__wt_k` of document type `index`: every value of the type + /// encodes to a well-typed value of `Ty.adt index`. + fn wt_row(&mut self, index: u64, recursive: bool) -> 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" || recursive { + "__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); + if recursive { + return Err(format!( + "`{}` is recursive: its well-typedness theorem is a recursor term, which stage 1 of #89 does not yet write", + self.gen.source.type_text(&ty) + )); + } + 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 = { + let o = self.b.bvar(0); + let ro3 = self.b.bvar(3); + let body = self.b.apps(realizes, &[fallible_term, o, ro3]); + 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. + let representable = self.rust("RepresentableL"); + let hrep_ty = self.b.app(representable, args_list); + 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)) + }); + for index in component { + let row = self.wt_row(index, recursive)?; + self.row_axioms + .insert(row.name.clone(), row.axioms.clone()); + rows.push(row); + } + } + rows.push(self.root_row(root_module, root_name, fallible)?); + 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) + } +} + +/// 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..c5d0f97c6 --- /dev/null +++ b/crates/lexlean/src/production/kernel.rs @@ -0,0 +1,607 @@ +//! 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 1745df00e..6f2cd07fc 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 lower; pub mod preserve; diff --git a/crates/lexlean/src/production/preserve.rs b/crates/lexlean/src/production/preserve.rs index 6b3f42b38..1edef45b5 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(); for module in &library.modules { @@ -346,11 +357,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, }) } @@ -382,6 +399,122 @@ 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. @@ -412,6 +545,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() @@ -481,6 +625,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 { @@ -1080,6 +1235,7 @@ pub fn workspace( path: module_path(&module), text: text.to_owned(), module, + source: None, }); } for (module, text) in ordered(user)? { @@ -1095,11 +1251,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 @@ -1116,6 +1273,7 @@ pub fn workspace( path: module_path(&certificate.module), module: certificate.module.clone(), text: certificate.text.clone(), + source: certificate.source.clone(), }); } Ok(Workspace { @@ -1128,6 +1286,7 @@ pub fn workspace( path: module_path(AUDIT_MODULE), module: AUDIT_MODULE.to_owned(), text: audit_text(&library, certificates), + source: None, }, }) } @@ -1218,6 +1377,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(()) } @@ -1264,12 +1444,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(), ), ), diff --git a/crates/lexlean/src/production/rust_cert.rs b/crates/lexlean/src/production/rust_cert.rs index 936070ef6..a674afa6b 100644 --- a/crates/lexlean/src/production/rust_cert.rs +++ b/crates/lexlean/src/production/rust_cert.rs @@ -102,6 +102,8 @@ impl CertificateB { theorem: self.theorem, text: self.text, imports: Vec::new(), + data: None, + source: None, } } } diff --git a/crates/lexlean/src/verify/mod.rs b/crates/lexlean/src/verify/mod.rs index 66a9fd332..ae1af29df 100644 --- a/crates/lexlean/src/verify/mod.rs +++ b/crates/lexlean/src/verify/mod.rs @@ -2081,11 +2081,20 @@ pub fn run( )?; process_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/features/suites/preservation.feature b/features/suites/preservation.feature index ee01f0348..20626a720 100644 --- a/features/suites/preservation.feature +++ b/features/suites/preservation.feature @@ -85,3 +85,10 @@ Feature: preservation Then every listed module has exactly one native source and the project holds no Lean file, and no Lean file in the release tree declares the library's namespace And the registry names no declaration, and the constructors and soundness cases the audit uses are those of the native modules And a native source that is missing, extra, of the first schema, or weakened to an inexact policy is refused + + @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 30b4f88dc..e24589d3e 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -1868,6 +1868,12 @@ level = "build" suite = "preservation" statement = "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." +[[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/xtask/src/spec_links.rs b/xtask/src/spec_links.rs index ccb1d47d2..4deb4e7c9 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() != 379 { - return Err(format!("RP-07: the §31 table has {} rows, not 379", rows.len()).into()); + if rows.len() != 380 { + return Err(format!("RP-07: the §31 table has {} rows, not 380", 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. From 2e806d45e4f76bb4d990e766539dbbc2ad8fd00f Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 19:46:36 +0100 Subject: [PATCH 02/17] WIP #89 stage 1: recursive groups as recursor terms; SP-14 builds every certificate E --- crates/conformance/src/cases/preservation.rs | 87 ++ .../src/production/certificate/data.rs | 802 +++++++++++++++++- crates/lexlean/src/production/source.rs | 13 + 3 files changed, 862 insertions(+), 40 deletions(-) diff --git a/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index 1bb8aab84..d3b8cc15f 100644 --- a/crates/conformance/src/cases/preservation.rs +++ b/crates/conformance/src/cases/preservation.rs @@ -2928,6 +2928,93 @@ pub fn run(id: &str) { } // §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") + ); for (name, _) in certified_projects() { let base = repo_root() .join("examples") diff --git a/crates/lexlean/src/production/certificate/data.rs b/crates/lexlean/src/production/certificate/data.rs index 018b9b4d5..4f5c85014 100644 --- a/crates/lexlean/src/production/certificate/data.rs +++ b/crates/lexlean/src/production/certificate/data.rs @@ -762,35 +762,14 @@ impl<'g, 'a> Composer<'g, 'a> { let proof = self.wt_apply(ty, *value)?; items.push((encoded, target, proof)); } - 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), - ], - ) + self.wt_adt_items(index, constructor, &items) } - /// The row `__wt_k` of document type `index`: every value of the type - /// encodes to a well-typed value of `Ty.adt index`. - fn wt_row(&mut self, index: u64, recursive: bool) -> Result { + /// 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)?; @@ -831,23 +810,13 @@ impl<'g, 'a> Composer<'g, 'a> { } }; let owner = self.document_name(&member)?; - let binder = if shape.kind == "inductive" || recursive { - "__v" - } else { - "__s" - }; + 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); - if recursive { - return Err(format!( - "`{}` is recursive: its well-typedness theorem is a recursor term, which stage 1 of #89 does not yet write", - self.gen.source.type_text(&ty) - )); - } 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); @@ -1300,8 +1269,16 @@ impl<'g, 'a> Composer<'g, 'a> { .get(index) .is_some_and(|edges| edges.contains(index)) }); - for index in component { - let row = self.wt_row(index, recursive)?; + 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); @@ -1328,6 +1305,751 @@ impl<'g, 'a> Composer<'g, 'a> { } } + +/// 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> { + Ok(match aux.kind { + AuxKind::List => vec![super::element_of(&aux.original)?], + AuxKind::Option => match &aux.original { + SemanticType::Option { value } => vec![value.as_ref().clone()], + _ => return Err("an option auxiliary of a non-option".to_owned()), + }, + AuxKind::Prod => match &aux.original { + SemanticType::Product { left, right } => { + vec![left.as_ref().clone(), right.as_ref().clone()] + } + SemanticType::ContractViolation | SemanticType::ReasoningFailure => { + vec![SemanticType::Bool, SemanticType::Bool] + } + _ => return Err("a pair auxiliary of a non-pair".to_owned()), + }, + AuxKind::Except => match &aux.original { + SemanticType::Result { ok, error } => { + vec![error.as_ref().clone(), ok.as_ref().clone()] + } + _ => return Err("a result auxiliary of a non-result".to_owned()), + }, + }) + } + + /// 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. + 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 = match &original { + SemanticType::Option { value } => value.as_ref().clone(), + _ => return Err("an option auxiliary of a non-option".to_owned()), + }; + 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 (ok, error) = match &original { + SemanticType::Result { ok, error } => { + (ok.as_ref().clone(), error.as_ref().clone()) + } + _ => return Err("a result auxiliary of a non-result".to_owned()), + }; + 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; + let (first_member, first_arguments) = match first { + SemanticType::Named { member, arguments } => (member.clone(), arguments.clone()), + _ => return Err("a recursive group of a non-document type".to_owned()), + }; + 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 member a document type names. +fn named_member(ty: &SemanticType) -> Result { + match ty { + SemanticType::Named { + member, + arguments: _, + } => Ok(member.clone()), + _ => 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 { 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 From 19da6ebae1872053d8416fa62625e94dbb415415 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 20:03:21 +0100 Subject: [PATCH 03/17] WIP #89 stage 1: loose-variable guard, hrep binder depth, SP-14 Lean-backed plants, SPEC/CHANGELOG, fixture plant in data form --- CHANGELOG.md | 18 + SPEC.md | 30 ++ crates/conformance/src/cases/preservation.rs | 199 +++++++- crates/conformance/src/preservation.rs | 123 +++++ crates/lexlean/src/production/certificate.rs | 473 ------------------ .../src/production/certificate/data.rs | 134 +++-- crates/lexlean/src/production/kernel.rs | 19 +- crates/lexlean/src/production/preserve.rs | 3 +- .../certificate-e-rejected/toolchain/bin/lake | 10 +- 9 files changed, 462 insertions(+), 547 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6add5ff8d..29fda496b 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` (380 rows). - Core modules in the authoring notation (SPEC.md §17.21.8, `AU-09`..`AU-12`; stages 3c and 3d of #93). A native `coremodule` of schema `lexlean/core-module/2` can be written as text instead of one `\coredata{…}` argument of canonical diff --git a/SPEC.md b/SPEC.md index 6f24b1d7b..187011c12 100644 --- a/SPEC.md +++ b/SPEC.md @@ -5229,6 +5229,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 @@ -7239,6 +7268,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 diff --git a/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index d3b8cc15f..14564cb4b 100644 --- a/crates/conformance/src/cases/preservation.rs +++ b/crates/conformance/src/cases/preservation.rs @@ -1754,8 +1754,10 @@ 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(), @@ -1864,13 +1866,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( @@ -2983,7 +2989,10 @@ pub fn run(id: &str) { .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"); + assert_eq!( + read, canonical, + "{module_e}: the record reads back to the data" + ); let environment: BTreeSet = [ module.clone(), module_b.clone(), @@ -3015,6 +3024,7 @@ pub fn run(id: &str) { "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") @@ -3036,6 +3046,179 @@ pub fn run(id: &str) { } } } + 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 text = lexlean::backend::core::lean_text_legacy(planted) + .expect("the planted module renders"); + let module = format!("{}Plant{label}", composed.module); + 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}" + ); + joined.lines().next().unwrap_or_default().to_owned() + }; + 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) + .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(); + let planted_workspace = + preserve::workspace(&user, std::slice::from_ref(&lying_certificate)) + .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/preservation.rs b/crates/conformance/src/preservation.rs index 0ec7ac991..825e21ead 100644 --- a/crates/conformance/src/preservation.rs +++ b/crates/conformance/src/preservation.rs @@ -429,6 +429,129 @@ fn lean(root: &Path, arguments: &[String]) -> std::process::Output { .expect("lean runs") } +/// The statement oracle of #89 stage 1 (a one-time record, kept in +/// `tests/preservation-certificates/E-STATEMENTS.md`): for every certificate E +/// of the four corpora, the kernel statement of each theorem of the data +/// certificate is definitionally the statement the committed text certificate +/// elaborated to. Run by hand with the pinned Lean while the committed records +/// are still the text certificates: +/// `cargo test -p repo-conformance --lib oracle_e_statements -- --ignored --nocapture`. +#[cfg(test)] +mod oracle { + use std::path::Path; + + use crate::support::{repo_root, P}; + + #[test] + #[ignore = "a one-time record, run by hand with the pinned Lean"] + fn oracle_e_statements() { + let mut table = Vec::new(); + for example in ["production", "production-coverage", "models", "reasoning"] { + let project = P::copy_example(example); + let certified = super::certificates(&project); + let workspace = super::staged(&project, &certified); + let root = tempfile::Builder::new() + .prefix("lexlean-oracle-") + .tempdir() + .expect("tempdir"); + let checked = super::check(&workspace, root.path()); + assert!( + checked.failure.is_none(), + "{example}: {:?}", + checked.failure + ); + let base = repo_root() + .join("examples") + .join(example) + .join("expected/verify/preserve"); + for certified in &certified { + for (_, composed) in &certified.composed { + let module = &composed.module; + let data = composed.data.as_ref().expect("certificate E is data"); + let old_path = base.join(lexlean::production::preserve::module_path(module)); + let old = std::fs::read_to_string(old_path.as_std_path()) + .unwrap_or_else(|error| panic!("{module}: the committed text: {error}")); + let old_module = format!("{module}.Old"); + let renamed = old + .replace( + &format!("namespace {module}\n"), + &format!("namespace {old_module}\n"), + ) + .replace(&format!("end {module}\n"), &format!("end {old_module}\n")); + let output = super::compile_text(root.path(), &old_module, &renamed); + assert!( + output.status.success(), + "{module}: the committed text compiles: {}", + String::from_utf8_lossy(&output.stderr) + ); + let pairs: Vec = data + .declarations + .iter() + .map(|row| { + let short = row + .name + .strip_prefix(&format!("{module}.")) + .expect("a row of the module"); + format!("(`{module}.{short}, `{old_module}.{short})") + }) + .collect(); + let oracle = format!( + "import {module}\nimport {old_module}\nimport Lean\nopen Lean Meta\nrun_cmd Lean.Elab.Command.liftTermElabM do\n let pairs : List (Name × Name) := [{}]\n for (new, old) in pairs do\n let n ← getConstInfo new\n let o ← getConstInfo old\n unless (← isDefEq n.type o.type) do\n throwError \"{{new}}: the statement differs from {{old}}\"\n logInfo m!\"SP-14 oracle: {{pairs.length}} statements equal\"\n", + pairs.join(", ") + ); + let output = compile_oracle(root.path(), &format!("{module}.Oracle"), &oracle); + let text = format!( + "{}{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + assert!( + output.status.success() && text.contains("statements equal"), + "{module}: {text}" + ); + table.push(format!( + "| `{example}` | `{}` | {} | {} |", + module.strip_prefix("LexLeanPreserve.").unwrap_or(module), + data.declarations.len(), + text.trim().lines().last().unwrap_or_default().trim() + )); + } + } + } + eprintln!("| corpus | certificate E | rows | oracle |\n| --- | --- | ---: | --- |"); + for row in table { + eprintln!("{row}"); + } + } + + fn compile_oracle(root: &Path, module: &str, text: &str) -> std::process::Output { + super::compile_text(root, module, text) + } +} + +/// 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!( "{}{}", diff --git a/crates/lexlean/src/production/certificate.rs b/crates/lexlean/src/production/certificate.rs index d1ff58e04..7605d38eb 100644 --- a/crates/lexlean/src/production/certificate.rs +++ b/crates/lexlean/src/production/certificate.rs @@ -480,38 +480,6 @@ fn record_source(module: &str, data: &crate::ir::core::CoreModule) -> Result 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 generator of a lowered root's certificates, before nesting. fn generator<'a>( modules: &'a BTreeMap>, @@ -7399,447 +7367,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(); - 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 : {} [{}]) : ∃ __e_ro, {} {module_b}.krate ({} {entry}) [{}] __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"), - arguments.join(", "), - lib("Rust.RCI"), - lib("Rust.fnIdent"), - arguments.join(", "), - 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 : {} [{}]) : ∃ __e_ro, {} {fallible} ({module_a}.denote{applied}) __e_ro ∧ {} {module_b}.krate ({} 0) [{}] __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"), - arguments.join(", "), - lib("Rust.RealizesFn"), - lib("Rust.RCI"), - lib("Rust.fnIdent"), - arguments.join(", "), - 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 index 4f5c85014..4ea10148c 100644 --- a/crates/lexlean/src/production/certificate/data.rs +++ b/crates/lexlean/src/production/certificate/data.rs @@ -143,15 +143,6 @@ impl<'g, 'a> Composer<'g, 'a> { .map_err(|reason| format!("`{name}`: {reason}")) } - /// A library lemma applied to `args`, with the resulting type. - fn apply_typed(&mut self, name: &str, args: &[Arg]) -> Result<(Term, Term), String> { - let (head, ty) = self.lemma(name)?; - self.b - .apply_pi(head, ty, args) - .map(|applied| (applied.term, applied.ty)) - .map_err(|reason| format!("`{name}`: {reason}")) - } - fn rust_lemma(&mut self, name: &str, args: &[Arg]) -> Result { self.apply(&format!("{RUST}.{name}"), args) } @@ -810,7 +801,11 @@ impl<'g, 'a> Composer<'g, 'a> { } }; let owner = self.document_name(&member)?; - let binder = if shape.kind == "inductive" { "__v" } else { "__s" }; + 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}")); @@ -930,7 +925,9 @@ impl<'g, 'a> Composer<'g, 'a> { 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 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. @@ -940,9 +937,10 @@ impl<'g, 'a> Composer<'g, 'a> { 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]); + 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)); @@ -1088,9 +1086,10 @@ impl<'g, 'a> Composer<'g, 'a> { 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 ro3 = self.b.bvar(3); - let body = self.b.apps(realizes, &[fallible_term, o, ro3]); + 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"); @@ -1109,9 +1108,9 @@ impl<'g, 'a> Composer<'g, 'a> { 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]); + let rewritten = self + .b + .apps(eq_subst, &[obs_ty, motive3, obs3, target, equation, hr3]); self.b .lam("__e_h", CoreBinderInfo::Explicit, accepted2, rewritten) }; @@ -1125,9 +1124,9 @@ impl<'g, 'a> Composer<'g, 'a> { 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]); + let rewritten = self + .b + .apps(eq_subst, &[obs_ty, motive3, obs3, target, equation, hr3]); self.b .lam("__e_h", CoreBinderInfo::Explicit, refused2, rewritten) }; @@ -1145,7 +1144,12 @@ impl<'g, 'a> Composer<'g, 'a> { 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], + &[ + 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"); @@ -1162,7 +1166,9 @@ impl<'g, 'a> Composer<'g, 'a> { let _ = hand_ty; self.b.apps(and, &[realizes1, rci1]) }; - let inner = self.b.lam("__e_hand", CoreBinderInfo::Explicit, hand_ty, intro); + 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( @@ -1184,17 +1190,32 @@ impl<'g, 'a> Composer<'g, 'a> { let statement = self.b.apps(exists, &[r_out, predicate]); (statement, composed) }; - // Close the binders: the parameters, then __e_hrep. + // 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 hrep_ty = self.b.app(representable, args_list); - 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 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); + statement = self + .b + .pi(&binder, CoreBinderInfo::Explicit, domain, statement); value = self.b.lam(&binder, CoreBinderInfo::Explicit, domain, value); } let mut axioms = self.axioms()?; @@ -1264,10 +1285,11 @@ impl<'g, 'a> Composer<'g, 'a> { 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)) + 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)? @@ -1279,12 +1301,21 @@ impl<'g, 'a> Composer<'g, 'a> { built }; for row in built { - self.row_axioms - .insert(row.name.clone(), row.axioms.clone()); + 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)) @@ -1305,7 +1336,6 @@ impl<'g, 'a> Composer<'g, 'a> { } } - /// 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 { @@ -1358,12 +1388,10 @@ fn canonical(ty: &SemanticType) -> SemanticType { right: Box::new(canonical(value)), }), }, - SemanticType::ContractViolation | SemanticType::ReasoningFailure => { - SemanticType::Product { - left: Box::new(SemanticType::Bool), - right: Box::new(SemanticType::Bool), - } - } + 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)), }, @@ -1437,7 +1465,10 @@ impl Composer<'_, '_> { 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)?; + 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)?; @@ -1720,7 +1751,10 @@ impl Composer<'_, '_> { .map(|field| self.position(group, field)) .collect(); let m = fields.len(); - let r = positions.iter().filter(|position| position.is_some()).count(); + 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() { @@ -1748,11 +1782,15 @@ impl Composer<'_, '_> { 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); + 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); + term = self + .b + .lam(&format!("__x{j}"), CoreBinderInfo::Explicit, domain, term); } Ok(term) } diff --git a/crates/lexlean/src/production/kernel.rs b/crates/lexlean/src/production/kernel.rs index c5d0f97c6..000893dd7 100644 --- a/crates/lexlean/src/production/kernel.rs +++ b/crates/lexlean/src/production/kernel.rs @@ -263,22 +263,12 @@ impl Builder { let x = self.lift_memo(x, n, cutoff, memo); self.app(f, x) } - CoreNode::Lambda { - n: name, - b, - t, - v, - } => { + 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, - } => { + 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) @@ -570,7 +560,10 @@ mod tests { 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!( + matches!(b.node(parts[2]), CoreNode::BVar { i: 0 }), + "y is still #0" + ); assert_eq!(applied.term, b.app(f, zero)); } diff --git a/crates/lexlean/src/production/preserve.rs b/crates/lexlean/src/production/preserve.rs index 1edef45b5..99976fcf5 100644 --- a/crates/lexlean/src/production/preserve.rs +++ b/crates/lexlean/src/production/preserve.rs @@ -482,8 +482,7 @@ pub fn audit_core( } for node in &module.nodes { if let CoreNode::Const { n, .. } = node { - if n - .split('.') + if n.split('.') .any(|segment| FORBIDDEN_CONSTANTS.contains(&segment)) { return Err(format!("the forbidden constant `{n}`")); 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 From 94f53420369ede85eb405e51d53f669b344e8ea5 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 20:07:43 +0100 Subject: [PATCH 04/17] WIP #89 stage 1: exhaustive matches --- .../src/production/certificate/data.rs | 181 ++++++++++++++---- 1 file changed, 143 insertions(+), 38 deletions(-) diff --git a/crates/lexlean/src/production/certificate/data.rs b/crates/lexlean/src/production/certificate/data.rs index 4ea10148c..a03fc010e 100644 --- a/crates/lexlean/src/production/certificate/data.rs +++ b/crates/lexlean/src/production/certificate/data.rs @@ -1610,28 +1610,18 @@ impl Composer<'_, '_> { /// 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> { - Ok(match aux.kind { - AuxKind::List => vec![super::element_of(&aux.original)?], - AuxKind::Option => match &aux.original { - SemanticType::Option { value } => vec![value.as_ref().clone()], - _ => return Err("an option auxiliary of a non-option".to_owned()), - }, - AuxKind::Prod => match &aux.original { - SemanticType::Product { left, right } => { - vec![left.as_ref().clone(), right.as_ref().clone()] - } - SemanticType::ContractViolation | SemanticType::ReasoningFailure => { - vec![SemanticType::Bool, SemanticType::Bool] - } - _ => return Err("a pair auxiliary of a non-pair".to_owned()), - }, - AuxKind::Except => match &aux.original { - SemanticType::Result { ok, error } => { - vec![error.as_ref().clone(), ok.as_ref().clone()] - } - _ => return Err("a result auxiliary of a non-result".to_owned()), - }, - }) + 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. @@ -1740,6 +1730,7 @@ impl Composer<'_, '_> { /// 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, @@ -1858,10 +1849,9 @@ impl Composer<'_, '_> { })?); } AuxKind::Option => { - let inner = match &original { - SemanticType::Option { value } => value.as_ref().clone(), - _ => return Err("an option auxiliary of a non-option".to_owned()), - }; + 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", @@ -1913,12 +1903,9 @@ impl Composer<'_, '_> { })?); } AuxKind::Except => { - let (ok, error) = match &original { - SemanticType::Result { ok, error } => { - (ok.as_ref().clone(), error.as_ref().clone()) - } - _ => return Err("a result auxiliary of a non-result".to_owned()), - }; + 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()]; @@ -2002,11 +1989,9 @@ impl Composer<'_, '_> { /// 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; - let (first_member, first_arguments) = match first { - SemanticType::Named { member, arguments } => (member.clone(), arguments.clone()), - _ => return Err("a recursive group of a non-document type".to_owned()), - }; + 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 { @@ -2077,6 +2062,97 @@ impl Composer<'_, '_> { } } + +/// 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 { @@ -2084,7 +2160,36 @@ fn named_member(ty: &SemanticType) -> Result { member, arguments: _, } => Ok(member.clone()), - _ => Err("a document type that is not named".to_owned()), + 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()), } } From 1314d976a13ae7ec75df9fd6bc9e42f9df37901b Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 20:27:40 +0100 Subject: [PATCH 05/17] WIP #89 stage 1: the legacy rendering scopes the decoder under the module's namespace --- crates/conformance/src/cases/preservation.rs | 9 ++++--- crates/lexlean/src/backend/core.rs | 27 ++++++++++++------- crates/lexlean/src/production/certificate.rs | 2 +- .../src/production/certificate/data.rs | 1 - 4 files changed, 24 insertions(+), 15 deletions(-) diff --git a/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index 14564cb4b..588f76c3b 100644 --- a/crates/conformance/src/cases/preservation.rs +++ b/crates/conformance/src/cases/preservation.rs @@ -3096,9 +3096,9 @@ pub fn run(id: &str) { planted }; let refused = |label: &str, planted: &lexlean::ir::core::CoreModule| { - let text = lexlean::backend::core::lean_text_legacy(planted) - .expect("the planted module renders"); 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!( "{}{}", @@ -3178,8 +3178,9 @@ pub fn run(id: &str) { } let mut lying_certificate = composed.clone(); lying_certificate.module = format!("{}PlantLyingPolicy", composed.module); - lying_certificate.text = lexlean::backend::core::lean_text_legacy(&lying) - .expect("the planted module renders"); + 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(), diff --git a/crates/lexlean/src/backend/core.rs b/crates/lexlean/src/backend/core.rs index 21723aaca..25ea9a0de 100644 --- a/crates/lexlean/src/backend/core.rs +++ b/crates/lexlean/src/backend/core.rs @@ -1382,29 +1382,32 @@ 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 { - lean_text_with(core, true) + 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. 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). +/// 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) -> Result { - lean_text_with(core, false) +pub fn lean_text_legacy(core: &CoreModule, scope: &str) -> Result { + lean_text_with(core, Some(scope)) } -fn lean_text_with(core: &CoreModule, module_system: bool) -> Result { +fn lean_text_with(core: &CoreModule, legacy_scope: Option<&str>) -> Result { let mut text = String::new(); - if module_system { + if legacy_scope.is_none() { text.push_str("module\n"); } for import in &core.imports { - if module_system { + if legacy_scope.is_none() { text.push_str(&format!("public import {import}\n")); } else { text.push_str(&format!("import {import}\n")); @@ -1413,6 +1416,9 @@ fn lean_text_with(core: &CoreModule, module_system: bool) -> Result Result { } } - /// 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 From 67cffb755d8bb214ec27441e757ead1c9d5ed5ec Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 21:12:32 +0100 Subject: [PATCH 06/17] #89 stage 1: the statement record of the 76 certificates E (oracle run at 1314d976); the one-time oracle test removed --- crates/conformance/src/preservation.rs | 100 ------------ .../preservation-certificates/E-STATEMENTS.md | 148 ++++++++++++++++++ 2 files changed, 148 insertions(+), 100 deletions(-) create mode 100644 tests/preservation-certificates/E-STATEMENTS.md diff --git a/crates/conformance/src/preservation.rs b/crates/conformance/src/preservation.rs index 825e21ead..092b3d850 100644 --- a/crates/conformance/src/preservation.rs +++ b/crates/conformance/src/preservation.rs @@ -429,106 +429,6 @@ fn lean(root: &Path, arguments: &[String]) -> std::process::Output { .expect("lean runs") } -/// The statement oracle of #89 stage 1 (a one-time record, kept in -/// `tests/preservation-certificates/E-STATEMENTS.md`): for every certificate E -/// of the four corpora, the kernel statement of each theorem of the data -/// certificate is definitionally the statement the committed text certificate -/// elaborated to. Run by hand with the pinned Lean while the committed records -/// are still the text certificates: -/// `cargo test -p repo-conformance --lib oracle_e_statements -- --ignored --nocapture`. -#[cfg(test)] -mod oracle { - use std::path::Path; - - use crate::support::{repo_root, P}; - - #[test] - #[ignore = "a one-time record, run by hand with the pinned Lean"] - fn oracle_e_statements() { - let mut table = Vec::new(); - for example in ["production", "production-coverage", "models", "reasoning"] { - let project = P::copy_example(example); - let certified = super::certificates(&project); - let workspace = super::staged(&project, &certified); - let root = tempfile::Builder::new() - .prefix("lexlean-oracle-") - .tempdir() - .expect("tempdir"); - let checked = super::check(&workspace, root.path()); - assert!( - checked.failure.is_none(), - "{example}: {:?}", - checked.failure - ); - let base = repo_root() - .join("examples") - .join(example) - .join("expected/verify/preserve"); - for certified in &certified { - for (_, composed) in &certified.composed { - let module = &composed.module; - let data = composed.data.as_ref().expect("certificate E is data"); - let old_path = base.join(lexlean::production::preserve::module_path(module)); - let old = std::fs::read_to_string(old_path.as_std_path()) - .unwrap_or_else(|error| panic!("{module}: the committed text: {error}")); - let old_module = format!("{module}.Old"); - let renamed = old - .replace( - &format!("namespace {module}\n"), - &format!("namespace {old_module}\n"), - ) - .replace(&format!("end {module}\n"), &format!("end {old_module}\n")); - let output = super::compile_text(root.path(), &old_module, &renamed); - assert!( - output.status.success(), - "{module}: the committed text compiles: {}", - String::from_utf8_lossy(&output.stderr) - ); - let pairs: Vec = data - .declarations - .iter() - .map(|row| { - let short = row - .name - .strip_prefix(&format!("{module}.")) - .expect("a row of the module"); - format!("(`{module}.{short}, `{old_module}.{short})") - }) - .collect(); - let oracle = format!( - "import {module}\nimport {old_module}\nimport Lean\nopen Lean Meta\nrun_cmd Lean.Elab.Command.liftTermElabM do\n let pairs : List (Name × Name) := [{}]\n for (new, old) in pairs do\n let n ← getConstInfo new\n let o ← getConstInfo old\n unless (← isDefEq n.type o.type) do\n throwError \"{{new}}: the statement differs from {{old}}\"\n logInfo m!\"SP-14 oracle: {{pairs.length}} statements equal\"\n", - pairs.join(", ") - ); - let output = compile_oracle(root.path(), &format!("{module}.Oracle"), &oracle); - let text = format!( - "{}{}", - String::from_utf8_lossy(&output.stdout), - String::from_utf8_lossy(&output.stderr) - ); - assert!( - output.status.success() && text.contains("statements equal"), - "{module}: {text}" - ); - table.push(format!( - "| `{example}` | `{}` | {} | {} |", - module.strip_prefix("LexLeanPreserve.").unwrap_or(module), - data.declarations.len(), - text.trim().lines().last().unwrap_or_default().trim() - )); - } - } - } - eprintln!("| corpus | certificate E | rows | oracle |\n| --- | --- | ---: | --- |"); - for row in table { - eprintln!("{row}"); - } - } - - fn compile_oracle(root: &Path, module: &str, text: &str) -> std::process::Output { - super::compile_text(root, module, text) - } -} - /// 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. 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. From 81a1bdf0395d7256d235870c19ccfb321960967c Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 21:22:29 +0100 Subject: [PATCH 07/17] WIP #89 stage 1: VERIFICATION.md section for the SP-14 plants (outputs to fill) --- VERIFICATION.md | 63 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/VERIFICATION.md b/VERIFICATION.md index f3dd60886..5db154c93 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -1120,6 +1120,69 @@ What was not run on the development host: the verification of its records do not depend on this change and CI reverifies them) and `conformance_vr_19`. The CI legs run both. +### 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` in the root's `wtl_cons` +chain) 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 +WRONG_LEMMA +``` + +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 +CHANGED_STATEMENT +``` + +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 +FORGED_CRATE +``` + +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 +ADDED_AXIOM +``` + +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 +LYING_POLICY +``` + +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 From 526b8a25a947a043fe3c769d876a5e7689554573 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 21:54:44 +0100 Subject: [PATCH 08/17] #89 stage 1: the exported package carries certificate E in the notation; SP-05 and the lying-policy plant read the data --- SPEC.md | 2 +- crates/conformance/src/cases/preservation.rs | 51 +++++++++++++++----- crates/lexlean/src/api/production.rs | 7 ++- 3 files changed, 46 insertions(+), 14 deletions(-) diff --git a/SPEC.md b/SPEC.md index 187011c12..45b72b488 100644 --- a/SPEC.md +++ b/SPEC.md @@ -7918,7 +7918,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/1` 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, and the certification. 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. diff --git a/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index 588f76c3b..35fcdad03 100644 --- a/crates/conformance/src/cases/preservation.rs +++ b/crates/conformance/src/cases/preservation.rs @@ -1763,15 +1763,29 @@ pub fn run(id: &str) { .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!( @@ -1779,8 +1793,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" ); @@ -3198,9 +3215,19 @@ pub fn run(id: &str) { .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, std::slice::from_ref(&lying_certificate)) - .expect("the planted workspace stages"); + preserve::workspace(&user, &planted_set).expect("the planted workspace stages"); let audit_output = preservation::compile_text( root.path(), &format!("{}Plant", preserve::AUDIT_MODULE), diff --git a/crates/lexlean/src/api/production.rs b/crates/lexlean/src/api/production.rs index 5d2abc7b8..0bf7c7547 100644 --- a/crates/lexlean/src/api/production.rs +++ b/crates/lexlean/src/api/production.rs @@ -1211,7 +1211,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(), From a5aaf8ce0e1615d6c9dce466526a374c369e5550 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 22:03:47 +0100 Subject: [PATCH 09/17] #89 stage 1: the export's replay binds certificate E at its notation path --- crates/conformance/src/cases/preservation.rs | 6 +++++- crates/lexlean/src/api/production.rs | 10 +++++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index 35fcdad03..fe1530581 100644 --- a/crates/conformance/src/cases/preservation.rs +++ b/crates/conformance/src/cases/preservation.rs @@ -3126,7 +3126,11 @@ pub fn run(id: &str) { !output.status.success() && joined.contains("error"), "{label}: the planted certificate E is refused by Lean: {joined}" ); - joined.lines().next().unwrap_or_default().to_owned() + // The first error, with the kernel's reason on the lines after it. + joined.lines().take(3).collect::>().join( + " + ", + ) }; let scalar = data .nodes diff --git a/crates/lexlean/src/api/production.rs b/crates/lexlean/src/api/production.rs index 0bf7c7547..c6b935320 100644 --- a/crates/lexlean/src/api/production.rs +++ b/crates/lexlean/src/api/production.rs @@ -1670,7 +1670,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, From 46a48c8586cad07a973a204910b1ea4800573b2c Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 22:04:20 +0100 Subject: [PATCH 10/17] #89 stage 1: the verify records of the four corpora regenerated (certificate E in the notation), the certificate-e-rejected and certificates-total-limit fixtures rewritten --- .../R0/Compose/RustStd.lean | 28 - .../R0/Compose/RustStd.lex.tex | 588 +++++ .../R1/Compose/RustStd.lean | 28 - .../R1/Compose/RustStd.lex.tex | 593 ++++++ .../R2/Compose/RustStd.lean | 31 - .../R2/Compose/RustStd.lex.tex | 624 ++++++ .../R3/Compose/RustStd.lean | 19 - .../R3/Compose/RustStd.lex.tex | 603 ++++++ .../R4/Compose/RustStd.lean | 19 - .../R4/Compose/RustStd.lex.tex | 604 ++++++ .../R5/Compose/RustStd.lean | 16 - .../R5/Compose/RustStd.lex.tex | 474 +++++ .../R6/Compose/RustStd.lean | 16 - .../R6/Compose/RustStd.lex.tex | 474 +++++ .../R7/Compose/RustStd.lean | 16 - .../R7/Compose/RustStd.lex.tex | 424 ++++ .../R8/Compose/RustStd.lean | 16 - .../R8/Compose/RustStd.lex.tex | 477 +++++ .../models/expected/verify/preserve/audit.txt | 6 + .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../R0/Compose/RustStd.lean | 50 - .../R0/Compose/RustStd.lex.tex | 1886 +++++++++++++++++ .../R1/Compose/RustStd.lean | 20 - .../R1/Compose/RustStd.lex.tex | 731 +++++++ .../R10/Compose/RustCore.lean | 16 - .../R10/Compose/RustCore.lex.tex | 465 ++++ .../R10/Compose/RustStd.lean | 16 - .../R10/Compose/RustStd.lex.tex | 465 ++++ .../R11/Compose/RustCore.lean | 16 - .../R11/Compose/RustCore.lex.tex | 466 ++++ .../R11/Compose/RustStd.lean | 16 - .../R11/Compose/RustStd.lex.tex | 466 ++++ .../R12/Compose/RustCore.lean | 21 - .../R12/Compose/RustCore.lex.tex | 581 +++++ .../R12/Compose/RustStd.lean | 21 - .../R12/Compose/RustStd.lex.tex | 581 +++++ .../R13/Compose/RustStd.lean | 20 - .../R13/Compose/RustStd.lex.tex | 588 +++++ .../R14/Compose/RustCore.lean | 25 - .../R14/Compose/RustCore.lex.tex | 779 +++++++ .../R14/Compose/RustStd.lean | 25 - .../R14/Compose/RustStd.lex.tex | 779 +++++++ .../R15/Compose/RustCore.lean | 16 - .../R15/Compose/RustCore.lex.tex | 618 ++++++ .../R15/Compose/RustStd.lean | 16 - .../R15/Compose/RustStd.lex.tex | 618 ++++++ .../R16/Compose/RustCore.lean | 16 - .../R16/Compose/RustCore.lex.tex | 427 ++++ .../R16/Compose/RustStd.lean | 16 - .../R16/Compose/RustStd.lex.tex | 427 ++++ .../R17/Compose/RustCore.lean | 16 - .../R17/Compose/RustCore.lex.tex | 524 +++++ .../R17/Compose/RustStd.lean | 16 - .../R17/Compose/RustStd.lex.tex | 524 +++++ .../R18/Compose/RustCore.lean | 16 - .../R18/Compose/RustCore.lex.tex | 465 ++++ .../R18/Compose/RustStd.lean | 16 - .../R18/Compose/RustStd.lex.tex | 465 ++++ .../R19/Compose/RustStd.lean | 16 - .../R19/Compose/RustStd.lex.tex | 466 ++++ .../R2/Compose/RustStd.lean | 20 - .../R2/Compose/RustStd.lex.tex | 661 ++++++ .../R20/Compose/RustCore.lean | 16 - .../R20/Compose/RustCore.lex.tex | 421 ++++ .../R20/Compose/RustStd.lean | 16 - .../R20/Compose/RustStd.lex.tex | 421 ++++ .../R21/Compose/RustCore.lean | 16 - .../R21/Compose/RustCore.lex.tex | 478 +++++ .../R21/Compose/RustStd.lean | 16 - .../R21/Compose/RustStd.lex.tex | 478 +++++ .../R22/Compose/RustCore.lean | 16 - .../R22/Compose/RustCore.lex.tex | 504 +++++ .../R22/Compose/RustStd.lean | 16 - .../R22/Compose/RustStd.lex.tex | 504 +++++ .../R23/Compose/RustCore.lean | 16 - .../R23/Compose/RustCore.lex.tex | 546 +++++ .../R23/Compose/RustStd.lean | 16 - .../R23/Compose/RustStd.lex.tex | 546 +++++ .../R24/Compose/RustCore.lean | 16 - .../R24/Compose/RustCore.lex.tex | 549 +++++ .../R24/Compose/RustStd.lean | 16 - .../R24/Compose/RustStd.lex.tex | 549 +++++ .../R25/Compose/RustCore.lean | 16 - .../R25/Compose/RustCore.lex.tex | 498 +++++ .../R25/Compose/RustStd.lean | 16 - .../R25/Compose/RustStd.lex.tex | 498 +++++ .../R26/Compose/RustStd.lean | 16 - .../R26/Compose/RustStd.lex.tex | 607 ++++++ .../R27/Compose/RustStd.lean | 16 - .../R27/Compose/RustStd.lex.tex | 431 ++++ .../R28/Compose/RustStd.lean | 16 - .../R28/Compose/RustStd.lex.tex | 491 +++++ .../R29/Compose/RustStd.lean | 16 - .../R29/Compose/RustStd.lex.tex | 493 +++++ .../R3/Compose/RustStd.lean | 20 - .../R3/Compose/RustStd.lex.tex | 620 ++++++ .../R30/Compose/RustStd.lean | 26 - .../R30/Compose/RustStd.lex.tex | 640 ++++++ .../R31/Compose/RustStd.lean | 32 - .../R31/Compose/RustStd.lex.tex | 888 ++++++++ .../R32/Compose/RustCore.lean | 16 - .../R32/Compose/RustCore.lex.tex | 470 ++++ .../R32/Compose/RustStd.lean | 16 - .../R32/Compose/RustStd.lex.tex | 470 ++++ .../R33/Compose/RustStd.lean | 20 - .../R33/Compose/RustStd.lex.tex | 576 +++++ .../R4/Compose/RustStd.lean | 20 - .../R4/Compose/RustStd.lex.tex | 609 ++++++ .../R5/Compose/RustStd.lean | 16 - .../R5/Compose/RustStd.lex.tex | 471 ++++ .../R6/Compose/RustStd.lean | 20 - .../R6/Compose/RustStd.lex.tex | 679 ++++++ .../R7/Compose/RustStd.lean | 20 - .../R7/Compose/RustStd.lex.tex | 629 ++++++ .../R8/Compose/RustStd.lean | 20 - .../R8/Compose/RustStd.lex.tex | 1573 ++++++++++++++ .../R9/Compose/RustStd.lean | 16 - .../R9/Compose/RustStd.lex.tex | 504 +++++ .../expected/verify/preserve/audit.txt | 22 + .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../R0/Compose/RustCore.lean | 16 - .../R0/Compose/RustCore.lex.tex | 467 ++++ .../R0/Compose/RustStd.lean | 16 - .../R0/Compose/RustStd.lex.tex | 467 ++++ .../R1/Compose/RustCore.lean | 20 - .../R1/Compose/RustCore.lex.tex | 568 +++++ .../R1/Compose/RustStd.lean | 20 - .../R1/Compose/RustStd.lex.tex | 567 +++++ .../R2/Compose/RustCore.lean | 16 - .../R2/Compose/RustCore.lex.tex | 420 ++++ .../R2/Compose/RustStd.lean | 16 - .../R2/Compose/RustStd.lex.tex | 419 ++++ .../R3/Compose/RustCore.lean | 16 - .../R3/Compose/RustCore.lex.tex | 420 ++++ .../R3/Compose/RustStd.lean | 16 - .../R3/Compose/RustStd.lex.tex | 419 ++++ .../R4/Compose/RustStd.lean | 16 - .../R4/Compose/RustStd.lex.tex | 464 ++++ .../R5/Compose/RustStd.lean | 16 - .../R5/Compose/RustStd.lex.tex | 464 ++++ .../expected/verify/preserve/audit.txt | 2 + .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../R0/Compose/RustCore.lean | 32 - .../R0/Compose/RustCore.lex.tex | 1344 ++++++++++++ .../R1/Compose/RustCore.lean | 32 - .../R1/Compose/RustCore.lex.tex | 1344 ++++++++++++ .../R2/Compose/RustStd.lean | 38 - .../R2/Compose/RustStd.lex.tex | 1744 +++++++++++++++ .../R3/Compose/RustStd.lean | 30 - .../R3/Compose/RustStd.lex.tex | 1304 ++++++++++++ .../R4/Compose/RustStd.lean | 22 - .../R4/Compose/RustStd.lex.tex | 880 ++++++++ .../R5/Compose/RustCore.lean | 32 - .../R5/Compose/RustCore.lex.tex | 1344 ++++++++++++ .../R6/Compose/RustStd.lean | 28 - .../R6/Compose/RustStd.lex.tex | 1221 +++++++++++ .../R7/Compose/RustStd.lean | 20 - .../R7/Compose/RustStd.lex.tex | 508 +++++ .../expected/verify/preserve/audit.txt | 25 + .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- 168 files changed, 48417 insertions(+), 1511 deletions(-) delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lex.tex delete mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lean create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lex.tex delete mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lean create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lex.tex delete mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lean create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lex.tex delete mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lean create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lex.tex diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lean deleted file mode 100644 index bff2d68ea..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lean +++ /dev/null @@ -1,28 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Models.Glyphs.Glyph)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.program _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.krate _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.flags (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R0.__enc_0 glyph)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.denote glyph) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.__enc_0 glyph)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 glyph) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.root glyph) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lex.tex new file mode 100644 index 000000000..65fad3544 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R0/Compose/RustStd.lex.tex @@ -0,0 +1,588 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.__wt_0 : @16 := @448 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root : @1168 := @1169 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.flags +@3 := Models.Glyphs.Glyph +@4 := #0 +@5 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R0.denote +@618 := @617 @30 +@619 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.__fits_0 +@620 := @619 @30 +@622 := Models.Main.classify @30 +@624 := LexLeanTarget.TargetSyntax.Value.nat @622 +@626 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@58 @468) + @468 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lean deleted file mode 100644 index 3c0f0b25a..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lean +++ /dev/null @@ -1,28 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Models.Glyphs.Glyph)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.program _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.krate _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.flags (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R1.__enc_0 glyph)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.denote glyph) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.__enc_0 glyph)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 glyph) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.root glyph) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lex.tex new file mode 100644 index 000000000..016e46463 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R1/Compose/RustStd.lex.tex @@ -0,0 +1,593 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.__wt_0 : @16 := @448 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root : @1181 := @1182 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.flags +@3 := Models.Glyphs.Glyph +@4 := #0 +@5 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R1.denote +@618 := @617 @30 +@619 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@58 @468) + @468 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lean deleted file mode 100644 index 8576a121d..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lean +++ /dev/null @@ -1,31 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Models.Triage.Presentation)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.program _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.krate _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.flags (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.program _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.krate _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.flags (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R2.__enc_0 presentation)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.denote presentation) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.__enc_0 presentation)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 presentation) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.root presentation) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..d43078f07 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R2/Compose/RustStd.lex.tex @@ -0,0 +1,624 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_0 : @16 := @392 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_1 : @399 := @481 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root : @1214 := @1215 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.flags +@3 := Models.Triage.Presentation +@4 := #0 +@5 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R2.denote +@651 := @650 @30 +@652 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@58 @501) + @501 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lean deleted file mode 100644 index 860f3504f..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lean +++ /dev/null @@ -1,19 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Models.Session.Window)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.program _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.krate _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.flags (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R3.denote costs) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R3.root costs) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5decee625 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R3/Compose/RustStd.lex.tex @@ -0,0 +1,603 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root : @1207 := @1208 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.flags +@3 := Models.Session.Window +@4 := #0 +@6 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R3.denote +@639 := @638 @32 +@640 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@110 @558) + @558 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lean deleted file mode 100644 index efa7bf1eb..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lean +++ /dev/null @@ -1,19 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Models.Session.Window)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.program _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.krate _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.flags (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R4.__enc_0 window), (_root_.LexLeanTarget.TargetSyntax.Value.nat cost)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.denote window cost) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.__enc_0 window), (_root_.LexLeanTarget.TargetSyntax.Value.nat cost)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R4.root window cost) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..05a5884d9 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R4/Compose/RustStd.lex.tex @@ -0,0 +1,604 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root : @1229 := @1230 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.flags +@3 := Models.Session.Window +@4 := #0 +@5 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R4.denote +@609 := @607 @30 @32 +@610 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@110 @470) + @470 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lean deleted file mode 100644 index 58e3adf79..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R5.denote s x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R5.root s x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lex.tex new file mode 100644 index 000000000..385b85feb --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R5/Compose/RustStd.lex.tex @@ -0,0 +1,474 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root : @932 := @933 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R5.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lean deleted file mode 100644 index cd7c286f7..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R6.denote s x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R6.root s x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lex.tex new file mode 100644 index 000000000..cdf68688f --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R6/Compose/RustStd.lex.tex @@ -0,0 +1,474 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root : @932 := @933 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R6.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lean deleted file mode 100644 index bf1b5717e..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R7.denote x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R7.root x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lex.tex new file mode 100644 index 000000000..83ab8d954 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R7/Compose/RustStd.lex.tex @@ -0,0 +1,424 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root : @838 := @839 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R7.denote +@272 := @271 @4 +@273 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lean b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lean deleted file mode 100644 index 6800bdd79..000000000 --- a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8 -import LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R8.denote s x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R8.root s x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd diff --git a/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lex.tex b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lex.tex new file mode 100644 index 000000000..4f4e4de72 --- /dev/null +++ b/examples/models/expected/verify/preserve/LexLeanPreserve/Ccca462bfe8cabc3365338af96b591362/R8/Compose/RustStd.lex.tex @@ -0,0 +1,477 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8, + LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root : @938 := @939 { + all: [LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.program +@1 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.krate +@2 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.R8.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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.Ccca462bfe8cabc3365338af96b591362.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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 f3f3e4808..cada32984 100644 --- a/examples/models/expected/verify/preserve/audit.txt +++ b/examples/models/expected/verify/preserve/audit.txt @@ -7801,6 +7801,12 @@ 'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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 c47e2d6ef..4b5e88cd6 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":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":208207,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":200996,"composed":{"byte_length":3064,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd","sha256":"3298af0830d376b688d70b187a472e9c38a2251e68270bbbf2807a7c1e863976","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd","sha256":"5ae6320603667cbc4fe3e965638710743c6a2db7c2e2e77ac56a790fc5462e35","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"39f163323cb5ed530c70cc9b97df0277a07dd9ba384a6b577bb99913af987496","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.root"},{"byte_length":218385,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208194,"composed":{"byte_length":3064,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd","sha256":"d3a1b439be1826b7b0faf46d526431505def0b3e60dd804ad7344098da4e3086","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd","sha256":"a0a68b18dc852651a0e666ba7b61de0a41dff321339bc8dbf0680aa263a2bb8c","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"487c1782e978ab0a3605ce1e5a1e104048a8d9b072c85e2ed8d855ff7b466a04","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.root"},{"byte_length":87037,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":3700,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd","sha256":"b0090efc769371d0019fd99f52e720e58fb6adeafa84d13e641611f568f19f7a","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd","sha256":"9b13048ac2c1f45577cb3615d7d7299da40535ac6cd8d8a4fa360b1f4ed930e5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"3b3284fa5c2d959b38a97a8b5e37410f643910f386be54155afdc61b4b97b9ef","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.root"},{"byte_length":41456,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":2318,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd","sha256":"ff1a3f9da82fc9310370bee5e88c640ddb00549ebae2cfa9e797b04258e07794","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd","sha256":"d7aa2e04cbd09f62f1d6e305c8243d78b9b38ec1188a6c1347b1da64feb6c513","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"f7587654c04f21e68cc44e485afcb9a6f5a1346a33897edbd646ce809cae2e2f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.root"},{"byte_length":16496,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":2450,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd","sha256":"eaffcc0cc04e7d4afb84a892314725b255a0997e4a347ddfc0e1a02563575316","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd","sha256":"d38569568c1150f9dd4e2af271516b5fcaf5f25d8da65495f68da0bef669f4e2","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"672d14f5acfe083f63d3eb3ca91a9ca9fc07eb1761f924b41dea6d635e424b4f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":1679,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd","sha256":"ee58a84735e87765771142c1735bf702c28877c89d03fc17429723e4cf4e4f0c","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd","sha256":"cccb962143e5e57db430235f81d07aef3b7b06b0c5619d3ae2eb047a4b694a21","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"aca5b5d30b9d6742f26371f80302d74914a5d4451752c447981f53244acd4cca","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":1679,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd","sha256":"5eac2617460e21a6ab6cf1e57b915eda5d6a99230830281b2672a3069f502e21","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd","sha256":"898ebf4aad14a875402e30111db2daa88d28941c2c277594f1cd713a81c95bb5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"4323b6d1a5e2428961e64b00bbcb99b6cf777df8707f764a7e9b40335359d361","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":1482,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd","sha256":"1e8995ad984aa5402928f577b59b608cc08153edb83e4538d39a858648b760e4","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd","sha256":"c775e3adcb89ad8dd51cac17907e8dd9b6ba78082f2791753bdab3fd06e764f1","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"c05b03fab688130ba7918d6864b91256692300b169242b575313d48644165807","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.root"},{"byte_length":28222,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":1679,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd","sha256":"4d3279bda50e50f5ddf9d419a17066cb79326b561114f21bb161b79d0ed49660","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd","sha256":"a2585a915305ef5c41ab91ec89fdb862ae867add94f46f1114107ae04b2f43bc","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"e703b82136f2f6c83c844175dc5827b5862073aee9e9b3953c68f75cb309cc06","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":208207,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":200996,"composed":{"byte_length":17306,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd","sha256":"c27bb292cd4eb64ad5bfb3de08c6398f0d698be0f1a70788ead84571c1af963d","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd","sha256":"5ae6320603667cbc4fe3e965638710743c6a2db7c2e2e77ac56a790fc5462e35","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"39f163323cb5ed530c70cc9b97df0277a07dd9ba384a6b577bb99913af987496","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.root"},{"byte_length":218385,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208194,"composed":{"byte_length":17521,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd","sha256":"66c40a1909a220c1951ddd7195b51da88e9fe95fc392cfef5e4dcd84b470e4bf","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd","sha256":"a0a68b18dc852651a0e666ba7b61de0a41dff321339bc8dbf0680aa263a2bb8c","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"487c1782e978ab0a3605ce1e5a1e104048a8d9b072c85e2ed8d855ff7b466a04","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.root"},{"byte_length":87037,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":18585,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd","sha256":"e184abd8946877206abe64fa4978904338f653fbd7f3d5650a0aa10462dc469b","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd","sha256":"9b13048ac2c1f45577cb3615d7d7299da40535ac6cd8d8a4fa360b1f4ed930e5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"3b3284fa5c2d959b38a97a8b5e37410f643910f386be54155afdc61b4b97b9ef","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.root"},{"byte_length":41456,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":17938,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd","sha256":"7a8a3609adc6167327031d969000b4e5762a47151ea1db820b40b9362bbb01ae","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd","sha256":"d7aa2e04cbd09f62f1d6e305c8243d78b9b38ec1188a6c1347b1da64feb6c513","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"f7587654c04f21e68cc44e485afcb9a6f5a1346a33897edbd646ce809cae2e2f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.root"},{"byte_length":16496,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":17860,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd","sha256":"fb14621c423a5c24efe80965ed4c792a7974163c2559eee9336da3a487045a87","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd","sha256":"d38569568c1150f9dd4e2af271516b5fcaf5f25d8da65495f68da0bef669f4e2","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"672d14f5acfe083f63d3eb3ca91a9ca9fc07eb1761f924b41dea6d635e424b4f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":13517,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd","sha256":"e9b895841cbb1d7070d7ab2663bcbf581828f25b4044975e94cad264939cc437","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd","sha256":"cccb962143e5e57db430235f81d07aef3b7b06b0c5619d3ae2eb047a4b694a21","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"aca5b5d30b9d6742f26371f80302d74914a5d4451752c447981f53244acd4cca","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":13517,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd","sha256":"870bd00b6d3a0f520e0ce2329cca58e467c235d8cf3afeb32d772670ac2cb6aa","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd","sha256":"898ebf4aad14a875402e30111db2daa88d28941c2c277594f1cd713a81c95bb5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"4323b6d1a5e2428961e64b00bbcb99b6cf777df8707f764a7e9b40335359d361","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":12282,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd","sha256":"b4825b044edcf21428fe1af863e36de8c76b4cf4efffa85dd2fad99d6d3caaa4","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd","sha256":"c775e3adcb89ad8dd51cac17907e8dd9b6ba78082f2791753bdab3fd06e764f1","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"c05b03fab688130ba7918d6864b91256692300b169242b575313d48644165807","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.root"},{"byte_length":28222,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":13588,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd","sha256":"c294ccba78e294711da1ddcf0ca47374307b717fb06f37df261d9dd9cc7a2378","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd","sha256":"a2585a915305ef5c41ab91ec89fdb862ae867add94f46f1114107ae04b2f43bc","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"e703b82136f2f6c83c844175dc5827b5862073aee9e9b3953c68f75cb309cc06","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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 f7cf39510..26ec51216 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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.Ccca462bfe8cabc3365338af96b591362.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"fa6b5de1a3733bcf9e758da1801431847ef957b1b7722bc750bb2abc404fef16","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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.Ccca462bfe8cabc3365338af96b591362.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"822585fff0ea9af741821ca412d84ecacc9d00b1b1ba121ba2ffd4764203c407","tool":"lean"} diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lean deleted file mode 100644 index 3f44af27d..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lean +++ /dev/null @@ -1,50 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd - -mutual -theorem __wt_0 : ∀ (__v : (Coverage.Boundary.Grove)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.__enc_0 g), (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 18) [(_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.__enc_0 g), (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.accepts g ledger picks spare → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.denote g ledger picks spare)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.entry_accepts g ledger picks spare __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.entry_refuses g ledger picks spare __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lex.tex new file mode 100644 index 000000000..80d7fd996 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R0/Compose/RustStd.lex.tex @@ -0,0 +1,1886 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_0 : @2059 := @2058 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_0 : @2081 := @2080 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_1 : @2103 := @2102 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_3 : @2125 := @2124 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_4 : @2147 := @2146 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_4], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_2 : @2169 := @2168 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_1 : @2176 := @2362 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.root : @3729 := @3730 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.flags +@3 := Coverage.Boundary.Grove +@4 := #0 +@5 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.__O_1 +@583 := @580 @3 @581 +@584 := @583 @71 +@585 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_0 @71 +@2365 := @2171 @73 +@2367 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R0.denoteEntry +@2885 := @2881 @71 @73 @69 @72 +@2886 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.entryFits +@2890 := @2886 @71 @73 @69 @72 +@2895 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.entryValue @71 @73 @69 @72 +@2900 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@17 @2630) + @2630 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R0.accepts +@3566 := @3562 @71 @73 @69 @72 +@3567 := LexLeanPreservation.someObs +@3568 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lean deleted file mode 100644 index fd632eec2..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R1.accepts m k v → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.denote m k v)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R1.entry_accepts m k v __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.entry_refuses m k v __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lex.tex new file mode 100644 index 000000000..dd5b45522 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R1/Compose/RustStd.lex.tex @@ -0,0 +1,731 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd.root : @1520 := @1521 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R1.denoteEntry +@730 := @727 @10 @35 @37 +@731 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.entryFits +@734 := @731 @10 @35 @37 +@738 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.entryValue @10 @35 @37 +@742 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@8 @423) + @423 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R1.accepts +@1369 := @1366 @10 @35 @37 +@1370 := LexLeanPreservation.someObs +@1371 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lean deleted file mode 100644 index e86986dbd..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R10.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R10.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lex.tex new file mode 100644 index 000000000..bd18c2f59 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustCore.lex.tex @@ -0,0 +1,465 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore.root : @914 := @915 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R10.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.natOps @4 @15) +@333 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lean deleted file mode 100644 index a37cb3ae9..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R10.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R10.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5441451a9 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R10/Compose/RustStd.lex.tex @@ -0,0 +1,465 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd.root : @914 := @915 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R10.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.natOps @4 @15) +@333 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lean deleted file mode 100644 index 1d90dc2bc..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R11.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R11.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lex.tex new file mode 100644 index 000000000..e65b1aa3a --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustCore.lex.tex @@ -0,0 +1,466 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore.root : @915 := @916 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R11.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.__fits_0 +@327 := @325 @4 @15 +@331 := @5 (Coverage.Main.intOps @4 @15) +@334 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@136 @83) + @83 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lean deleted file mode 100644 index 9f89fa7d4..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R11.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R11.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lex.tex new file mode 100644 index 000000000..7f7fb74f7 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R11/Compose/RustStd.lex.tex @@ -0,0 +1,466 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd.root : @915 := @916 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R11.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.__fits_0 +@327 := @325 @4 @15 +@331 := @5 (Coverage.Main.intOps @4 @15) +@334 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@136 @83) + @83 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lean deleted file mode 100644 index 8fcaebee5..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lean +++ /dev/null @@ -1,21 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore - -theorem __wt_0 : ∀ (__v : (Coverage.Types.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.denote w h) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.root w h) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lex.tex new file mode 100644 index 000000000..dd6b56fad --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustCore.lex.tex @@ -0,0 +1,581 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.__wt_0 : @16 := @482 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.root : @1157 := @1158 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.flags +@3 := Coverage.Types.Shape +@4 := #0 +@6 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.denote +@573 := @571 @27 @29 +@574 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.__fits_0 +@576 := @574 @27 @29 +@580 := @18 (Coverage.Main.shapes @27 @29) +@583 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@97 @501) + @501 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lean deleted file mode 100644 index 74a53cba9..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lean +++ /dev/null @@ -1,21 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Coverage.Types.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.denote w h) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.root w h) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lex.tex new file mode 100644 index 000000000..28b70502d --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R12/Compose/RustStd.lex.tex @@ -0,0 +1,581 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.__wt_0 : @16 := @482 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.root : @1157 := @1158 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.flags +@3 := Coverage.Types.Shape +@4 := #0 +@6 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R12.denote +@573 := @571 @27 @29 +@574 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.__fits_0 +@576 := @574 @27 @29 +@580 := @18 (Coverage.Main.shapes @27 @29) +@583 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@97 @501) + @501 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lean deleted file mode 100644 index 837af3816..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Coverage.Types.Tree)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R13.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R13.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5b08efdf2 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R13/Compose/RustStd.lex.tex @@ -0,0 +1,588 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.__wt_0 : @520 := @519 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.root : @1152 := @1153 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.flags +@3 := Coverage.Types.Tree +@4 := #0 +@5 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R13.denote +@608 := @607 @29 +@609 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.__fits_0 +@610 := @609 @29 +@613 := @192 (Coverage.Main.treeTotal @29) +@615 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@57 @540) + @540 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lean deleted file mode 100644 index 22d97d7fa..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lean +++ /dev/null @@ -1,25 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Coverage.Types.Point)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lex.tex new file mode 100644 index 000000000..0b3f53f2b --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustCore.lex.tex @@ -0,0 +1,779 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_1 : @449 := @632 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_2 : @640 := @821 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.root : @1560 := @1561 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.flags +@3 := Coverage.Types.Point +@4 := #0 +@6 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.denote +@968 := @966 @30 @32 +@969 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.__fits_0 +@971 := @969 @30 @32 +@974 := Coverage.Main.records @30 @32 +@980 := LexLeanPreservation.encPair @27 @27 @21 @21 @974 +@983 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@110 @851) + @851 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lean deleted file mode 100644 index af05880f9..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lean +++ /dev/null @@ -1,25 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Coverage.Types.Point)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lex.tex new file mode 100644 index 000000000..766528095 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R14/Compose/RustStd.lex.tex @@ -0,0 +1,779 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_0 : @16 := @440 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_1 : @449 := @632 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_2 : @640 := @821 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.root : @1560 := @1561 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.flags +@3 := Coverage.Types.Point +@4 := #0 +@6 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R14.denote +@968 := @966 @30 @32 +@969 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.__fits_0 +@971 := @969 @30 @32 +@974 := Coverage.Main.records @30 @32 +@980 := LexLeanPreservation.encPair @27 @27 @21 @21 @974 +@983 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@110 @851) + @851 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lean deleted file mode 100644 index 8d7d5bc1c..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R15.denote v r) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R15.root v r) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lex.tex new file mode 100644 index 000000000..ec015a893 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustCore.lex.tex @@ -0,0 +1,618 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore.root : @1260 := @1261 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R15.denote +@660 := @658 @6 @23 +@661 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.__fits_0 +@663 := @661 @6 @23 +@667 := @7 (Coverage.Main.options @6 @23) +@670 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@464 @412) + @412 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lean deleted file mode 100644 index 9073c39aa..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R15.denote v r) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R15.root v r) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lex.tex new file mode 100644 index 000000000..9a3628b3f --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R15/Compose/RustStd.lex.tex @@ -0,0 +1,618 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd.root : @1260 := @1261 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R15.denote +@660 := @658 @6 @23 +@661 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.__fits_0 +@663 := @661 @6 @23 +@667 := @7 (Coverage.Main.options @6 @23) +@670 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@464 @412) + @412 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lean deleted file mode 100644 index 396864b09..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R16.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R16.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lex.tex new file mode 100644 index 000000000..d1b5e20e2 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustCore.lex.tex @@ -0,0 +1,427 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore.root : @844 := @845 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R16.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lean deleted file mode 100644 index 655c46c51..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R16.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R16.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lex.tex new file mode 100644 index 000000000..0c8ad5d47 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R16/Compose/RustStd.lex.tex @@ -0,0 +1,427 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd.root : @844 := @845 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R16.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lean deleted file mode 100644 index 6385d801e..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R17.denote p) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R17.root p) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lex.tex new file mode 100644 index 000000000..200fb1c3a --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustCore.lex.tex @@ -0,0 +1,524 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore.root : @1045 := @1046 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R17.denote +@492 := @491 @8 +@493 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.__fits_0 +@494 := @493 @8 +@496 := Coverage.Main.pairs @8 +@501 := @11 @4 @3 @10 @9 @496 +@503 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@349 @297) + @297 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lean deleted file mode 100644 index 9fb6025e1..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R17.denote p) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R17.root p) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lex.tex new file mode 100644 index 000000000..8819e8fb9 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R17/Compose/RustStd.lex.tex @@ -0,0 +1,524 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd.root : @1045 := @1046 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R17.denote +@492 := @491 @8 +@493 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.__fits_0 +@494 := @493 @8 +@496 := Coverage.Main.pairs @8 +@501 := @11 @4 @3 @10 @9 @496 +@503 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@349 @297) + @297 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lean deleted file mode 100644 index c1a579cc9..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R18.denote base offset) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R18.root base offset) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lex.tex new file mode 100644 index 000000000..57bf76eb3 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustCore.lex.tex @@ -0,0 +1,465 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore.root : @914 := @915 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R18.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.higher @4 @15) +@333 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lean deleted file mode 100644 index a54bf96b6..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R18.denote base offset) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R18.root base offset) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lex.tex new file mode 100644 index 000000000..3e7c4c42f --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R18/Compose/RustStd.lex.tex @@ -0,0 +1,465 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd.root : @914 := @915 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R18.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.__fits_0 +@326 := @324 @4 @15 +@330 := @5 (Coverage.Main.higher @4 @15) +@333 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lean deleted file mode 100644 index 9516ea211..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R19.denote values) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R19.root values) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lex.tex new file mode 100644 index 000000000..89be31faa --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R19/Compose/RustStd.lex.tex @@ -0,0 +1,466 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd.root : @926 := @927 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R19.denote +@370 := @369 @6 +@371 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @181) + @181 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lean deleted file mode 100644 index 74fd1cf10..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R2.accepts m bonus → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.denote m bonus)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R2.entry_accepts m bonus __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.entry_refuses m bonus __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..ba217a73e --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R2/Compose/RustStd.lex.tex @@ -0,0 +1,661 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd.root : @1352 := @1353 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R2.denoteEntry +@626 := @624 @9 @34 +@627 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.entryFits +@629 := @627 @9 @34 +@632 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.entryValue @9 @34 +@635 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@7 @378) + @378 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R2.accepts +@1216 := @1214 @9 @34 +@1217 := LexLeanPreservation.someObs +@1218 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lean deleted file mode 100644 index 8e8f0cb47..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R20.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R20.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lex.tex new file mode 100644 index 000000000..bca511463 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustCore.lex.tex @@ -0,0 +1,421 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore.root : @826 := @827 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R20.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.__fits_0 +@274 := @273 @4 +@276 := Coverage.Main.parity @4 +@278 := LexLeanTarget.TargetSyntax.Value.bool @276 +@280 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lean deleted file mode 100644 index 1640e4283..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R20.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R20.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5b188c80a --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R20/Compose/RustStd.lex.tex @@ -0,0 +1,421 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd.root : @826 := @827 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R20.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.__fits_0 +@274 := @273 @4 +@276 := Coverage.Main.parity @4 +@278 := LexLeanTarget.TargetSyntax.Value.bool @276 +@280 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lean deleted file mode 100644 index bea61fad7..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R21.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R21.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lex.tex new file mode 100644 index 000000000..ed211006e --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustCore.lex.tex @@ -0,0 +1,478 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore.root : @939 := @940 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R21.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@138 @85) + @85 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lean deleted file mode 100644 index 85cfe6c08..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R21.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R21.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lex.tex new file mode 100644 index 000000000..6bf397eab --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R21/Compose/RustStd.lex.tex @@ -0,0 +1,478 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd.root : @939 := @940 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R21.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@138 @85) + @85 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lean deleted file mode 100644 index 2b88c0834..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R22.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R22.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lex.tex new file mode 100644 index 000000000..b241b1432 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustCore.lex.tex @@ -0,0 +1,504 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore.root : @1000 := @1001 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R22.denote +@372 := @370 @4 @17 +@373 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@165 @112) + @112 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lean deleted file mode 100644 index 3fb5710b8..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R22.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R22.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lex.tex new file mode 100644 index 000000000..81cda3981 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R22/Compose/RustStd.lex.tex @@ -0,0 +1,504 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd.root : @1000 := @1001 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R22.denote +@372 := @370 @4 @17 +@373 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@165 @112) + @112 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lean deleted file mode 100644 index eef237f70..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R23.denote a b c) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R23.root a b c) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lex.tex new file mode 100644 index 000000000..d23a7b2d6 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustCore.lex.tex @@ -0,0 +1,546 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore.root : @1096 := @1097 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R23.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@176 @123) + @123 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lean deleted file mode 100644 index b23bcf815..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R23.denote a b c) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R23.root a b c) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lex.tex new file mode 100644 index 000000000..b3004183e --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R23/Compose/RustStd.lex.tex @@ -0,0 +1,546 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd.root : @1096 := @1097 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R23.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@176 @123) + @123 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lean deleted file mode 100644 index fb1872274..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R24.denote a b s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R24.root a b s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lex.tex new file mode 100644 index 000000000..4c2b9183e --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustCore.lex.tex @@ -0,0 +1,549 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore.root : @1100 := @1101 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R24.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@176 @123) + @123 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lean deleted file mode 100644 index 5645eaaa2..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R24.denote a b s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R24.root a b s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lex.tex new file mode 100644 index 000000000..1f63bef01 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R24/Compose/RustStd.lex.tex @@ -0,0 +1,549 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd.root : @1100 := @1101 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R24.denote +@423 := @420 @4 @15 @17 +@424 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@176 @123) + @123 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lean deleted file mode 100644 index e648005f1..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R25.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R25.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lex.tex new file mode 100644 index 000000000..18bb8ad8b --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustCore.lex.tex @@ -0,0 +1,498 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore.root : @992 := @993 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R25.denote +@371 := @369 @4 @15 +@372 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@164 @111) + @111 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lean deleted file mode 100644 index a9449052d..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R25.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R25.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lex.tex new file mode 100644 index 000000000..49726f73a --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R25/Compose/RustStd.lex.tex @@ -0,0 +1,498 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd.root : @992 := @993 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R25.denote +@371 := @369 @4 @15 +@372 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@164 @111) + @111 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lean deleted file mode 100644 index 4b69b12ae..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R26.denote xs b i) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R26.root xs b i) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lex.tex new file mode 100644 index 000000000..eeb70faa2 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R26/Compose/RustStd.lex.tex @@ -0,0 +1,607 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd.root : @1256 := @1257 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R26.denote +@536 := @533 @6 @21 @23 +@537 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @229) + @229 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lean deleted file mode 100644 index 370b5b8d2..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R27.denote s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R27.root s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lex.tex new file mode 100644 index 000000000..20068de75 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R27/Compose/RustStd.lex.tex @@ -0,0 +1,431 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd.root : @842 := @843 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R27.denote +@273 := @272 @4 +@274 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@125 @72) + @72 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lean deleted file mode 100644 index a7b2a351f..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R28.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R28.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lex.tex new file mode 100644 index 000000000..fd39739be --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R28/Compose/RustStd.lex.tex @@ -0,0 +1,491 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd.root : @983 := @984 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R28.denote +@371 := @369 @4 @15 +@372 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@164 @111) + @111 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lean deleted file mode 100644 index b6cb6d775..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R29.denote s d) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R29.root s d) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lex.tex new file mode 100644 index 000000000..6ea5bf1e8 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R29/Compose/RustStd.lex.tex @@ -0,0 +1,493 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd.root : @966 := @967 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R29.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@136 @83) + @83 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lean deleted file mode 100644 index 6206fa056..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R3.accepts s t x → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.denote s t x)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R3.entry_accepts s t x __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.entry_refuses s t x __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..7ef0fe2f9 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R3/Compose/RustStd.lex.tex @@ -0,0 +1,620 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd.root : @1271 := @1272 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R3.denoteEntry +@492 := @489 @6 @21 @23 +@493 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.entryFits +@496 := @493 @6 @21 @23 +@500 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.entryValue @6 @21 @23 +@504 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @203) + @203 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R3.accepts +@1122 := @1119 @6 @21 @23 +@1123 := LexLeanPreservation.someObs +@1124 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lean deleted file mode 100644 index 5bf3ed2f4..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lean +++ /dev/null @@ -1,26 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd - -mutual -theorem __wt_0 : ∀ (__v : (Coverage.Syntax.Rose Nat)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R30.denote n) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R30.root n) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lex.tex new file mode 100644 index 000000000..eb4b080ae --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R30/Compose/RustStd.lex.tex @@ -0,0 +1,640 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wt_0 : @689 := @688 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wtItems_0 : @699 := @698 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wtItems_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.root : @1328 := @1329 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.flags +@3 := Nat +@5 := Coverage.Syntax.Rose @3 +@6 := #0 +@7 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R30.denote +@781 := @780 @31 +@782 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.__fits_0 +@783 := @782 @31 +@786 := @32 (Coverage.RecRoots.roseTotal @31) +@788 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@19 @719) + @719 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lean deleted file mode 100644 index 44506b678..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd - -mutual -theorem __wt_0 : ∀ (__v : (Coverage.Syntax.Expr)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R31.__enc_0 e)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.denote e) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.__enc_0 e)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 e) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.root e) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5c6248f93 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R31/Compose/RustStd.lex.tex @@ -0,0 +1,888 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_0 : @1187 := @1186 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_1 : @1201 := @1200 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wtItems_0 : @1215 := @1214 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wtItems_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.root : @1800 := @1801 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.flags +@3 := Coverage.Syntax.Expr +@4 := #0 +@5 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.root @4 @9 +@1255 := @777 @1217 @111 +@1256 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.denote +@1257 := @1256 @47 +@1258 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.__fits_0 +@1259 := @1258 @47 +@1262 := @36 (Coverage.RecRoots.syntaxTotal @47) +@1264 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@25 @1231) + @1231 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lean deleted file mode 100644 index d38e4e86e..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R32.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R32.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lex.tex new file mode 100644 index 000000000..178790163 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustCore.lex.tex @@ -0,0 +1,470 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore.root : @923 := @924 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R32.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lean deleted file mode 100644 index d48957d2d..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R32.denote a b) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R32.root a b) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lex.tex new file mode 100644 index 000000000..1ebaf5002 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R32/Compose/RustStd.lex.tex @@ -0,0 +1,470 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R32.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lean deleted file mode 100644 index 89b9ded2b..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Coverage.Syntax.Term)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.program _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.krate _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.flags (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R33.__enc_0 t)]) : ∃ __e_ro, _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.denote t) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.krate (_root_.LexLeanPreservation.Rust.fnIdent 0) [(_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.__enc_0 t)] __e_ro := - _root_.LexLeanPreservation.Rust.compose (fun __e_n => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.root __e_n 0) rfl (_root_.LexLeanPreservation.Rust.wtl_cons (__wt_0 t) _root_.LexLeanPreservation.Rust.wtl_nil) rfl rfl (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.root t) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lex.tex new file mode 100644 index 000000000..454602ed3 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R33/Compose/RustStd.lex.tex @@ -0,0 +1,576 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.__wt_0 : @520 := @519 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.root : @1138 := @1139 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.flags +@3 := Coverage.Syntax.Term +@4 := #0 +@5 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R33.denote +@590 := @589 @28 +@591 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.__fits_0 +@592 := @591 @28 +@594 := Coverage.RecRoots.rewrite @28 +@600 := LexLeanPreservation.encPair @3 @3 @5 @5 @594 +@602 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@96 @538) + @538 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lean deleted file mode 100644 index 719ba6867..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R4.accepts xs s → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.denote xs s)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R4.entry_accepts xs s __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.entry_refuses xs s __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..1c85eb5e0 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R4/Compose/RustStd.lex.tex @@ -0,0 +1,609 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd.root : @1228 := @1229 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R4.denoteEntry +@499 := @497 @6 @23 +@500 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.entryFits +@502 := @500 @6 @23 +@505 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.entryValue @6 @23 +@508 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @250) + @250 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R4.accepts +@1092 := @1090 @6 @23 +@1093 := LexLeanPreservation.someObs +@1094 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lean deleted file mode 100644 index 1fa166176..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R5.denote n start) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R5.root n start) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lex.tex new file mode 100644 index 000000000..62f2b7b71 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R5/Compose/RustStd.lex.tex @@ -0,0 +1,471 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd.root : @924 := @925 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R5.denote +@323 := @321 @4 @15 +@324 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@135 @82) + @82 + (LexLeanTarget.TargetSemantics.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/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lean deleted file mode 100644 index 150f2472d..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R6.accepts g start → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.denote g start)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R6.entry_accepts g start __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.entry_refuses g start __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lex.tex new file mode 100644 index 000000000..34a2112c7 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R6/Compose/RustStd.lex.tex @@ -0,0 +1,679 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd.root : @1387 := @1388 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R6.denoteEntry +@661 := @659 @10 @38 +@662 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.entryFits +@664 := @662 @10 @38 +@667 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.entryValue @10 @38 +@670 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @413) + @413 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R6.accepts +@1251 := @1249 @10 @38 +@1252 := LexLeanPreservation.someObs +@1253 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lean deleted file mode 100644 index 725ac5a41..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R7.accepts g → _root_.LexLeanPreservation.Rust.RealizesFn Bool.true (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.denote g)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R7.entry_accepts g __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.entry_refuses g __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lex.tex new file mode 100644 index 000000000..23d1124db --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R7/Compose/RustStd.lex.tex @@ -0,0 +1,629 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd.root : @1256 := @1257 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R7.denoteEntry +@593 := @592 @10 +@594 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.entryFits +@595 := @594 @10 +@597 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.entryValue @10 +@599 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @404) + @404 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R7.accepts +@1135 := @1134 @10 +@1136 := LexLeanPreservation.someObs +@1137 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lean deleted file mode 100644 index 8b82158a1..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R8.accepts a k i j b c d e u w → _root_.LexLeanPreservation.Rust.RealizesFn Bool.false (_root_.LexLeanPreservation.someObs (_root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.denote a k i j b c d e u w)) __e_ro) ∧ - (¬ _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R8.entry_accepts a k i j b c d e u w __e_h ▸ __e_hr, fun __e_h => _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.entry_refuses a k i j b c d e u w __e_h ▸ __e_hr⟩ - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lex.tex new file mode 100644 index 000000000..7461b8995 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R8/Compose/RustStd.lex.tex @@ -0,0 +1,1573 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd.root : @3073 := @3074 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R8.denoteEntry +@1841 := @1831 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 +@1842 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.entryFits +@1852 := @1842 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 +@1863 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.entryValue + @13 + @112 + @114 + @116 + @130 + @111 + @118 + @45 + @47 + @49 +@1874 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@11 @1117) + @1117 + (LexLeanTarget.TargetSemantics.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.C6cddd56cf041af764eeefdf9e95c897e.R8.accepts +@2817 := @2807 @13 @112 @114 @116 @130 @111 @118 @45 @47 @49 +@2818 := LexLeanPreservation.someObs +@2819 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lean b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lean deleted file mode 100644 index 99d4ecd6a..000000000 --- a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9 -import LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R9.denote x s) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R9.root x s) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd diff --git a/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lex.tex b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lex.tex new file mode 100644 index 000000000..b96e9ec57 --- /dev/null +++ b/examples/production-coverage/expected/verify/preserve/LexLeanPreserve/C6cddd56cf041af764eeefdf9e95c897e/R9/Compose/RustStd.lex.tex @@ -0,0 +1,504 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9, + LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd.root : @1005 := @1006 { + all: [LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd.program +@1 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd.krate +@2 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.R9.denote +@368 := @366 @4 @15 +@369 := LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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.C6cddd56cf041af764eeefdf9e95c897e.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@161 @108) + @108 + (LexLeanTarget.TargetSemantics.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 8d2aaa7ce..96f6db60a 100644 --- a/examples/production-coverage/expected/verify/preserve/audit.txt +++ b/examples/production-coverage/expected/verify/preserve/audit.txt @@ -8066,6 +8066,28 @@ 'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext] +'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 1b1917d52..9ac760b0a 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":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":58284,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0","program":{"byte_length":19449,"sha256":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d"},"renderings":[{"byte_length":85650,"composed":{"byte_length":9211,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd","sha256":"338e9a535240577f98274cca0d202961293c4750760cb6ccf2e632e7c84c3b26","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.root"},"crate":{"byte_length":22556,"sha256":"77ab666847a104f8f578a1f8e741421430e9fed92895817a111f50a95178b620"},"entry":{"function":18,"symbol":"f18"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd","sha256":"3521c8f65918bb9ccb7d86c371f3f98b5225cecd212a4a058a6c8e5d37abea07","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.root"}],"root":"Coverage.Boundary.groveRoot","sha256":"dc8acbc18fe0b7cf22206e035fbc293ba879532c8c9ef5a5b764f38e37cd5dd6","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.root"},{"byte_length":29833,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1","program":{"byte_length":16945,"sha256":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f"},"renderings":[{"byte_length":59928,"composed":{"byte_length":3031,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd","sha256":"0502f4c2c512bc39267a197858f1fd7124c1863552082a37c76610bf90588ab0","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd.root"},"crate":{"byte_length":19105,"sha256":"5d5216f8cd8580e08122755e5fd0aa617b9ba4b46fd2dcb000f6d7503c307f92"},"entry":{"function":10,"symbol":"f10"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd","sha256":"ff789e905681502042cc9fa17571cd46f927ebfe125fb0f57b6ccf5b975ee8fa","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd.root"}],"root":"Coverage.Colls.mapOps","sha256":"e94c290ab43c1858ddb9c9170dbe4af0f228d36177769447a436aa1af6cb5dc0","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.root"},{"byte_length":13160,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2","program":{"byte_length":4015,"sha256":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1"},"renderings":[{"byte_length":25017,"composed":{"byte_length":2837,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd","sha256":"eae4feba4882af06a8fe4f64ad38b6a91848f78c78203881e7ec8019e60c4c02","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd.root"},"crate":{"byte_length":15540,"sha256":"014aa5f97db48ae59c8841bf98cd515f65a1be0c24b3fd1095cc48ebb6c83fc1"},"entry":{"function":5,"symbol":"f5"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd","sha256":"dc8172aa7fd206199880a4d1c909ade61887a907f653e862ef954d3275005a7b","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd.root"}],"root":"Coverage.Colls.mapFolding","sha256":"e9e804e872ac5d0b0b4d4a7650ec5d743927315ba595cdc4f096507fd34ad35a","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.root"},{"byte_length":27034,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3","program":{"byte_length":16755,"sha256":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d"},"renderings":[{"byte_length":61996,"composed":{"byte_length":2876,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd","sha256":"2fc0de76d86d9b27f5ae37540231fa9c5693d3df30cee5a16b1111c8fe610a83","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd.root"},"crate":{"byte_length":19344,"sha256":"b735c8c86aaac3de962c4a35440898953b1162fd156ada72eb075744426d87e1"},"entry":{"function":11,"symbol":"f11"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd","sha256":"98e4146f33915d8c7f5338966b48f840aaeb65ba5a0f25d85ab54d00985f167c","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd.root"}],"root":"Coverage.Colls.setOps","sha256":"b787296ebe7b0066f148c1965de1d220cb2ecc17a66f93e9379cc18e14e6579c","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.root"},{"byte_length":13375,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4","program":{"byte_length":4435,"sha256":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd"},"renderings":[{"byte_length":21903,"composed":{"byte_length":2676,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd","sha256":"ffd05e1aa09cfa452c386ac3ba300a70acd5057d2a049a67271df09bc4b896ca","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd.root"},"crate":{"byte_length":15272,"sha256":"cf60ae7366ecb8b9565507fd1247024683dfd01ad6d22c2db0aeb6f250c1b307"},"entry":{"function":6,"symbol":"f6"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd","sha256":"c09ab56aa4ee2b1c767a992f468b44f50e448d16ade835d0e07b320d44c2f772","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd.root"}],"root":"Coverage.Colls.folds","sha256":"991ae51235f220be974028a86492aa3e4ec098badea3221fb2567591c7a217bb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.root"},{"byte_length":9233,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5","program":{"byte_length":3448,"sha256":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223"},"renderings":[{"byte_length":14771,"composed":{"byte_length":1703,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd","sha256":"522c4dea187ac65be75d3120d0a37832ad51976029376392ede03179e94aa902","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd.root"},"crate":{"byte_length":14251,"sha256":"b07e6313d5996c7f489f6ff31b6047d7bdd30fac8dc0ab06dd2de5c165773171"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd","sha256":"e9bd63011d0dae2b0b347bede085f1b8b6675aa5b095527c5a9d22568823f15a","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd.root"}],"root":"Coverage.Colls.iterations","sha256":"93399bf9ad94dae0dcbb710f59dbd2e0bef3fdb250797dcdf321229ae236713b","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.root"},{"byte_length":30878,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6","program":{"byte_length":32854,"sha256":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2"},"renderings":[{"byte_length":153083,"composed":{"byte_length":2965,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd","sha256":"5aaaad63bc4045af8c1a61308518bb99a5c85d0efaa0c2f5519ed9dfef61bae5","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd.root"},"crate":{"byte_length":28628,"sha256":"d53a1fc1f9cf1f4e7366e8dcf3dea4f3e858227e7739718651f7bd74ea86be6f"},"entry":{"function":30,"symbol":"f30"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd","sha256":"d12f273db303928b8e6912c6d94dc71bc053ba31887e610ac688ed06240af97f","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd.root"}],"root":"Coverage.Colls.graphs","sha256":"687d839ae4621a67d8cd831eab4826c429c21f61cbc29f119687b855ca5a7945","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.root"},{"byte_length":20090,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7","program":{"byte_length":17014,"sha256":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475"},"renderings":[{"byte_length":82886,"composed":{"byte_length":2743,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd","sha256":"85fba63567beaa3a3a5a384412f1887486527e9b8b1e76897e8be204c2063e41","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd.root"},"crate":{"byte_length":21438,"sha256":"b7f9d495a96503043078bb00af86cac5d22f3a92bef084ff7b8d41e5a157014e"},"entry":{"function":15,"symbol":"f15"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd","sha256":"e192365debf8736fc160ebbab30e74f38f6f1c794b45b6854d9976db18a27621","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd.root"}],"root":"Coverage.Colls.stringGraph","sha256":"92676a2bcb12f98afabf9d59345539c93cecbcdddce58379800ac731f83e6303","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.root"},{"byte_length":46985,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8","program":{"byte_length":22112,"sha256":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f"},"renderings":[{"byte_length":117400,"composed":{"byte_length":6533,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd","sha256":"6baf0c266b973fe6297d6b622423845221ea055d48fd9112d4d3db03cfc5f45d","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd.root"},"crate":{"byte_length":26043,"sha256":"bf8749dca9d3b9f015f7261c88b60dea927138244a7b63985e6966ad4147d00f"},"entry":{"function":13,"symbol":"f13"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd","sha256":"7f8a7718143e2e99dc6809b0ddbc2cf578cdc0b290d82e6adfac0fac527c459d","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd.root"}],"root":"Coverage.Colls.keyTypes","sha256":"5a5e46b8485d32417418092e096baac09262f3c2ffc9be26e7127d09f215bd21","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.root"},{"byte_length":9008,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9","program":{"byte_length":3996,"sha256":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c"},"renderings":[{"byte_length":5833,"composed":{"byte_length":1692,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd","sha256":"3a113189cde2b976eec7e9d8cc8809deb9191ca23956806b84d40a0be508548b","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd.root"},"crate":{"byte_length":13175,"sha256":"a33503946fd052ef363ed726a5ef3cab80d9029bf159effcb5ca3ee3f234125d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd","sha256":"631b04a0cf784b5c517ff093cfb43605c1bd1bae316ce5381d24da9c0b8f160f","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd.root"}],"root":"Coverage.Colls.literals","sha256":"013883204ab049afadd5ec16da5cf4fe86ac2b67bea3392c8d1677ecb88d1277","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.root"},{"byte_length":8048,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10","program":{"byte_length":1746,"sha256":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f"},"renderings":[{"byte_length":13257,"composed":{"byte_length":1692,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore","sha256":"25ced223a4eb86ca316aa74ee37f066ecb235cd1daaf5ed98ac4527ec7d52a15","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore.root"},"crate":{"byte_length":4767,"sha256":"af030ef915059e74c7c2a7439cdd2f3e87f0ff1e956993fbdc5ad7c010e3c87a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore","sha256":"190048fc2179cfb0fdd90d198ce5444bf132455a4a195371fd7493f4fdba13b5","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore.root"},{"byte_length":13254,"composed":{"byte_length":1687,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd","sha256":"3b6af843b207ce6457976f70643b578f8a6644a552b9b11aa74eddbce43d3bd0","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd.root"},"crate":{"byte_length":13685,"sha256":"ee0fea13fd0bcd6a8f38ac930442b23f7dcf051f188f1661a7305f3d1e9b69a5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd","sha256":"30c649725c8ea4e053188af89539ff2c65518b8b2a9d4f4eb984cd7eb246d8b8","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd.root"}],"root":"Coverage.Main.natOps","sha256":"783fd533a19ca4455baecb94ee009380489b628cea7cda3fc0bdc50da704295a","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.root"},{"byte_length":5004,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11","program":{"byte_length":772,"sha256":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283"},"renderings":[{"byte_length":6973,"composed":{"byte_length":1692,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore","sha256":"fe27f30315c1e916153fd5d78eb204b4cef3719b2f981747bae81b6c3fbebd41","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore.root"},"crate":{"byte_length":4340,"sha256":"1fd22968eef8b396fb2c0032d03104ae83717176fc2919b9876d5a2d7a73e0e9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore","sha256":"4d28ecc39853ccb2ed96104664f58de698549e3d4f90c596df21857888dfa5b6","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore.root"},{"byte_length":6970,"composed":{"byte_length":1687,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd","sha256":"954616d3f32cc74ff18b30ca7ba6d5d86284a011a0d4a85b7c43c5a38689f5a7","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd.root"},"crate":{"byte_length":13258,"sha256":"35a8c124f4644cb2f70ee53bb1a4766ebb427587204f1c193338913fdb89fd1c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd","sha256":"19d8c8e395dc076f22a23f8fb3fc5206a5a9498475a389b598b41cc3ea6f6705","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd.root"}],"root":"Coverage.Main.intOps","sha256":"8b7c5e15fcb8f82dc6ff6157dc373cb05fb0650d11414208dc7f62bbc49197e3","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.root"},{"byte_length":9260,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12","program":{"byte_length":1624,"sha256":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8"},"renderings":[{"byte_length":8984,"composed":{"byte_length":2728,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore","sha256":"d44a0a77c98788d48fa34708e645d3cdfeb07d55633b2eb1769591958d1a575f","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.root"},"crate":{"byte_length":4616,"sha256":"9a588c5405d0805e8b71a3c168ecca7d5a7941a10b3707e884a8200765963074"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore","sha256":"db4d9e18fd77295e7de60762b663dab44a0d0a74075ce8a97248e78037cfe5f1","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.root"},{"byte_length":8981,"composed":{"byte_length":2720,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd","sha256":"548ea9d225e6ddbed0a9e334c48f5bcbc22087abd22c93ff9bd66617747f6ed7","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.root"},"crate":{"byte_length":13534,"sha256":"57df19a47ce392a82bdfe801f4e334b35198361a066b7dd6063f679c07bebbe5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd","sha256":"8ff819754acbe5234283be3f182867aaf6a34ad2aedc031ac0100aa3f54f2255","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.root"}],"root":"Coverage.Main.shapes","sha256":"4daee1ae94c252dfc01b4df54f02d9843db159bd96e2df94042307f40868da42","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.root"},{"byte_length":6637,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13","program":{"byte_length":1517,"sha256":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35"},"renderings":[{"byte_length":7237,"composed":{"byte_length":2336,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd","sha256":"a54c930939b8bb5ce70abee8c0f10c51526c14eb7f585e92423ae828a2936474","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.root"},"crate":{"byte_length":13479,"sha256":"92cec27dd560e7ca0a9f5daa440567b51beb597b69ef56f0678a55f0729d1198"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd","sha256":"fceeb284f89fc223a8bbb7796787a015ce216433fa36a1e8f1adb2507458c8a3","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.root"}],"root":"Coverage.Main.treeTotal","sha256":"2e7e5e83376690c139275f53f0d6a5acfa578df6764aa9963e07414986b718a3","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.root"},{"byte_length":6646,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14","program":{"byte_length":1628,"sha256":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656"},"renderings":[{"byte_length":7066,"composed":{"byte_length":3771,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore","sha256":"6ac262ebcd0ba0df193616e879e6061517442e43da1812244685c0f7ac486203","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.root"},"crate":{"byte_length":4685,"sha256":"73a3e27a1326d458fa653a2a3b7057649a690cfc50441d306fc0456004f12045"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore","sha256":"cc42aad8373c6dd2957dcc60868d5b0ec948f833019d6fe004b5d29eca422ba2","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.root"},{"byte_length":7063,"composed":{"byte_length":3757,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd","sha256":"3351977859b7f9122c6dd30d2da2b4fd21c47a7982c2542f2e595d293a12bef9","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.root"},"crate":{"byte_length":13603,"sha256":"4b8bab9cd36b1b9026cb5992a83d73f087c3a70988458b0e1f559b5e0d15d812"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd","sha256":"6d041060b0e0b78a25ac90592b203e2f1f253fa72cd62ebf2a11b7c9efc3398b","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.root"}],"root":"Coverage.Main.records","sha256":"325474c3add7fb0e32c1a70124f3886417cd860cc130cbc5d4de567e888c0b89","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.root"},{"byte_length":5198,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15","program":{"byte_length":989,"sha256":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9"},"renderings":[{"byte_length":5464,"composed":{"byte_length":2095,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore","sha256":"db48a990e6578f9c8c77ee266e69691b16b76fc94e82aba807ad6a2fab79552c","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore.root"},"crate":{"byte_length":4417,"sha256":"31aa7ca5ef4e02642fd2c913c93293b098b0b55555ebd261df0377b68180139e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore","sha256":"cebd8c7e5271298a568dcbdddf087f9f96349da685ace1ffa9564c449cdd63bb","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore.root"},{"byte_length":5461,"composed":{"byte_length":2090,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd","sha256":"2f3d7c1216a857dc636a9e51e0b2a9485e23cd95c7df525a0994b3abdac45366","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd.root"},"crate":{"byte_length":13335,"sha256":"44fa70d0448251f98e8fdef3403a5990d6a42239304a80f10cb6830960f7268d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd","sha256":"9fafccd3a7a3e55d336dc4fe0888158d6242f02cc8fa27cf58daf73df23c4aed","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd.root"}],"root":"Coverage.Main.options","sha256":"0cfc3023e6a8f34a2a07683148df556b3200f2540592fd4d579b451dc7ee14f3","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.root"},{"byte_length":4914,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16","program":{"byte_length":1264,"sha256":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db"},"renderings":[{"byte_length":3982,"composed":{"byte_length":1494,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore","sha256":"39667de045e9e08041a2abbce67b4ad34b2fd543810ddcaead7734e9b63a4db0","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore.root"},"crate":{"byte_length":4121,"sha256":"84aab30692ec8281062085a409bfc422cd779958bb5c57ef9e59799a768d2501"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore","sha256":"07bea78738a9811d70b727909ff01b9598d26dc40de55acffd6b4a074ce3e921","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore.root"},{"byte_length":3979,"composed":{"byte_length":1489,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd","sha256":"6126a77886dd874d6bf08b04bbb8751ed674fe5d48da9d23ad8adb65bb5cf35d","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd.root"},"crate":{"byte_length":13039,"sha256":"6d8bc511c7f98f686d36dbda86f3c9a344a7dcdf69021b28be933128dcaaae78"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd","sha256":"1090072ad99b2bcb2286660e6c7c93607914d6c1fd085dbedaa730905e0392c6","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd.root"}],"root":"Coverage.Main.builders","sha256":"349e54a62e6468f47a44b628e0eba5cde42f1168f53f025062099fe0614eb55f","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.root"},{"byte_length":2718,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17","program":{"byte_length":451,"sha256":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f"},"renderings":[{"byte_length":2405,"composed":{"byte_length":1756,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore","sha256":"ff34e0f60ecb25a8df0e9cdd6ea55a2d1eaa39d85be58afb217a6e84d0e74319","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore.root"},"crate":{"byte_length":4003,"sha256":"9ee584eed11f7b4efb99475c2a6b35939dc35dd3f263806aec3ae84479b96685"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore","sha256":"e731f4ea963943765dc1bcadd001272cc1ef9ed45a3d927115dd73ed07304fa3","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore.root"},{"byte_length":2402,"composed":{"byte_length":1751,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd","sha256":"d026a8c4626b1d008b3a3cf14e0d6bb0e37a2ac169a2805e0089e6f7ea62a587","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd.root"},"crate":{"byte_length":12921,"sha256":"5e115227d6075aa279430638e5ddb6995ac255db0bd608e107a843bd468dde51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd","sha256":"3e24a50eb62d50bc931b3fe6230587afc2fa8599529affc8cb29fb3d6ac551e4","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd.root"}],"root":"Coverage.Main.pairs","sha256":"e8ebf71cbfee3620bfcded5121dee9dcb062e0fcf1fb06c4bb91b238ef55af85","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.root"},{"byte_length":10853,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18","program":{"byte_length":1873,"sha256":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596"},"renderings":[{"byte_length":12456,"composed":{"byte_length":1740,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore","sha256":"e94a1e44f0e95112801004e5dcc530a3ae5050ee5066621f78370cd3d9c1e814","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore.root"},"crate":{"byte_length":5047,"sha256":"2c1e15094b24d3e5c9a0a06315afc8bf4c60341ba27fd1bf252230213141f5fe"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore","sha256":"bb67add88f55098060737c659901b10c033bc807d0dd225f558ed95916faefe6","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore.root"},{"byte_length":12453,"composed":{"byte_length":1735,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd","sha256":"d26bc2e0bd2ba2e63b873fc5f1be8d400613b11dc8f8c60eb8c242b691e7b465","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd.root"},"crate":{"byte_length":13965,"sha256":"d46d5bf325126545575bdf8963f16739be5cfb777b38c5233acf8ea8c474a576"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd","sha256":"21f16872c4806ec4677ddb564f2717225321951c78a1f6baee7d5a79a25b1ff9","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd.root"}],"root":"Coverage.Main.higher","sha256":"9667d42d5aeb047ddf894c675edbe23f750b5ad9ed61bf1470f34c2c498355ad","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.root"},{"byte_length":8651,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19","program":{"byte_length":1884,"sha256":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943"},"renderings":[{"byte_length":7953,"composed":{"byte_length":1646,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd","sha256":"f6e17b1f46610300d39a63e715ba5d11916f7aee688d60bf165988f507b6d2e3","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd.root"},"crate":{"byte_length":13607,"sha256":"ffd9d2b0d04acb6874cfa5f2983560a9c24a75e8bbd9f3b2580f84d5a76d7b70"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd","sha256":"de82b5f0d7bd5ae0a75b2f5f712bcced3eba57fd49737eb62a63b61b48e69686","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd.root"}],"root":"Coverage.Main.mapped","sha256":"fc407bc552d23c92e96ae366a304a2a46aa87b82b8ee9673ef1f9f1acecc1310","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.root"},{"byte_length":4983,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20","program":{"byte_length":999,"sha256":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775"},"renderings":[{"byte_length":4204,"composed":{"byte_length":1495,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore","sha256":"7c87348d83ed3df26db2b0961fee4a9c85b92668e311ca55ef02c90544cd1686","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore.root"},"crate":{"byte_length":4179,"sha256":"fcb23d2bf0050b3ce8c890495631aa62147613e0a92836750e7c5fd2bb3b60dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore","sha256":"2824da984890e52615cb5a756133237cb6fa3fd47c98aaada6be46b9d88c59a3","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore.root"},{"byte_length":4201,"composed":{"byte_length":1490,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd","sha256":"15a979c5121764c9e6018e9279835652f5de3f36b8014b6357d2aa65954f6b0a","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd.root"},"crate":{"byte_length":13097,"sha256":"a9de1e3631675db5a707a20a389993cdccd26644956d0ad09e14a25f26b8123f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd","sha256":"81d28073cf2f9561d8059afad16d35fe0bf005c7fed642ed0d4d7030f0345f08","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd.root"}],"root":"Coverage.Main.parity","sha256":"752d1a4eb74a04e9e6d3649d3c7d30ad4160a7bfbe8d1302c6356a54e318c38e","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.root"},{"byte_length":6865,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21","program":{"byte_length":2446,"sha256":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d"},"renderings":[{"byte_length":7321,"composed":{"byte_length":1689,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore","sha256":"b646b6bdb3e5a8da11c02d3db34c86b477c7c8e479a35fbcec5c7139af4a33f2","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore.root"},"crate":{"byte_length":4385,"sha256":"f4884b32be79ba4577ae148c340ffd389f3ab673bab9b3e0a6151d92a64dac98"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore","sha256":"b9ea296a4b026a6e693036f4801f254ee8bf91483fe02c0f06e17b8c6fcbad02","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore.root"},{"byte_length":7318,"composed":{"byte_length":1684,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd","sha256":"021a5f654d52955fd459dd4c931a6012e2164e39b7c43defcd166e6fd01afb7d","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd.root"},"crate":{"byte_length":13303,"sha256":"a09d0b574d6829f8ce94552a82e7770388c891bf3591aef3bdb2aa1c80734465"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd","sha256":"4034061e38cf183ad421795f371f324a79999c84a4461fbb366518bc050ee709","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd.root"}],"root":"Coverage.Prims.fixedSmall","sha256":"44107f458fe79fd79b7ee137d4480e6d5ad597431117fd2b4de29527e8a18bff","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.root"},{"byte_length":5605,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22","program":{"byte_length":1770,"sha256":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf"},"renderings":[{"byte_length":5884,"composed":{"byte_length":1697,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore","sha256":"f7a1cd054dbbee2447699aa7610d060f2aac8115e2ef57941f5747653f88214e","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore.root"},"crate":{"byte_length":4285,"sha256":"9ad73a749e8c19c7038a85d6fd571a10e3024158934cfc17d738099d4257e7c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore","sha256":"833d76ba6af942a3ed740ba21b939bf50eb41ba802f6afec781ee8c5d760ac43","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore.root"},{"byte_length":5881,"composed":{"byte_length":1692,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd","sha256":"bc86d817a42ddc6512bec704218e3fb2b886d8a1d42bc3544823c845f3941b87","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd.root"},"crate":{"byte_length":13203,"sha256":"2e31d2ad0160635ba75b00c7c15bc08e71de244c902defb8fddb06175c8752e4"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd","sha256":"bded0ce289736e9469cb7c3b5df834e3d7b50da4a1226424843392e94ae6f1c6","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd.root"}],"root":"Coverage.Prims.fixedMiddle","sha256":"9033c681e9646581e0456bcd2d891cfc617967ab876ada6cfaa05092176e28d4","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.root"},{"byte_length":8536,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23","program":{"byte_length":3324,"sha256":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d"},"renderings":[{"byte_length":8909,"composed":{"byte_length":1898,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore","sha256":"142e968ed269b79010e2d3f1e735153fbded92b5a28d5806021bcceaa1d0075d","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore.root"},"crate":{"byte_length":4519,"sha256":"e68ee92c192814f24ef49f678d7b0f10e590262eaac0e5a5edafd2716711b54f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore","sha256":"005d23bc93b19c39579877ca1637b2483793a38378c7ef3752b0772e626dd6ea","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore.root"},{"byte_length":8906,"composed":{"byte_length":1893,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd","sha256":"335df03f45e487f8131a916b8f10b4e520fb61491debd09784c789b5a7684572","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd.root"},"crate":{"byte_length":13437,"sha256":"2f8e04183e437e3b85961d1277fa70eec93662dd97eb0e6e4f0d1d1adfc95798"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd","sha256":"41ea7efafe195e949c305759ffeeccc6073feea61f1a289b95598b6179b62fe6","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd.root"}],"root":"Coverage.Prims.fixedWide","sha256":"28d8ee40d3e53adcac9d9234714669e3e1b2dd202e8641fb8f3305c8e3502096","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.root"},{"byte_length":8690,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24","program":{"byte_length":3494,"sha256":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018"},"renderings":[{"byte_length":9917,"composed":{"byte_length":1900,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore","sha256":"36e805272c9705ac0c2f67cd4a41789d73f21fce342a6c2a13903b3f9cdcfaf4","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore.root"},"crate":{"byte_length":4562,"sha256":"f594bce05710d6a44ba4db5022a8759b6ac698bed7b389b7e60d820c93373a21"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore","sha256":"8b318b839e6106e83479d8338d0d09c5acc03fdbe37f4883edef89c40abf3ee1","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore.root"},{"byte_length":9914,"composed":{"byte_length":1895,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd","sha256":"df8604dd1717336998e60de3ee0ab99a9675933fcdced9e2b6c09cb1f8fd4fe1","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd.root"},"crate":{"byte_length":13480,"sha256":"34ed06527b7da3dc36936034ff6c7a0145675fd668c22ed6feafa9a3b418e3bf"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd","sha256":"1517a3bfdef06176c5a77916a7176e2dea2d6b7aefb5a73a5db8484b89aa57a2","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd.root"}],"root":"Coverage.Prims.bits","sha256":"4dd9fc5f1be4a975f22cb7113c6f2a86e9d544a0a225825a6e798848832b8092","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.root"},{"byte_length":3336,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25","program":{"byte_length":701,"sha256":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f"},"renderings":[{"byte_length":2932,"composed":{"byte_length":1691,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore","sha256":"faf9bf9670345c34689eede7703d8817689855bcfcd18b962fb1168ae93c3e4c","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore.root"},"crate":{"byte_length":4072,"sha256":"177164e24d17c1a066fd7038902d01c1f8dfd73c69ed8377af3b1c2db5cc1412"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore","sha256":"a9cf2664bd6f0429ad6cf00c32d0ba21ad10d577684e595be0fc84b4b5002831","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore.root"},{"byte_length":2929,"composed":{"byte_length":1686,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd","sha256":"7c4500323690ec2d29b972769cf0664c6c285ed816fe43bcbcd4e2965d7e8ee2","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd.root"},"crate":{"byte_length":12990,"sha256":"2f5c6ff9563847b0e68f1b9b206d825a78c81a047a954fd54ab509b3bd79de61"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd","sha256":"5a356ee4d983930d3365f6c262f833d817a3df4239d0c119643f685b837297fe","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd.root"}],"root":"Coverage.Prims.conversions","sha256":"3358a74860980e13d5efcc751e2e9fad37e161790a5eec7c3bc4642d0e893451","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.root"},{"byte_length":14123,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26","program":{"byte_length":5637,"sha256":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702"},"renderings":[{"byte_length":16373,"composed":{"byte_length":2029,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd","sha256":"8dd64303d88a843106442a62e74cbbf8ae811f10e4ad8b84fae01bfd5ebce407","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd.root"},"crate":{"byte_length":14078,"sha256":"64aebfe2ed7b706cea90fb4e7ee5b7630cb43e480aa43f74e6fe9af4c4142601"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd","sha256":"27d92112a3682294ac0543524cbaed1691c4dd56d9657b92905f10318deefec1","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd.root"}],"root":"Coverage.Prims.sequences","sha256":"ecf7b27332c34ddde75979829af1f9b3324ebfbd669088974ea114c4e2da3c2a","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.root"},{"byte_length":3214,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27","program":{"byte_length":686,"sha256":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526"},"renderings":[{"byte_length":2818,"composed":{"byte_length":1501,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd","sha256":"2fd63eb1fa35703f1d6572e9da6667a9763234c9e4200bff279f6a1d98ec35f0","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd.root"},"crate":{"byte_length":12956,"sha256":"11b389208a11b50ffd36526d42d3b92b00669a700b8875d53bef97f92efd7c8a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd","sha256":"081bf1a2b87899c32b4d09b8293c66be3a3c26cfcfd83d952d1f631fe88453a7","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd.root"}],"root":"Coverage.Prims.decimals","sha256":"f127b1e25952a8f6ef90fb3b98e741c65da1510e43f27a186b7c3f5bbe86fd17","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.root"},{"byte_length":3046,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28","program":{"byte_length":529,"sha256":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372"},"renderings":[{"byte_length":2791,"composed":{"byte_length":1686,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd","sha256":"313df789d85eb4073a4642f780bede0aee529a5a5818664e89d67c91a96daa11","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd.root"},"crate":{"byte_length":12933,"sha256":"d0b018bf12ebfd193d45370c9a299fe8448a30481f706e8bcf5a756c78b6359e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd","sha256":"c6e3cbca86d9b9872d32bcfa556a3e02920236ae5e183255809cf3579c356dd8","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd.root"}],"root":"Coverage.Prims.formats","sha256":"d2ea17f53b5bd2d19cb0bc56de1e03286fa73281a589353c2170524050428350","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.root"},{"byte_length":11774,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29","program":{"byte_length":4118,"sha256":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f"},"renderings":[{"byte_length":14927,"composed":{"byte_length":1712,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd","sha256":"d867efce445619789b22af66f895e6fd134986d0c60ce50102ab0a92805e0814","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd.root"},"crate":{"byte_length":13981,"sha256":"e4aba3ad1a43ca155a88aec769bcc47479e9e5091944214f2a469ca7b68e7d9c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd","sha256":"987cb7e80e851ba83543f8e71b649eed4aa8cac307b9b8d14e569114f13803d4","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd.root"}],"root":"Coverage.Prims.text","sha256":"8d00056ba8e6243f8b40d0f6a8540b73bb57bad0b023181cac2566785f70d8c6","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.root"},{"byte_length":8119,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30","program":{"byte_length":1887,"sha256":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41"},"renderings":[{"byte_length":7705,"composed":{"byte_length":2793,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd","sha256":"55f15d594b43927a1cdd776e107ae6a10a6032e626debfdc111dcbae51bd6592","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.root"},"crate":{"byte_length":13423,"sha256":"7b6d66e610ef88eda88943c88c3322a2c1bf519e41049d16afe53d039cd7033a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd","sha256":"454db78e305a6a801594a5f11d27b3021b951c1f6262f20075e9a35267b95199","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.root"}],"root":"Coverage.RecRoots.roseTotal","sha256":"75787cad9de6fe71f00a572f775b7d3c357091dd717786916c29143de074f94a","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.root"},{"byte_length":12655,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31","program":{"byte_length":2687,"sha256":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b"},"renderings":[{"byte_length":15589,"composed":{"byte_length":4165,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd","sha256":"f8c71d75f2d0e62c400e3d60fb9b7729de80868f1cbf8df8dbf4c7d003c2beba","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.root"},"crate":{"byte_length":14339,"sha256":"3c3d755be5666a0def8f507f530fa6c1b75ce74ae299363b69cdd7f19b598674"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd","sha256":"0d41e6c5de61f58cec6c58515f83ef1326961c8c436f62c2a7df442a6a76d8f9","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.root"}],"root":"Coverage.RecRoots.syntaxTotal","sha256":"1335a87e9ef007bec1a852a22c6bc6cd6f5f157e8620f3aa70fe35eb8792eddd","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.root"},{"byte_length":17328,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32","program":{"byte_length":3120,"sha256":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d"},"renderings":[{"byte_length":19234,"composed":{"byte_length":1692,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore","sha256":"cf926e136dadacdd2b361db139fd917dee9788860e239056ae061b76f62dec36","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore.root"},"crate":{"byte_length":5179,"sha256":"595b9659cce79629fb199be239edeba9f908e19c5863ec7fc71ddbea1ca6b16d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore","sha256":"47d0ca085b36ed7ba47079b83062f744469d3c7a3819fdb3dae6c45d25b49a72","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore.root"},{"byte_length":19231,"composed":{"byte_length":1687,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd","sha256":"2630c95d193ff3d31198a4330ac0f9d36fff777e2fd42313f7b472cff4fb1137","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd.root"},"crate":{"byte_length":14097,"sha256":"5bde24114f0f63beca1277bf6cd06ea203bd89352590534d5844f6639bbeb943"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd","sha256":"c7a25159d2484598814aee7f2efa55a5481c5938952e85eafd70fdccbfeeabc7","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd.root"}],"root":"Coverage.RecRoots.wellFounded","sha256":"8d268d6cce014391c5e6c0f5c3cb95d239fc279b8f111f8865df2227adff53d6","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.root"},{"byte_length":15632,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33","program":{"byte_length":2757,"sha256":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89"},"renderings":[{"byte_length":13569,"composed":{"byte_length":2380,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd","sha256":"2b50e219eb9029e76e6c576e6115f6d0f36efe698653282b1f0c5f2e85aa832f","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.root"},"crate":{"byte_length":14222,"sha256":"85ddef0fbc268b258386fd1d552610372cf646edbeda718288d5bc4554a58de0"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd","sha256":"0c79131f69305cbde053a748d8fafa28fa94d16cf5342fecf2b18b807df01f6f","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.root"}],"root":"Coverage.RecRoots.rewrite","sha256":"51c3380ae10932ac7128863db6fa993d3840fe2470ead4cce03ba3d2b7a06445","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":58284,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0","program":{"byte_length":19449,"sha256":"1aadfc9ba4fd60d7060d145ef97656e0bca23924ec77e487808d5faae1ada33d"},"renderings":[{"byte_length":85650,"composed":{"byte_length":57275,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd","sha256":"2fb9d461fbecfcf1e00cae7c692853a7ce14b9524b8d488283f623ae0e3ccfe7","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.root"},"crate":{"byte_length":22556,"sha256":"77ab666847a104f8f578a1f8e741421430e9fed92895817a111f50a95178b620"},"entry":{"function":18,"symbol":"f18"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd","sha256":"3521c8f65918bb9ccb7d86c371f3f98b5225cecd212a4a058a6c8e5d37abea07","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.root"}],"root":"Coverage.Boundary.groveRoot","sha256":"dc8acbc18fe0b7cf22206e035fbc293ba879532c8c9ef5a5b764f38e37cd5dd6","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.root"},{"byte_length":29833,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1","program":{"byte_length":16945,"sha256":"befbd0f6a81345584eccc0e352073fcc65d585f2ff9b002aad0cfac26a5a426f"},"renderings":[{"byte_length":59928,"composed":{"byte_length":21795,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd","sha256":"f97b532c298f5d43f4a6f18570aab603537dcc79acf2310492820e6b019a7740","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd.root"},"crate":{"byte_length":19105,"sha256":"5d5216f8cd8580e08122755e5fd0aa617b9ba4b46fd2dcb000f6d7503c307f92"},"entry":{"function":10,"symbol":"f10"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd","sha256":"ff789e905681502042cc9fa17571cd46f927ebfe125fb0f57b6ccf5b975ee8fa","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd.root"}],"root":"Coverage.Colls.mapOps","sha256":"e94c290ab43c1858ddb9c9170dbe4af0f228d36177769447a436aa1af6cb5dc0","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.root"},{"byte_length":13160,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2","program":{"byte_length":4015,"sha256":"db2b0f171e75cff8b9931bc693e039342501c8d43f2d2a653bd29728fe777dc1"},"renderings":[{"byte_length":25017,"composed":{"byte_length":19513,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd","sha256":"09210dbfce2c1824561a7fb030705a68f274810b3a0f27e89cfbb5f67bb50f97","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd.root"},"crate":{"byte_length":15540,"sha256":"014aa5f97db48ae59c8841bf98cd515f65a1be0c24b3fd1095cc48ebb6c83fc1"},"entry":{"function":5,"symbol":"f5"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd","sha256":"dc8172aa7fd206199880a4d1c909ade61887a907f653e862ef954d3275005a7b","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd.root"}],"root":"Coverage.Colls.mapFolding","sha256":"e9e804e872ac5d0b0b4d4a7650ec5d743927315ba595cdc4f096507fd34ad35a","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.root"},{"byte_length":27034,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3","program":{"byte_length":16755,"sha256":"ff65cb9f421e37305a20ed392f155a0aabde61713d63520082effd9e2006231d"},"renderings":[{"byte_length":61996,"composed":{"byte_length":18315,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd","sha256":"77c3659fcb3f59b950dd4024a0488afb5a4305f3d5ddd55b7147f6e802c03b70","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd.root"},"crate":{"byte_length":19344,"sha256":"b735c8c86aaac3de962c4a35440898953b1162fd156ada72eb075744426d87e1"},"entry":{"function":11,"symbol":"f11"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd","sha256":"98e4146f33915d8c7f5338966b48f840aaeb65ba5a0f25d85ab54d00985f167c","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd.root"}],"root":"Coverage.Colls.setOps","sha256":"b787296ebe7b0066f148c1965de1d220cb2ecc17a66f93e9379cc18e14e6579c","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.root"},{"byte_length":13375,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4","program":{"byte_length":4435,"sha256":"48b1d22aff3beb88a3f286056475ac74e9a357ff9dc339c89b802249153cebbd"},"renderings":[{"byte_length":21903,"composed":{"byte_length":18055,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd","sha256":"a0e473a4ed4c2012eb89086d1c044c78443706a1fd6f29e8cdc01e21b1db4985","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd.root"},"crate":{"byte_length":15272,"sha256":"cf60ae7366ecb8b9565507fd1247024683dfd01ad6d22c2db0aeb6f250c1b307"},"entry":{"function":6,"symbol":"f6"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd","sha256":"c09ab56aa4ee2b1c767a992f468b44f50e448d16ade835d0e07b320d44c2f772","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd.root"}],"root":"Coverage.Colls.folds","sha256":"991ae51235f220be974028a86492aa3e4ec098badea3221fb2567591c7a217bb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.root"},{"byte_length":9233,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5","program":{"byte_length":3448,"sha256":"17fa1f466a5d992c3b54152d0a758cd23d38d1b2fda1ef5693cc06700cabe223"},"renderings":[{"byte_length":14771,"composed":{"byte_length":13436,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd","sha256":"ebaaa672191dc1681a29bf54469b8ba939863e01e42dd3a244cd237da0043f8a","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd.root"},"crate":{"byte_length":14251,"sha256":"b07e6313d5996c7f489f6ff31b6047d7bdd30fac8dc0ab06dd2de5c165773171"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd","sha256":"e9bd63011d0dae2b0b347bede085f1b8b6675aa5b095527c5a9d22568823f15a","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd.root"}],"root":"Coverage.Colls.iterations","sha256":"93399bf9ad94dae0dcbb710f59dbd2e0bef3fdb250797dcdf321229ae236713b","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.root"},{"byte_length":30878,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6","program":{"byte_length":32854,"sha256":"54b3c6a08367cfc9abac0716d282f9bfd50bcfffd1c1c0a5693bf6e6407145e2"},"renderings":[{"byte_length":153083,"composed":{"byte_length":20162,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd","sha256":"826e4d42877567099fdd2bb7985f404f8a92f838f3a5e84a5bbca4ec9fabbfca","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd.root"},"crate":{"byte_length":28628,"sha256":"d53a1fc1f9cf1f4e7366e8dcf3dea4f3e858227e7739718651f7bd74ea86be6f"},"entry":{"function":30,"symbol":"f30"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd","sha256":"d12f273db303928b8e6912c6d94dc71bc053ba31887e610ac688ed06240af97f","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd.root"}],"root":"Coverage.Colls.graphs","sha256":"687d839ae4621a67d8cd831eab4826c429c21f61cbc29f119687b855ca5a7945","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.root"},{"byte_length":20090,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7","program":{"byte_length":17014,"sha256":"bbf596ebb9eca8da32bc60cf81d5aed9f971a815f74ed865dc65f5b5acd7c475"},"renderings":[{"byte_length":82886,"composed":{"byte_length":18707,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd","sha256":"75786232b96aaeb976cf55750132594319e5e4a07ce8f7386d6b325635fec1e8","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd.root"},"crate":{"byte_length":21438,"sha256":"b7f9d495a96503043078bb00af86cac5d22f3a92bef084ff7b8d41e5a157014e"},"entry":{"function":15,"symbol":"f15"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd","sha256":"e192365debf8736fc160ebbab30e74f38f6f1c794b45b6854d9976db18a27621","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd.root"}],"root":"Coverage.Colls.stringGraph","sha256":"92676a2bcb12f98afabf9d59345539c93cecbcdddce58379800ac731f83e6303","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.root"},{"byte_length":46985,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8","program":{"byte_length":22112,"sha256":"fc3e6614b68e0f0cf2e4fcd7831a0a8ac5a84ade2a42c08eabcd0d2ddc8abe3f"},"renderings":[{"byte_length":117400,"composed":{"byte_length":45702,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd","sha256":"53fc3225dc2e863f1ff60471d8e374cd1d4609703f518ce5a16d69565f00a58c","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd.root"},"crate":{"byte_length":26043,"sha256":"bf8749dca9d3b9f015f7261c88b60dea927138244a7b63985e6966ad4147d00f"},"entry":{"function":13,"symbol":"f13"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd","sha256":"7f8a7718143e2e99dc6809b0ddbc2cf578cdc0b290d82e6adfac0fac527c459d","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd.root"}],"root":"Coverage.Colls.keyTypes","sha256":"5a5e46b8485d32417418092e096baac09262f3c2ffc9be26e7127d09f215bd21","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.root"},{"byte_length":9008,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9","program":{"byte_length":3996,"sha256":"c7a7def9b6c20967b79d34ac878ad3bd945e7e8a5f7ba59728f515c9495f8d2c"},"renderings":[{"byte_length":5833,"composed":{"byte_length":14388,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd","sha256":"db233b61807378060663c5ab87968e6a35522b11aa58437fd25eb47e8f5d971d","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd.root"},"crate":{"byte_length":13175,"sha256":"a33503946fd052ef363ed726a5ef3cab80d9029bf159effcb5ca3ee3f234125d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd","sha256":"631b04a0cf784b5c517ff093cfb43605c1bd1bae316ce5381d24da9c0b8f160f","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd.root"}],"root":"Coverage.Colls.literals","sha256":"013883204ab049afadd5ec16da5cf4fe86ac2b67bea3392c8d1677ecb88d1277","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.root"},{"byte_length":8048,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10","program":{"byte_length":1746,"sha256":"7327b0d3e0e2b92c9e324f0b8f38bf8b9a4866af1fab582ce3cb3471b3faac1f"},"renderings":[{"byte_length":13257,"composed":{"byte_length":13279,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore","sha256":"0c43ceca398b7dddaa4305ba651c2cb2158e8dde3193e41dbc9b96b8c79d3f21","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore.root"},"crate":{"byte_length":4767,"sha256":"af030ef915059e74c7c2a7439cdd2f3e87f0ff1e956993fbdc5ad7c010e3c87a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore","sha256":"190048fc2179cfb0fdd90d198ce5444bf132455a4a195371fd7493f4fdba13b5","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore.root"},{"byte_length":13254,"composed":{"byte_length":13270,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd","sha256":"fd602f6ee745d958952bd0b5b0a893566a204cc64caf2aa1635cc522ace3242a","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd.root"},"crate":{"byte_length":13685,"sha256":"ee0fea13fd0bcd6a8f38ac930442b23f7dcf051f188f1661a7305f3d1e9b69a5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd","sha256":"30c649725c8ea4e053188af89539ff2c65518b8b2a9d4f4eb984cd7eb246d8b8","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd.root"}],"root":"Coverage.Main.natOps","sha256":"783fd533a19ca4455baecb94ee009380489b628cea7cda3fc0bdc50da704295a","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.root"},{"byte_length":5004,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11","program":{"byte_length":772,"sha256":"6f167a8d46f8923a927e311666264729d573c3b8593155abef2114631b1b0283"},"renderings":[{"byte_length":6973,"composed":{"byte_length":13303,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore","sha256":"712941496988f58ef8c7eec8591a28cc00026e4c27653ab9d36badd850678264","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore.root"},"crate":{"byte_length":4340,"sha256":"1fd22968eef8b396fb2c0032d03104ae83717176fc2919b9876d5a2d7a73e0e9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore","sha256":"4d28ecc39853ccb2ed96104664f58de698549e3d4f90c596df21857888dfa5b6","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore.root"},{"byte_length":6970,"composed":{"byte_length":13294,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd","sha256":"d4007fdf4e82c10f1f160165469c51f2d0bd422fc175fcad2766ef1607e315c0","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd.root"},"crate":{"byte_length":13258,"sha256":"35a8c124f4644cb2f70ee53bb1a4766ebb427587204f1c193338913fdb89fd1c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd","sha256":"19d8c8e395dc076f22a23f8fb3fc5206a5a9498475a389b598b41cc3ea6f6705","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd.root"}],"root":"Coverage.Main.intOps","sha256":"8b7c5e15fcb8f82dc6ff6157dc373cb05fb0650d11414208dc7f62bbc49197e3","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.root"},{"byte_length":9260,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12","program":{"byte_length":1624,"sha256":"05293367c4a6e86e29d41974b883426e97957fbbc411382de01e1da3e41879c8"},"renderings":[{"byte_length":8984,"composed":{"byte_length":17259,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore","sha256":"e7fbfbf863548453a774aab20173eaceb3d545e4312cc444a1bd7234aa0ad8ab","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.root"},"crate":{"byte_length":4616,"sha256":"9a588c5405d0805e8b71a3c168ecca7d5a7941a10b3707e884a8200765963074"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore","sha256":"db4d9e18fd77295e7de60762b663dab44a0d0a74075ce8a97248e78037cfe5f1","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.root"},{"byte_length":8981,"composed":{"byte_length":17248,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd","sha256":"751b46f81974b3ae90c4fa60acd3b804fdac7f5e9ffcff0b52c12d43951e00ae","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.root"},"crate":{"byte_length":13534,"sha256":"57df19a47ce392a82bdfe801f4e334b35198361a066b7dd6063f679c07bebbe5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd","sha256":"8ff819754acbe5234283be3f182867aaf6a34ad2aedc031ac0100aa3f54f2255","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.root"}],"root":"Coverage.Main.shapes","sha256":"4daee1ae94c252dfc01b4df54f02d9843db159bd96e2df94042307f40868da42","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.root"},{"byte_length":6637,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13","program":{"byte_length":1517,"sha256":"43b6eedb7829b3598a29348c532e07d70295631eb2650df5de98d38c3daccb35"},"renderings":[{"byte_length":7237,"composed":{"byte_length":17123,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd","sha256":"ebfdaa19ecc0ee45ea3af5acf842f088ac82195bc33bcfbd5257e1c2af78ba89","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.root"},"crate":{"byte_length":13479,"sha256":"92cec27dd560e7ca0a9f5daa440567b51beb597b69ef56f0678a55f0729d1198"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd","sha256":"fceeb284f89fc223a8bbb7796787a015ce216433fa36a1e8f1adb2507458c8a3","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.root"}],"root":"Coverage.Main.treeTotal","sha256":"2e7e5e83376690c139275f53f0d6a5acfa578df6764aa9963e07414986b718a3","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.root"},{"byte_length":6646,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14","program":{"byte_length":1628,"sha256":"f6c459c7f8163810d05bc43460cd394578f415d182096e2ad51dae6252d4f656"},"renderings":[{"byte_length":7066,"composed":{"byte_length":23380,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore","sha256":"ca1e7e0e0c9e9f8f89cb344b71fe7707fe29c6869a9705d6b4256af2354d2862","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.root"},"crate":{"byte_length":4685,"sha256":"73a3e27a1326d458fa653a2a3b7057649a690cfc50441d306fc0456004f12045"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore","sha256":"cc42aad8373c6dd2957dcc60868d5b0ec948f833019d6fe004b5d29eca422ba2","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.root"},{"byte_length":7063,"composed":{"byte_length":23365,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd","sha256":"cb97bf275111a22ab8faae6232c3452ee0158509df289600b030c633d2ec36fc","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.root"},"crate":{"byte_length":13603,"sha256":"4b8bab9cd36b1b9026cb5992a83d73f087c3a70988458b0e1f559b5e0d15d812"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd","sha256":"6d041060b0e0b78a25ac90592b203e2f1f253fa72cd62ebf2a11b7c9efc3398b","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.root"}],"root":"Coverage.Main.records","sha256":"325474c3add7fb0e32c1a70124f3886417cd860cc130cbc5d4de567e888c0b89","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.root"},{"byte_length":5198,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15","program":{"byte_length":989,"sha256":"1817e8488f6542ec7a9c65ee73a26b9b2ce35ef18dad904d897c9dded6e3cbf9"},"renderings":[{"byte_length":5464,"composed":{"byte_length":18219,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore","sha256":"6c605b681daaa931b6316d4350a948ecc0db06b19f5bdb09f4ccd4a06fd3010f","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore.root"},"crate":{"byte_length":4417,"sha256":"31aa7ca5ef4e02642fd2c913c93293b098b0b55555ebd261df0377b68180139e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore","sha256":"cebd8c7e5271298a568dcbdddf087f9f96349da685ace1ffa9564c449cdd63bb","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore.root"},{"byte_length":5461,"composed":{"byte_length":18210,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd","sha256":"f04dada5eee6c6f6afc43f646e01fca136ac1be594dafaa1f8ad62d167169193","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd.root"},"crate":{"byte_length":13335,"sha256":"44fa70d0448251f98e8fdef3403a5990d6a42239304a80f10cb6830960f7268d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd","sha256":"9fafccd3a7a3e55d336dc4fe0888158d6242f02cc8fa27cf58daf73df23c4aed","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd.root"}],"root":"Coverage.Main.options","sha256":"0cfc3023e6a8f34a2a07683148df556b3200f2540592fd4d579b451dc7ee14f3","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.root"},{"byte_length":4914,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16","program":{"byte_length":1264,"sha256":"234deee526474348f12566f97e315f4a79becf0607138d82ae06f555a4d3f2db"},"renderings":[{"byte_length":3982,"composed":{"byte_length":12362,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore","sha256":"6b41eb9d1266e761efcbdf5d469520d55527bd900f272a85c4c46c1ba83d92e8","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore.root"},"crate":{"byte_length":4121,"sha256":"84aab30692ec8281062085a409bfc422cd779958bb5c57ef9e59799a768d2501"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore","sha256":"07bea78738a9811d70b727909ff01b9598d26dc40de55acffd6b4a074ce3e921","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore.root"},{"byte_length":3979,"composed":{"byte_length":12353,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd","sha256":"3582f9f7b476eb16d1f799b35e97e2bab817a71bde09535cbc63a97722eee288","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd.root"},"crate":{"byte_length":13039,"sha256":"6d8bc511c7f98f686d36dbda86f3c9a344a7dcdf69021b28be933128dcaaae78"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd","sha256":"1090072ad99b2bcb2286660e6c7c93607914d6c1fd085dbedaa730905e0392c6","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd.root"}],"root":"Coverage.Main.builders","sha256":"349e54a62e6468f47a44b628e0eba5cde42f1168f53f025062099fe0614eb55f","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.root"},{"byte_length":2718,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17","program":{"byte_length":451,"sha256":"7d925a72d07005baaa5a9371f60e52199072e49139630af3348972394ef0539f"},"renderings":[{"byte_length":2405,"composed":{"byte_length":15248,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore","sha256":"98bf611a31d922c79b66feff3ed85f090e6bffd79ed4a9ca44f04f5160db4bac","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore.root"},"crate":{"byte_length":4003,"sha256":"9ee584eed11f7b4efb99475c2a6b35939dc35dd3f263806aec3ae84479b96685"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore","sha256":"e731f4ea963943765dc1bcadd001272cc1ef9ed45a3d927115dd73ed07304fa3","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore.root"},{"byte_length":2402,"composed":{"byte_length":15239,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd","sha256":"e5b95e510626984ec14b75472b00a5ec108c40ea2d57e24294e935a87e981297","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd.root"},"crate":{"byte_length":12921,"sha256":"5e115227d6075aa279430638e5ddb6995ac255db0bd608e107a843bd468dde51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd","sha256":"3e24a50eb62d50bc931b3fe6230587afc2fa8599529affc8cb29fb3d6ac551e4","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd.root"}],"root":"Coverage.Main.pairs","sha256":"e8ebf71cbfee3620bfcded5121dee9dcb062e0fcf1fb06c4bb91b238ef55af85","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.root"},{"byte_length":10853,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18","program":{"byte_length":1873,"sha256":"b9a631ceb72fc1536c7c26c88ce17cb71084492929763dc601a2e579e3b15596"},"renderings":[{"byte_length":12456,"composed":{"byte_length":13295,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore","sha256":"d4ec6b420df44e32cbbd206b3e433ececcb06393d8134337df99ab2d20d63854","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore.root"},"crate":{"byte_length":5047,"sha256":"2c1e15094b24d3e5c9a0a06315afc8bf4c60341ba27fd1bf252230213141f5fe"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore","sha256":"bb67add88f55098060737c659901b10c033bc807d0dd225f558ed95916faefe6","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore.root"},{"byte_length":12453,"composed":{"byte_length":13286,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd","sha256":"8464e23e9798afcb475dc02d70179b4193b630aaaed5c9046d5aa1ea0586d990","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd.root"},"crate":{"byte_length":13965,"sha256":"d46d5bf325126545575bdf8963f16739be5cfb777b38c5233acf8ea8c474a576"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd","sha256":"21f16872c4806ec4677ddb564f2717225321951c78a1f6baee7d5a79a25b1ff9","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd.root"}],"root":"Coverage.Main.higher","sha256":"9667d42d5aeb047ddf894c675edbe23f750b5ad9ed61bf1470f34c2c498355ad","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.root"},{"byte_length":8651,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19","program":{"byte_length":1884,"sha256":"83625b33701e16e8f1014fd8a942ea0ac67a87cefb2ef0f93321f9dbc4bbe943"},"renderings":[{"byte_length":7953,"composed":{"byte_length":13664,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd","sha256":"0901262eacbfd0a1d793e60c3138565e71f8fc38f95fb0113bdc5b1ffcbcd858","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd.root"},"crate":{"byte_length":13607,"sha256":"ffd9d2b0d04acb6874cfa5f2983560a9c24a75e8bbd9f3b2580f84d5a76d7b70"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd","sha256":"de82b5f0d7bd5ae0a75b2f5f712bcced3eba57fd49737eb62a63b61b48e69686","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd.root"}],"root":"Coverage.Main.mapped","sha256":"fc407bc552d23c92e96ae366a304a2a46aa87b82b8ee9673ef1f9f1acecc1310","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.root"},{"byte_length":4983,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20","program":{"byte_length":999,"sha256":"d80d8fa87a73970b99d0429236be199dba9bdbb4207a8c64505ec3f999bc2775"},"renderings":[{"byte_length":4204,"composed":{"byte_length":12158,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore","sha256":"dcf7ec88ee42ec08db1913d41fdb16aa5d4d82a509307e8d3e769c544f1f3a5f","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore.root"},"crate":{"byte_length":4179,"sha256":"fcb23d2bf0050b3ce8c890495631aa62147613e0a92836750e7c5fd2bb3b60dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore","sha256":"2824da984890e52615cb5a756133237cb6fa3fd47c98aaada6be46b9d88c59a3","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore.root"},{"byte_length":4201,"composed":{"byte_length":12149,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd","sha256":"d5dda89a0280c65e3fe8bc7d5cd99dc7ab40cb12a96c09acf8515a2f75740eca","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd.root"},"crate":{"byte_length":13097,"sha256":"a9de1e3631675db5a707a20a389993cdccd26644956d0ad09e14a25f26b8123f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd","sha256":"81d28073cf2f9561d8059afad16d35fe0bf005c7fed642ed0d4d7030f0345f08","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd.root"}],"root":"Coverage.Main.parity","sha256":"752d1a4eb74a04e9e6d3649d3c7d30ad4160a7bfbe8d1302c6356a54e318c38e","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.root"},{"byte_length":6865,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21","program":{"byte_length":2446,"sha256":"ef7c0ba20d049db4524a6ec6561a20d86bd33230f60e21dc733706135be42f2d"},"renderings":[{"byte_length":7321,"composed":{"byte_length":13659,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore","sha256":"3df1d46f7c5fa6b224d2435747345eb591e8a7888adda0af7ad31db08fd4a3ed","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore.root"},"crate":{"byte_length":4385,"sha256":"f4884b32be79ba4577ae148c340ffd389f3ab673bab9b3e0a6151d92a64dac98"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore","sha256":"b9ea296a4b026a6e693036f4801f254ee8bf91483fe02c0f06e17b8c6fcbad02","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore.root"},{"byte_length":7318,"composed":{"byte_length":13650,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd","sha256":"761ead2a8f90cde2e5805bc64911d63dc9707bdd0b7873c0e854b00bd15ed50a","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd.root"},"crate":{"byte_length":13303,"sha256":"a09d0b574d6829f8ce94552a82e7770388c891bf3591aef3bdb2aa1c80734465"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd","sha256":"4034061e38cf183ad421795f371f324a79999c84a4461fbb366518bc050ee709","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd.root"}],"root":"Coverage.Prims.fixedSmall","sha256":"44107f458fe79fd79b7ee137d4480e6d5ad597431117fd2b4de29527e8a18bff","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.root"},{"byte_length":5605,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22","program":{"byte_length":1770,"sha256":"c5c4a8ee12a3a426500bb6c4e82af761e1af447511bd597e1bc5dce63970ddaf"},"renderings":[{"byte_length":5884,"composed":{"byte_length":14491,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore","sha256":"c0519041b51ceefbcde4b0920dff55c16cdde615c413e41c6842318fe8265449","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore.root"},"crate":{"byte_length":4285,"sha256":"9ad73a749e8c19c7038a85d6fd571a10e3024158934cfc17d738099d4257e7c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore","sha256":"833d76ba6af942a3ed740ba21b939bf50eb41ba802f6afec781ee8c5d760ac43","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore.root"},{"byte_length":5881,"composed":{"byte_length":14482,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd","sha256":"0d58eccd162aea8d42793efdf12337769ea25b22a262b1531f0cd2e1348987bc","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd.root"},"crate":{"byte_length":13203,"sha256":"2e31d2ad0160635ba75b00c7c15bc08e71de244c902defb8fddb06175c8752e4"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd","sha256":"bded0ce289736e9469cb7c3b5df834e3d7b50da4a1226424843392e94ae6f1c6","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd.root"}],"root":"Coverage.Prims.fixedMiddle","sha256":"9033c681e9646581e0456bcd2d891cfc617967ab876ada6cfaa05092176e28d4","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.root"},{"byte_length":8536,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23","program":{"byte_length":3324,"sha256":"046e9276a504b885d2582f97b9c4fb34281d09496a6f649c6c147f6361e56c8d"},"renderings":[{"byte_length":8909,"composed":{"byte_length":15724,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore","sha256":"cf7a590c5c2e020736ccca048dea0233ff9b0e9d1ddf5d2559900282f4223387","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore.root"},"crate":{"byte_length":4519,"sha256":"e68ee92c192814f24ef49f678d7b0f10e590262eaac0e5a5edafd2716711b54f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore","sha256":"005d23bc93b19c39579877ca1637b2483793a38378c7ef3752b0772e626dd6ea","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore.root"},{"byte_length":8906,"composed":{"byte_length":15715,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd","sha256":"5e3a7ace773afc47efde8d88fc1b10b99f0e60b945108ed39fb36492612211f1","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd.root"},"crate":{"byte_length":13437,"sha256":"2f8e04183e437e3b85961d1277fa70eec93662dd97eb0e6e4f0d1d1adfc95798"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd","sha256":"41ea7efafe195e949c305759ffeeccc6073feea61f1a289b95598b6179b62fe6","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd.root"}],"root":"Coverage.Prims.fixedWide","sha256":"28d8ee40d3e53adcac9d9234714669e3e1b2dd202e8641fb8f3305c8e3502096","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.root"},{"byte_length":8690,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24","program":{"byte_length":3494,"sha256":"9ed3cf1ba1de6ddfd0c865acea0ee413b21ac44fb1d556e8eac704b552c3d018"},"renderings":[{"byte_length":9917,"composed":{"byte_length":15802,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore","sha256":"cbc6b7cdb80c24f7d2e0da780596b4ec54f49806e627c1be8bcc57ff73bae187","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore.root"},"crate":{"byte_length":4562,"sha256":"f594bce05710d6a44ba4db5022a8759b6ac698bed7b389b7e60d820c93373a21"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore","sha256":"8b318b839e6106e83479d8338d0d09c5acc03fdbe37f4883edef89c40abf3ee1","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore.root"},{"byte_length":9914,"composed":{"byte_length":15793,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd","sha256":"4f4d840d237181c36b43392692e815fe7eaeead5182e839c14b42f575eec522e","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd.root"},"crate":{"byte_length":13480,"sha256":"34ed06527b7da3dc36936034ff6c7a0145675fd668c22ed6feafa9a3b418e3bf"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd","sha256":"1517a3bfdef06176c5a77916a7176e2dea2d6b7aefb5a73a5db8484b89aa57a2","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd.root"}],"root":"Coverage.Prims.bits","sha256":"4dd9fc5f1be4a975f22cb7113c6f2a86e9d544a0a225825a6e798848832b8092","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.root"},{"byte_length":3336,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25","program":{"byte_length":701,"sha256":"6227207e0bebaa6609e8bfedfaffb83e7fcb5e8c11d9ed9caaa35fb65b35766f"},"renderings":[{"byte_length":2932,"composed":{"byte_length":14371,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore","sha256":"ca824a938fe0bfaabb6bf4d9175115c17956ab381b3d5122ace3ffd9c6d86fda","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore.root"},"crate":{"byte_length":4072,"sha256":"177164e24d17c1a066fd7038902d01c1f8dfd73c69ed8377af3b1c2db5cc1412"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore","sha256":"a9cf2664bd6f0429ad6cf00c32d0ba21ad10d577684e595be0fc84b4b5002831","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore.root"},{"byte_length":2929,"composed":{"byte_length":14362,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd","sha256":"18c2531e20e2706a947d6ae47ae682b9f4bb71639f99340561f8523fe1ad5f90","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd.root"},"crate":{"byte_length":12990,"sha256":"2f5c6ff9563847b0e68f1b9b206d825a78c81a047a954fd54ab509b3bd79de61"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd","sha256":"5a356ee4d983930d3365f6c262f833d817a3df4239d0c119643f685b837297fe","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd.root"}],"root":"Coverage.Prims.conversions","sha256":"3358a74860980e13d5efcc751e2e9fad37e161790a5eec7c3bc4642d0e893451","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.root"},{"byte_length":14123,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26","program":{"byte_length":5637,"sha256":"c01fc096fdf4c89e91adb6928197ce32bcb7e42426af0487546f4edc98fd3702"},"renderings":[{"byte_length":16373,"composed":{"byte_length":17721,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd","sha256":"b682464478f36f4761526e63ffd217a814d3677773727ea1fb0f1d6230c86e07","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd.root"},"crate":{"byte_length":14078,"sha256":"64aebfe2ed7b706cea90fb4e7ee5b7630cb43e480aa43f74e6fe9af4c4142601"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd","sha256":"27d92112a3682294ac0543524cbaed1691c4dd56d9657b92905f10318deefec1","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd.root"}],"root":"Coverage.Prims.sequences","sha256":"ecf7b27332c34ddde75979829af1f9b3324ebfbd669088974ea114c4e2da3c2a","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.root"},{"byte_length":3214,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27","program":{"byte_length":686,"sha256":"6fc888e3f1e9cf5a37f9f68cc01d1a1ff94cc30a552b384155cb811a9d13a526"},"renderings":[{"byte_length":2818,"composed":{"byte_length":12434,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd","sha256":"5bcd6e6ecc87a2748dcb2c973c7c56b91717c7af32bb33d3f919b578eb41ad5a","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd.root"},"crate":{"byte_length":12956,"sha256":"11b389208a11b50ffd36526d42d3b92b00669a700b8875d53bef97f92efd7c8a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd","sha256":"081bf1a2b87899c32b4d09b8293c66be3a3c26cfcfd83d952d1f631fe88453a7","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd.root"}],"root":"Coverage.Prims.decimals","sha256":"f127b1e25952a8f6ef90fb3b98e741c65da1510e43f27a186b7c3f5bbe86fd17","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.root"},{"byte_length":3046,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28","program":{"byte_length":529,"sha256":"a2d6d8d674af0354e10f236b2b6dcab2579a6ff9db94b3a696fb2c0679df7372"},"renderings":[{"byte_length":2791,"composed":{"byte_length":14182,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd","sha256":"ab5bce2d65ebdae6d7f10f541d4cfd6b46ef441229ab9b7434ef10a578cb7388","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd.root"},"crate":{"byte_length":12933,"sha256":"d0b018bf12ebfd193d45370c9a299fe8448a30481f706e8bcf5a756c78b6359e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd","sha256":"c6e3cbca86d9b9872d32bcfa556a3e02920236ae5e183255809cf3579c356dd8","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd.root"}],"root":"Coverage.Prims.formats","sha256":"d2ea17f53b5bd2d19cb0bc56de1e03286fa73281a589353c2170524050428350","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.root"},{"byte_length":11774,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29","program":{"byte_length":4118,"sha256":"54080023d9f656975c8d23e285159c2f80184d9c38941ebdeb9b115207eaea0f"},"renderings":[{"byte_length":14927,"composed":{"byte_length":14045,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd","sha256":"379e8863bdaab0e907d8d551817d640dc78c58b13f9a196e55de4a261fecc7a7","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd.root"},"crate":{"byte_length":13981,"sha256":"e4aba3ad1a43ca155a88aec769bcc47479e9e5091944214f2a469ca7b68e7d9c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd","sha256":"987cb7e80e851ba83543f8e71b649eed4aa8cac307b9b8d14e569114f13803d4","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd.root"}],"root":"Coverage.Prims.text","sha256":"8d00056ba8e6243f8b40d0f6a8540b73bb57bad0b023181cac2566785f70d8c6","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.root"},{"byte_length":8119,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30","program":{"byte_length":1887,"sha256":"023b87970dcc71c4e8be45aa676e75b9db5753e3da5f8ac416891d595dca8b41"},"renderings":[{"byte_length":7705,"composed":{"byte_length":19684,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd","sha256":"43a8644316433b205b2b35979901fb20b408884b71e6e7c8f75093d9049f8bed","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.root"},"crate":{"byte_length":13423,"sha256":"7b6d66e610ef88eda88943c88c3322a2c1bf519e41049d16afe53d039cd7033a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd","sha256":"454db78e305a6a801594a5f11d27b3021b951c1f6262f20075e9a35267b95199","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.root"}],"root":"Coverage.RecRoots.roseTotal","sha256":"75787cad9de6fe71f00a572f775b7d3c357091dd717786916c29143de074f94a","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.root"},{"byte_length":12655,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31","program":{"byte_length":2687,"sha256":"0b283960a85e885aef98cffde5a37a5840fe6905cb960332eb57755a9f588e7b"},"renderings":[{"byte_length":15589,"composed":{"byte_length":27465,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd","sha256":"83f84448cb7593fbe3c304a90cd37323fff9beb986e966766a17f12352c836cc","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.root"},"crate":{"byte_length":14339,"sha256":"3c3d755be5666a0def8f507f530fa6c1b75ce74ae299363b69cdd7f19b598674"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd","sha256":"0d41e6c5de61f58cec6c58515f83ef1326961c8c436f62c2a7df442a6a76d8f9","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.root"}],"root":"Coverage.RecRoots.syntaxTotal","sha256":"1335a87e9ef007bec1a852a22c6bc6cd6f5f157e8620f3aa70fe35eb8792eddd","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.root"},{"byte_length":17328,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32","program":{"byte_length":3120,"sha256":"a30548452b5811cfc83abdc547d7e93bbdfaf6ae193442225eed19b212b84e5d"},"renderings":[{"byte_length":19234,"composed":{"byte_length":13401,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore","sha256":"35faca66fd9828db6797532bbcae081f89f3d44c60db9c3ac2bc1343f5ae8136","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore.root"},"crate":{"byte_length":5179,"sha256":"595b9659cce79629fb199be239edeba9f908e19c5863ec7fc71ddbea1ca6b16d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore","sha256":"47d0ca085b36ed7ba47079b83062f744469d3c7a3819fdb3dae6c45d25b49a72","target":"rust-core","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore.root"},{"byte_length":19231,"composed":{"byte_length":13392,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd","sha256":"bb4316edb6c4221e5555e8213d6cf40abd37d5cedb999c4a2657bd5053346714","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd.root"},"crate":{"byte_length":14097,"sha256":"5bde24114f0f63beca1277bf6cd06ea203bd89352590534d5844f6639bbeb943"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd","sha256":"c7a25159d2484598814aee7f2efa55a5481c5938952e85eafd70fdccbfeeabc7","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd.root"}],"root":"Coverage.RecRoots.wellFounded","sha256":"8d268d6cce014391c5e6c0f5c3cb95d239fc279b8f111f8865df2227adff53d6","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.root"},{"byte_length":15632,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33","program":{"byte_length":2757,"sha256":"696084d3a568dde72c41261e20eb3e6dfc3055d9f56ddb2a9980a5b1eb061f89"},"renderings":[{"byte_length":13569,"composed":{"byte_length":17062,"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd","sha256":"910a37122c5b372570120821d702af9dcdae39ae0607b8e63e6fb95539d34eb0","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.root"},"crate":{"byte_length":14222,"sha256":"85ddef0fbc268b258386fd1d552610372cf646edbeda718288d5bc4554a58de0"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd","sha256":"0c79131f69305cbde053a748d8fafa28fa94d16cf5342fecf2b18b807df01f6f","target":"rust-std","theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.root"}],"root":"Coverage.RecRoots.rewrite","sha256":"51c3380ae10932ac7128863db6fa993d3840fe2470ead4cce03ba3d2b7a06445","targets":["rust-std"],"theorem":"LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 9c8a65d87..f3be5e7dc 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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.C6cddd56cf041af764eeefdf9e95c897e.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"b4d3e18c909023e8ef2eb16172d0d6a378d0dc0a522c5be3c92784e03cf17a51","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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.C6cddd56cf041af764eeefdf9e95c897e.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R8.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R9.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R10.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R11.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R15.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R16.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R17.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R18.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R19.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R20.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R21.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R22.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R23.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R24.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R25.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R26.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R27.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R28.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R29.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R32.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R33.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R0.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R12.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R13.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R14.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext]\n'LexLeanPreserve.C6cddd56cf041af764eeefdf9e95c897e.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"34e18c4bb3c9d5287d86585e66307d53c91ab9c87d19c847469810caf98a4115","tool":"lean"} diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lean deleted file mode 100644 index 0a10f9f77..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.denote left right) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.root left right) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lex.tex new file mode 100644 index 000000000..9c2923635 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustCore.lex.tex @@ -0,0 +1,467 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root : @920 := @921 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.__fits_0 +@329 := @327 @4 @17 +@332 := Production.Main.checkedSum @4 @17 +@336 := LexLeanPreservation.encOption @3 @5 @332 +@339 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@138 @85) + @85 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lean deleted file mode 100644 index d378d904c..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.denote left right) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.root left right) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lex.tex new file mode 100644 index 000000000..f138b36cc --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R0/Compose/RustStd.lex.tex @@ -0,0 +1,467 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd.root : @920 := @921 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.denote +@326 := @324 @4 @17 +@327 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.__fits_0 +@329 := @327 @4 @17 +@332 := Production.Main.checkedSum @4 @17 +@336 := LexLeanPreservation.encOption @3 @5 @332 +@339 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@138 @85) + @85 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lean deleted file mode 100644 index 0d3293c44..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore - -theorem __wt_0 : ∀ (__v : (Production.Kernel.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.program _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.krate _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.flags (_root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.denote width height) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.root width height) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lex.tex new file mode 100644 index 000000000..52dfc791f --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustCore.lex.tex @@ -0,0 +1,568 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.__wt_0 : @16 := @453 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.root : @1128 := @1129 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.flags +@3 := Production.Kernel.Shape +@4 := #0 +@6 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.denote +@544 := @542 @27 @29 +@545 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.__fits_0 +@547 := @545 @27 @29 +@551 := @18 (Production.Main.shapeArea @27 @29) +@554 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@97 @472) + @472 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lean deleted file mode 100644 index 8d81930a5..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Production.Kernel.Shape)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.program _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.krate _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.flags (_root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.denote width height) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.root width height) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lex.tex new file mode 100644 index 000000000..9a2620e1e --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R1/Compose/RustStd.lex.tex @@ -0,0 +1,567 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.__wt_0 : @16 := @453 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.root : @1128 := @1129 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.flags +@3 := Production.Kernel.Shape +@4 := #0 +@6 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R1.denote +@544 := @542 @27 @29 +@545 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.__fits_0 +@547 := @545 @27 @29 +@551 := @18 (Production.Main.shapeArea @27 @29) +@554 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@97 @472) + @472 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lean deleted file mode 100644 index 7d017856f..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R2.denote value) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R2.root value) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lex.tex new file mode 100644 index 000000000..697e871e2 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustCore.lex.tex @@ -0,0 +1,420 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore.root : @825 := @826 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R2.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.quadruple @4) +@279 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lean deleted file mode 100644 index 976321927..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R2.denote value) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R2.root value) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..afcf50977 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R2/Compose/RustStd.lex.tex @@ -0,0 +1,419 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd.root : @825 := @826 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R2.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.quadruple @4) +@279 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lean deleted file mode 100644 index 4bbf0dc02..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R3.denote number) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R3.root number) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lex.tex new file mode 100644 index 000000000..35ba9d9f0 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustCore.lex.tex @@ -0,0 +1,420 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore.root : @825 := @826 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R3.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.halvings @4) +@279 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lean deleted file mode 100644 index c456a30f5..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R3.denote number) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R3.root number) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5b0720776 --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R3/Compose/RustStd.lex.tex @@ -0,0 +1,419 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd.root : @825 := @826 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R3.denote +@272 := @271 @4 +@273 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.__fits_0 +@274 := @273 @4 +@277 := @5 (Production.Main.halvings @4) +@279 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@124 @71) + @71 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lean deleted file mode 100644 index dd611fd73..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R4.denote values) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R4.root values) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..af72102cb --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R4/Compose/RustStd.lex.tex @@ -0,0 +1,464 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R4.denote +@370 := @369 @6 +@371 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.__fits_0 +@372 := @371 @6 +@375 := @7 (Production.Main.sumAll @6) +@377 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @181) + @181 + (LexLeanTarget.TargetSemantics.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/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lean b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lean deleted file mode 100644 index 5bd237e5e..000000000 --- a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lean +++ /dev/null @@ -1,16 +0,0 @@ -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5 -import LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R5.denote values) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R5.root values) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd diff --git a/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lex.tex b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lex.tex new file mode 100644 index 000000000..e8ad74afb --- /dev/null +++ b/examples/production/expected/verify/preserve/LexLeanPreserve/C7b8829e2cc52192864282f3d66903769/R5/Compose/RustStd.lex.tex @@ -0,0 +1,464 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5, + LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd.root : @923 := @924 { + all: [LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd.program +@1 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd.krate +@2 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R5.denote +@370 := @369 @6 +@371 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.__fits_0 +@372 := @371 @6 +@375 := @7 (Production.Main.headOr @6) +@377 := LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@4 @181) + @181 + (LexLeanTarget.TargetSemantics.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 4f1a7e591..bd9a0192e 100644 --- a/examples/production/expected/verify/preserve/audit.txt +++ b/examples/production/expected/verify/preserve/audit.txt @@ -7804,6 +7804,8 @@ 'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 d196cf875..1083780e4 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":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":2450,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0","program":{"byte_length":338,"sha256":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216"},"renderings":[{"byte_length":2119,"composed":{"byte_length":1733,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore","sha256":"c78b87aacf8304b6979bb7864b3ded132a96c1b7b7154a6f405d7ba35f471180","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root"},"crate":{"byte_length":3976,"sha256":"a9ae0afab91c841fada5f7d20ccfe8a41dfc2ca90b5b46dab280d5cd17d1385f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore","sha256":"a1b0ac755716271644de0d8556af04b08ceb8826a4c6b48fd6987f88823158d7","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore.root"},{"byte_length":2116,"composed":{"byte_length":1728,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd","sha256":"3fe31fbd8fbeb5a54bfc56ac692e98fb62d5b57fbca422f842b3c61831fe3927","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd.root"},"crate":{"byte_length":12894,"sha256":"9b5d12145ec61a1e7c8b36c9ae4a493ad5897ccaf7c764cbf360f4e9a6cea8e6"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd","sha256":"827ea9eed244a2d248cc1652b040d591c25eedeec39f097968886673896dd72a","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd.root"}],"root":"Production.Main.checkedSum","sha256":"12001e90fccb4f09b7c3efa74b0850608b31fb0a8cb22c89950230965a36dfe4","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.root"},{"byte_length":6715,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1","program":{"byte_length":1055,"sha256":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215"},"renderings":[{"byte_length":6377,"composed":{"byte_length":2667,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore","sha256":"1735f7af8bb1799f63e74b5f09c64bc44535be36585d309326615291d1668a0d","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.root"},"crate":{"byte_length":4405,"sha256":"ca17d7510141e6e1b02dccc85a256a77785a5103f5a826747ea80ab9c1fb86bd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore","sha256":"21184cbed9f78f0a21898a7f4daae48fa2e1b62083481a35ed65577c21cf7c0c","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.root"},{"byte_length":6374,"composed":{"byte_length":2659,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd","sha256":"4265459186bf31e17b6850ced7199d96b3ee5dc0cff55c7a99bab9cc13248442","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.root"},"crate":{"byte_length":13323,"sha256":"513d47124349518781071d810b7d6ee6eda7aad8ae16d6d0fb34990f19bb55f7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd","sha256":"f40e5256090efd0cff4ea72c16c7e8a41e51fcb4931df5fa1047c64266a091f0","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.root"}],"root":"Production.Main.shapeArea","sha256":"459fc520560e108378ea8f00ab8437fffa54b50f34892f9b6f9b289bfbd5ded8","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.root"},{"byte_length":4754,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2","program":{"byte_length":725,"sha256":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928"},"renderings":[{"byte_length":4438,"composed":{"byte_length":1510,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore","sha256":"d6a47573be650b337c627103a32a915d270fcc4676cf99026d23065fc3c36278","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore.root"},"crate":{"byte_length":4314,"sha256":"8a91ac04eaa493de8edac523d3ac4a799351d7a2b214f2eb1badeb0ac9fbdfa8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore","sha256":"24e01fb7cf4cf7b469545b3a1345287e4653c82290603e907b51441cbe3df11f","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore.root"},{"byte_length":4435,"composed":{"byte_length":1505,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd","sha256":"38c2910e2cf9340b27cfb65a446aaca6c58137194f7e74bd7b09ff2448dc05cc","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd.root"},"crate":{"byte_length":13232,"sha256":"60e3d73c22b61aae4921ed8290cc78aa71cefc726f1d940ccac0d9daa1da7b37"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd","sha256":"a3c9c09af80064a4f10f2c12a6761e45401427d5c1823c6dd60cda6fd4992d57","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd.root"}],"root":"Production.Main.quadruple","sha256":"8cccc301ac8a556265ae9f43b652fcd664f261b02eba8bec4f6db429fd4d250e","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.root"},{"byte_length":5673,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3","program":{"byte_length":962,"sha256":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3"},"renderings":[{"byte_length":5904,"composed":{"byte_length":1516,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore","sha256":"871b603ce90306d362fdf3de469278648b3fd6824d196f22ff26be3845d1c7cc","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore.root"},"crate":{"byte_length":4245,"sha256":"5d0c2369b0094a573935f6f3e8ec55ee8377e2716cdf91f69eafbdccfd576350"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore","sha256":"7b32b07b3ed93ad40cfaec8ca01e9b9431451abac883151bd58c3d2fb6a68c67","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore.root"},{"byte_length":5901,"composed":{"byte_length":1511,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd","sha256":"810b9d8ddffc7bd574b07cee1c0d688278a992a10a5275629efced7406b84d33","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd.root"},"crate":{"byte_length":13163,"sha256":"0e3de250af7f0d8ab8b78cf05b26a348482821e96656854d81acde5d0045176d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd","sha256":"d92697eecb4aef7760da2e06f0301ce2bb9ff5bca10aae0f65b707d849ac9f7f","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd.root"}],"root":"Production.Main.halvings","sha256":"33c99486c9a0974d6211e6ce7406d2e908397223af88ef3b334adb7a6ee7b461","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.root"},{"byte_length":3911,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4","program":{"byte_length":730,"sha256":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821"},"renderings":[{"byte_length":4099,"composed":{"byte_length":1637,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd","sha256":"c477ff7190ceecadc5da72c5f84f19a12b3e253ae14d97adffb47398967bf2a3","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd.root"},"crate":{"byte_length":13085,"sha256":"83b2d122dec85436570c0f5b42cf87a311265a21df42e733c2f90555a4797e2e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd","sha256":"1299e80be57e086afb28b0a1340b846f016c62e962dacfc89225fc7087dc06b1","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd.root"}],"root":"Production.Main.sumAll","sha256":"40bf1b7cff48c5716911665b818cdf0b6e4246c0b72b53bab647329772c20991","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.root"},{"byte_length":4321,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5","program":{"byte_length":645,"sha256":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8"},"renderings":[{"byte_length":3226,"composed":{"byte_length":1638,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd","sha256":"dfde90e75edb311daeaca45f98d625528c30c312a76fe3e7fc83b86a98c653ad","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd.root"},"crate":{"byte_length":13019,"sha256":"0d6a4f61233b7dba3058013d7ce78e556bdbb28e9cd31915fdf5c2be8bcca08a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd","sha256":"d12e881b3bad91d55c833e6595d72961c5ff08fe36c984922336cdf7e2f9f64f","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd.root"}],"root":"Production.Main.headOr","sha256":"18aca5388a79dcd2ce1793c6488aa9ad17181c8cdbdd67a33cda6000c7dcb037","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":2450,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0","program":{"byte_length":338,"sha256":"938b367cd5b23f8fb66adc8d4520333ff0e34954395668d2e3b072af86ad3216"},"renderings":[{"byte_length":2119,"composed":{"byte_length":13416,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore","sha256":"bfc77e7abc78ef9a462c302244523ff746e570190323886bf84ef4485e87775f","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root"},"crate":{"byte_length":3976,"sha256":"a9ae0afab91c841fada5f7d20ccfe8a41dfc2ca90b5b46dab280d5cd17d1385f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore","sha256":"a1b0ac755716271644de0d8556af04b08ceb8826a4c6b48fd6987f88823158d7","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore.root"},{"byte_length":2116,"composed":{"byte_length":13407,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd","sha256":"380bba902ede6fcb581debc9522015d5b08d67a6839cab785bc410266cf4cd5a","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd.root"},"crate":{"byte_length":12894,"sha256":"9b5d12145ec61a1e7c8b36c9ae4a493ad5897ccaf7c764cbf360f4e9a6cea8e6"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd","sha256":"827ea9eed244a2d248cc1652b040d591c25eedeec39f097968886673896dd72a","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd.root"}],"root":"Production.Main.checkedSum","sha256":"12001e90fccb4f09b7c3efa74b0850608b31fb0a8cb22c89950230965a36dfe4","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.root"},{"byte_length":6715,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1","program":{"byte_length":1055,"sha256":"f21fc970908e57448e4db7c06bf2b57fee84f4b8734cbbf1ac327c6ee4ab6215"},"renderings":[{"byte_length":6377,"composed":{"byte_length":16876,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore","sha256":"5c81622ebd9b881d1349006ee039a6bd08f36ac22902c3fd7c7c190663e94d53","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.root"},"crate":{"byte_length":4405,"sha256":"ca17d7510141e6e1b02dccc85a256a77785a5103f5a826747ea80ab9c1fb86bd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore","sha256":"21184cbed9f78f0a21898a7f4daae48fa2e1b62083481a35ed65577c21cf7c0c","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.root"},{"byte_length":6374,"composed":{"byte_length":16863,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd","sha256":"3d46f7520bfcdf05f62d2b6bd2bc45431f14d2daa239d90afbfce5fda6908f16","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.root"},"crate":{"byte_length":13323,"sha256":"513d47124349518781071d810b7d6ee6eda7aad8ae16d6d0fb34990f19bb55f7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd","sha256":"f40e5256090efd0cff4ea72c16c7e8a41e51fcb4931df5fa1047c64266a091f0","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.root"}],"root":"Production.Main.shapeArea","sha256":"459fc520560e108378ea8f00ab8437fffa54b50f34892f9b6f9b289bfbd5ded8","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.root"},{"byte_length":4754,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2","program":{"byte_length":725,"sha256":"6853b4945864259f1da2a6fc5277607d3e4c3c725d8be3dfd7cd38000ab16928"},"renderings":[{"byte_length":4438,"composed":{"byte_length":12112,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore","sha256":"5ecb427a90e56464982b8921354e24c1b2dd4767ec550c8e37bb2f9a0981a70b","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore.root"},"crate":{"byte_length":4314,"sha256":"8a91ac04eaa493de8edac523d3ac4a799351d7a2b214f2eb1badeb0ac9fbdfa8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore","sha256":"24e01fb7cf4cf7b469545b3a1345287e4653c82290603e907b51441cbe3df11f","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore.root"},{"byte_length":4435,"composed":{"byte_length":12101,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd","sha256":"04774aea6425ae2ee7998d456237336f039912bd07d0f44641368bcd442cc522","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd.root"},"crate":{"byte_length":13232,"sha256":"60e3d73c22b61aae4921ed8290cc78aa71cefc726f1d940ccac0d9daa1da7b37"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd","sha256":"a3c9c09af80064a4f10f2c12a6761e45401427d5c1823c6dd60cda6fd4992d57","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd.root"}],"root":"Production.Main.quadruple","sha256":"8cccc301ac8a556265ae9f43b652fcd664f261b02eba8bec4f6db429fd4d250e","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.root"},{"byte_length":5673,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3","program":{"byte_length":962,"sha256":"4e73456e09ab92d80df1297c17a2a129e17822ff1c88cc30ec946ac7b5d21df3"},"renderings":[{"byte_length":5904,"composed":{"byte_length":12113,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore","sha256":"d0b42bf261249367b6e54fd33f955977a475d626ae5bf8802d14a3129ed58941","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore.root"},"crate":{"byte_length":4245,"sha256":"5d0c2369b0094a573935f6f3e8ec55ee8377e2716cdf91f69eafbdccfd576350"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore","sha256":"7b32b07b3ed93ad40cfaec8ca01e9b9431451abac883151bd58c3d2fb6a68c67","target":"rust-core","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore.root"},{"byte_length":5901,"composed":{"byte_length":12102,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd","sha256":"a117d8e9fe9679a56305e86fb39eb3ccba11a2b93d890307e6e9504e70d1db67","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd.root"},"crate":{"byte_length":13163,"sha256":"0e3de250af7f0d8ab8b78cf05b26a348482821e96656854d81acde5d0045176d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd","sha256":"d92697eecb4aef7760da2e06f0301ce2bb9ff5bca10aae0f65b707d849ac9f7f","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd.root"}],"root":"Production.Main.halvings","sha256":"33c99486c9a0974d6211e6ce7406d2e908397223af88ef3b334adb7a6ee7b461","targets":["rust-core","rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.root"},{"byte_length":3911,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4","program":{"byte_length":730,"sha256":"8ff4684c89e1a22e97417561a676319cab5351c711d244d980c53acc6160e821"},"renderings":[{"byte_length":4099,"composed":{"byte_length":13586,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd","sha256":"1861360331dfde748366ab5f0667368688014ba2abd884cda50931e17b93689b","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd.root"},"crate":{"byte_length":13085,"sha256":"83b2d122dec85436570c0f5b42cf87a311265a21df42e733c2f90555a4797e2e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd","sha256":"1299e80be57e086afb28b0a1340b846f016c62e962dacfc89225fc7087dc06b1","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd.root"}],"root":"Production.Main.sumAll","sha256":"40bf1b7cff48c5716911665b818cdf0b6e4246c0b72b53bab647329772c20991","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.root"},{"byte_length":4321,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5","program":{"byte_length":645,"sha256":"fd195b2e7a605141c794aa55f45159309d1e64be3c91ea5076f013e04dd08ec8"},"renderings":[{"byte_length":3226,"composed":{"byte_length":13587,"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd","sha256":"95fc8baaf5539ea23da535624b0fcab833a27b83ffb8b81924da2d93e1c5a1ef","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd.root"},"crate":{"byte_length":13019,"sha256":"0d6a4f61233b7dba3058013d7ce78e556bdbb28e9cd31915fdf5c2be8bcca08a"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd","sha256":"d12e881b3bad91d55c833e6595d72961c5ff08fe36c984922336cdf7e2f9f64f","target":"rust-std","theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd.root"}],"root":"Production.Main.headOr","sha256":"18aca5388a79dcd2ce1793c6488aa9ad17181c8cdbdd67a33cda6000c7dcb037","targets":["rust-std"],"theorem":"LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 74eaa40bf..d93ed5e5b 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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.C7b8829e2cc52192864282f3d66903769.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"9e0472f91d223c59a91278481b94d08828d6fee0418af0a2e358feb943474fbf","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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.C7b8829e2cc52192864282f3d66903769.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"5f305798caa290faa57bde2aedadb47231c80bac93ccb96cbb3bb00c44f22b40","tool":"lean"} diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lean deleted file mode 100644 index 7974a84c2..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R0.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R0.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lex.tex new file mode 100644 index 000000000..f8476e203 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R0/Compose/RustCore.lex.tex @@ -0,0 +1,1344 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R0.denote +@1977 := @1971 @149 @151 @153 @36 @38 @40 +@1978 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.__fits_0 +@1984 := @1978 @149 @151 @153 @36 @38 @40 +@1992 := @29 (Reasoning.Main.triageLevel @149 @151 @153 @36 @38 @40) +@1999 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@146 @1701) + @1701 + (LexLeanTarget.TargetSemantics.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/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lean deleted file mode 100644 index f12d0a510..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R1.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R1.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lex.tex new file mode 100644 index 000000000..b713330fb --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R1/Compose/RustCore.lex.tex @@ -0,0 +1,1344 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R1.denote +@1977 := @1971 @149 @151 @153 @36 @38 @40 +@1978 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.__fits_0 +@1984 := @1978 @149 @151 @153 @36 @38 @40 +@1992 := @29 (Reasoning.Main.gatewayLevel @149 @151 @153 @36 @38 @40) +@1999 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@146 @1701) + @1701 + (LexLeanTarget.TargetSemantics.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/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lean deleted file mode 100644 index 0750cf34d..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lean +++ /dev/null @@ -1,38 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lex.tex new file mode 100644 index 000000000..5a1072df8 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R2/Compose/RustStd.lex.tex @@ -0,0 +1,1744 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_1 : @724 := @960 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_3 : @967 := @1631 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_4 : @1638 := @2091 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_4], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_2 : @2098 := @2458 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root : @3543 := @3544 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R2.denote +@2804 := @2798 @149 @151 @153 @36 @38 @40 +@2805 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.__fits_0 +@2811 := @2805 @149 @151 @153 @36 @38 @40 +@2819 := @29 (Reasoning.Main.triageSteps @149 @151 @153 @36 @38 @40) +@2826 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@146 @2528) + @2528 + (LexLeanTarget.TargetSemantics.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/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lean deleted file mode 100644 index bc3aba426..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lean +++ /dev/null @@ -1,30 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Reasoning.Planner.Plan.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R3.denote target) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R3.root target) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lex.tex new file mode 100644 index 000000000..f54924615 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R3/Compose/RustStd.lex.tex @@ -0,0 +1,1304 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_0 : @16 := @424 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_2 : @431 := @905 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_3 : @913 := @1372 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_1 : @1379 := @2024 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root : @2637 := @2638 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.flags +@3 := Reasoning.Planner.Plan.Step +@4 := #0 +@5 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R3.denote +@2094 := @2093 @30 +@2095 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.__fits_0 +@2096 := @2095 @30 +@2099 := @219 (Reasoning.Main.planLeft @30) +@2101 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@58 @2037) + @2037 + (LexLeanTarget.TargetSemantics.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/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lean deleted file mode 100644 index a2cb998fa..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lean +++ /dev/null @@ -1,22 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd - -theorem __wt_1 : ∀ (__s : (Reasoning.Screening.Dose.Ledger)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R4.denote w) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R4.root w) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lex.tex new file mode 100644 index 000000000..1eeff2a2c --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R4/Compose/RustStd.lex.tex @@ -0,0 +1,880 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_1 : @16 := @717 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_0 : @724 := @1108 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root : @1754 := @1755 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.flags +@3 := Reasoning.Screening.Dose.Ledger +@4 := #0 +@5 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R4.denote +@1206 := @1205 @40 +@1207 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.__fits_0 +@1208 := @1207 @40 +@1211 := @29 (Reasoning.Main.doseLevel @40) +@1213 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@146 @1128) + @1128 + (LexLeanTarget.TargetSemantics.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/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lean deleted file mode 100644 index 7327f8888..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lean +++ /dev/null @@ -1,32 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore - -theorem __wt_0 : ∀ (__s : (Reasoning.Clinic.Vitals)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R5.denote temperature heartRate respiratoryRate whiteCells systolic infection) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R5.root temperature heartRate respiratoryRate whiteCells systolic infection) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lex.tex new file mode 100644 index 000000000..5129d3495 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R5/Compose/RustCore.lex.tex @@ -0,0 +1,1344 @@ +\begin{lexlean}{RustCore} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_0 : @16 := @716 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_1 : @724 := @1388 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_2 : @1396 := @1631 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root : @2716 := @2717 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.flags +@3 := Reasoning.Clinic.Vitals +@4 := #0 +@5 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R5.denote +@1977 := @1971 @149 @151 @153 @36 @38 @40 +@1978 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.__fits_0 +@1984 := @1978 @149 @151 @153 @36 @38 @40 +@1992 := @29 (Reasoning.Main.gradeLevel @149 @151 @153 @36 @38 @40) +@1999 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@146 @1701) + @1701 + (LexLeanTarget.TargetSemantics.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/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lean deleted file mode 100644 index 00023408e..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lean +++ /dev/null @@ -1,28 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Reasoning.Screening.Screen.Step)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R6.denote w) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R6.root w) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lex.tex new file mode 100644 index 000000000..a4abfa512 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R6/Compose/RustStd.lex.tex @@ -0,0 +1,1221 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_0 : @16 := @367 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_2 : @375 := @849 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_2], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_3 : @857 := @1316 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_3], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_1 : @1324 := @1844 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_1], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root : @2457 := @2458 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.flags +@3 := Reasoning.Screening.Screen.Step +@4 := #0 +@5 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R6.denote +@1914 := @1913 @29 +@1915 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.__fits_0 +@1916 := @1915 @29 +@1919 := @18 (Reasoning.Main.screenDose @29) +@1921 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@97 @1857) + @1857 + (LexLeanTarget.TargetSemantics.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/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lean b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lean deleted file mode 100644 index 5483e7528..000000000 --- a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lean +++ /dev/null @@ -1,20 +0,0 @@ -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7 -import LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd - -theorem __wt_0 : ∀ (__v : (Reasoning.Budget.Spend.Step Nat)), _root_.LexLeanPreservation.Rust.WT _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.program _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.krate _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.flags (_root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R7.denote x) __e_ro ∧ _root_.LexLeanPreservation.Rust.RCI _root_.LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R7.root x) (_root_.LexLeanPreservation.Rust.rel_ne_stuck _ _) - -end LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd diff --git a/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lex.tex b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lex.tex new file mode 100644 index 000000000..77022fad0 --- /dev/null +++ b/examples/reasoning/expected/verify/preserve/LexLeanPreserve/C6d3e375f76cbc573b09fef98086539e0/R7/Compose/RustStd.lex.tex @@ -0,0 +1,508 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7, + LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.__wt_0 : @18 := @398 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.__wt_0], + class: false, + generated: false, + policy: exact{axioms: [propext]}, + transparency: semireducible +} +theorem LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root : @1017 := @1018 { + all: [LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.program +@1 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.krate +@2 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.flags +@3 := Reasoning.Budget.Spend.Step +@4 := Nat +@5 := @3 @4 +@6 := #0 +@8 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.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.C6d3e375f76cbc573b09fef98086539e0.R7.denote +@470 := @469 @32 +@471 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.__fits_0 +@472 := @471 @32 +@475 := @193 (Reasoning.Main.spendLeft @32) +@477 := LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 := LexLeanTarget.TargetSemantics.LexLeanRuntime.index + (@59 @413) + @413 + (LexLeanTarget.TargetSemantics.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 559acbfde..c751298c4 100644 --- a/examples/reasoning/expected/verify/preserve/audit.txt +++ b/examples/reasoning/expected/verify/preserve/audit.txt @@ -7794,6 +7794,31 @@ 'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_4' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_0' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_2' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_3' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_1' depends on axioms: [propext] +'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 e91cd7897..a4ce1c9a2 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":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":141396,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187224,"composed":{"byte_length":6698,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore","sha256":"0a2068ab249efda29a0a85d2fcac3a1b8edc3e13b018a1428d3352ff735683d3","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore","sha256":"e2b06cc594d73b7d78f5bb32d26dc9da52bce9c2669d16cd495a6b9089cdee6c","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"c91830c0acc5ca6c342b396ca747b81e673c9ee568033ab3003b4938bbf53bee","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.root"},{"byte_length":143287,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188586,"composed":{"byte_length":6698,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore","sha256":"be1e48c87649c824c320bd3f8736dd8eb017843270189f61f7408ca928bc8dad","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore","sha256":"9e5355f206dc8d5175b5565796b6a2265507463d4cd49a8223a3cdfab7d4a199","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"0ca36292c66cc838e363c63ea8826e190598caed163f31e2225858ed728287fc","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.root"},{"byte_length":189268,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283153,"composed":{"byte_length":8531,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd","sha256":"c2de34ce6fe278317505d430c5c57c049159d74ac308088318313402548c4ca8","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd","sha256":"bb6fde80ef872a515877838e4cb70fb60796923e8447d5e86604915913287397","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"b9f92e8d4ee42da2dc9ec344d7ff6ceb58c73ad8ecc4e11436605af260967f9c","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.root"},{"byte_length":155121,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":229872,"composed":{"byte_length":5565,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd","sha256":"30769e1a23c5a73a64eb9de186e5bdba450d3a65f141b53376ee71e07dfb0d28","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd","sha256":"e50e3e410fe5325646c2eaee2cca39886372f84b88170ae839e2b62a9984a841","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"ff35c08fd5cd151b6d1e9c73e4de7f48eedebc972f9bed9cb9e7bde99f07e0ed","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.root"},{"byte_length":42567,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":3403,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd","sha256":"0e7ebec69703c7ef101de1bbb9daf2d98b95756354de9c823f765471de306a4b","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd","sha256":"697cf6fcd67bd5414da7e11e1b5e050f71d51a422be03b80114a1e221a4c38ff","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"842356d3e066cd5f18866b55f2e9f810e9d46e59a4bf23fa1aadeb146b244552","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.root"},{"byte_length":130055,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175743,"composed":{"byte_length":6671,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore","sha256":"b9d51815a74e6fc9591408996a42309d15d2def784e1860ea17c8c8593c58794","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore","sha256":"21dc5b15b7b3dace20ce35de1efc8248c5d9fdc89976c092efa855a22d3660c4","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"6a76146f554f33abdc3227565d8c1bf666e8462053878fb4994d9decec0096ea","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.root"},{"byte_length":116887,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164168,"composed":{"byte_length":4998,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd","sha256":"7194dd8140b33ec121ae4471816803699f20f4829df8cad6500f8205789eea49","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd","sha256":"55d5293dc1f5a7c7f420e3a664d7caee1727055d880c8090cac18802710965e7","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"4f05c09d3d376cce7bfd22fa2eb2099f6c460517d22a18a653606ca2c9dc8824","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.root"},{"byte_length":60948,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":2228,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd","sha256":"9727b1e523905625cf8f563cb69c81a4609d9325b3420a57f3f4307d63ebb130","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd","sha256":"62ef83f100a1e86cef2719a1611985cf993614d9434d9dd55eb6c78881ab7608","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"837ce5ae2804ba4b2ae770e12a6b656c504104b62a38742eb39d1622b16d4acb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":141396,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187224,"composed":{"byte_length":40217,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore","sha256":"c42fce0855a93d62f5a1a5f77272334ea90bfa769f2c41569260e16a447f05ae","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore","sha256":"e2b06cc594d73b7d78f5bb32d26dc9da52bce9c2669d16cd495a6b9089cdee6c","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"c91830c0acc5ca6c342b396ca747b81e673c9ee568033ab3003b4938bbf53bee","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.root"},{"byte_length":143287,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188586,"composed":{"byte_length":40218,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore","sha256":"b1cf9765470bae527b91b846ab8cb6b32b580f9e2380cdd6c62733b46ad162fa","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore","sha256":"9e5355f206dc8d5175b5565796b6a2265507463d4cd49a8223a3cdfab7d4a199","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"0ca36292c66cc838e363c63ea8826e190598caed163f31e2225858ed728287fc","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.root"},{"byte_length":189268,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283153,"composed":{"byte_length":52978,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd","sha256":"d2e59cb7e7f96279b0823f3f81ab69c07484ad80ce8e8b723a3c0ec4a14e341a","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd","sha256":"bb6fde80ef872a515877838e4cb70fb60796923e8447d5e86604915913287397","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"b9f92e8d4ee42da2dc9ec344d7ff6ceb58c73ad8ecc4e11436605af260967f9c","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.root"},{"byte_length":155121,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":229872,"composed":{"byte_length":40371,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd","sha256":"56ff6fc98f77523c7cf1b6b9f0c86e87429e7aaed01363769e1d33f90e16c6f6","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd","sha256":"e50e3e410fe5325646c2eaee2cca39886372f84b88170ae839e2b62a9984a841","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"ff35c08fd5cd151b6d1e9c73e4de7f48eedebc972f9bed9cb9e7bde99f07e0ed","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.root"},{"byte_length":42567,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":26414,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd","sha256":"a949c814a1c9f07562ff1ebeba2a40cbf1b0e9097eed5862ea9bcbaf07e9f7ba","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd","sha256":"697cf6fcd67bd5414da7e11e1b5e050f71d51a422be03b80114a1e221a4c38ff","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"842356d3e066cd5f18866b55f2e9f810e9d46e59a4bf23fa1aadeb146b244552","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.root"},{"byte_length":130055,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175743,"composed":{"byte_length":40210,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore","sha256":"048b5d7ca4412ef096d4ac80e6ea984cc23abd0e52ffa03f6ab3ce6ff31088fe","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore","sha256":"21dc5b15b7b3dace20ce35de1efc8248c5d9fdc89976c092efa855a22d3660c4","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"6a76146f554f33abdc3227565d8c1bf666e8462053878fb4994d9decec0096ea","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.root"},{"byte_length":116887,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164168,"composed":{"byte_length":37750,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd","sha256":"39e149446a8329fba91e32a82b3295f35dd08a48d0d4fdc713d5e8996458b081","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd","sha256":"55d5293dc1f5a7c7f420e3a664d7caee1727055d880c8090cac18802710965e7","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"4f05c09d3d376cce7bfd22fa2eb2099f6c460517d22a18a653606ca2c9dc8824","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.root"},{"byte_length":60948,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":15140,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd","sha256":"3ad364ea7bfb645ff54cdd99016e6a24230c3d60a7eee83e7830fc490c25412d","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd","sha256":"62ef83f100a1e86cef2719a1611985cf993614d9434d9dd55eb6c78881ab7608","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"837ce5ae2804ba4b2ae770e12a6b656c504104b62a38742eb39d1622b16d4acb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 faa10b6ed..6c6ae742f 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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.C6d3e375f76cbc573b09fef98086539e0.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"9a8bfd457dd13bc4cdf8e118e178e39893052ac443c98406a9d8dce0a860e913","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'LexLeanTarget.TargetSemantics.LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.equal.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanRuntime.length.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext]\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_1' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.LexLeanCollections.insertEntry.eq_2' does not depend on any axioms\n'LexLeanTarget.TargetSemantics.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.LexLeanRuntime.equal.eq_1' does not depend on any axioms\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.C6d3e375f76cbc573b09fef98086539e0.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_4' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_0' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_2' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_3' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.__wt_1' depends on axioms: [propext]\n'LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.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 LexLeanTarget.TargetSemantics.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 LexLeanTarget.TargetSemantics.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":"2b2a24a8e1add341f4655e09b0ca462514a1642d1c56fbfb4343442f71a57d13","tool":"lean"} diff --git a/tests/negative/certificate-e-rejected/expected/command.json b/tests/negative/certificate-e-rejected/expected/command.json index 8e6bd2fce..d2a5ab476 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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore` was rejected in `decodeAndAdd` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanTarget.TargetSemantics.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 db83f0f7a..ed8589107 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.C7b8829e2cc52192864282f3d66903769.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.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore` was rejected in `decodeAndAdd` of root `Production.Main.checkedSum`: error: native core declaration 'LexLeanPreserve.C7b8829e2cc52192864282f3d66903769.R0.Compose.RustCore.root':\n (kernel) application type mismatch\n LexLeanPreservation.Rust.compose (fun __e_n => RustCore.root __e_n 0)\n (Eq.refl (LexLeanTarget.TargetSemantics.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/certificates-total-limit/expected/command.json b/tests/negative/certificates-total-limit/expected/command.json index 669438e12..8cc161dc3 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 2022264 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..2b26a78e2 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 2022264 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"}] From 53f1d9803937ada5f6e88af9ca7782a7980f617b Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 22:07:15 +0100 Subject: [PATCH 11/17] #89 stage 1: 381 register rows after the merge of main (RB-09 and SP-14) --- README.md | 2 +- SPEC.md | 2 +- crates/conformance/src/cases/repository.rs | 2 +- xtask/src/spec_links.rs | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 199caed33..6f2fce11e 100644 --- a/README.md +++ b/README.md @@ -137,7 +137,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 380 registered conformance IDs are implemented and pass; `just vv` runs clean from a checkout with the pinned toolchain installed. +All 381 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. diff --git a/SPEC.md b/SPEC.md index 4dcaa0cbf..d10827447 100644 --- a/SPEC.md +++ b/SPEC.md @@ -9246,7 +9246,7 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `AU-11` | `authoring` | Malformed core notation fails closed and never panics: an unclosed delimiter, a keyword used as a name, a label that is not the number of its node, a reference to a node not yet written, a numeral with a redundant leading zero, a statement that defines no node, a nesting beyond the bound, and every single-token deletion and duplication of a committed module fail with a registered code at a position in the notation or link to a module that decodes. | §17.21.8 | | `AU-12` | `authoring` | A core module written with names for its statements and its variables reads to exactly the module its canonical notation reads to, and the canonical notation keeps the names of the binders and writes the numbers of the statements: a variable is written by the name of its binder exactly when no nearer binder has the name, a constant a binder in scope is named like is written as a string, a theorem added to the certification library by name reads to the committed module and is written as the committed bytes, and an unknown or repeated statement name and a variable given universe levels are refused with a position. | §17.21.8 | -**Total required capability IDs:** 380. +**Total required capability IDs:** 381. 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/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index a51407cc4..d9e416a14 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(), 380, "§31 has 380 rows"); + assert_eq!(table.len(), 381, "§31 has 381 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/xtask/src/spec_links.rs b/xtask/src/spec_links.rs index 4deb4e7c9..d2b81b421 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() != 380 { - return Err(format!("RP-07: the §31 table has {} rows, not 380", rows.len()).into()); + if rows.len() != 381 { + return Err(format!("RP-07: the §31 table has {} rows, not 381", 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. From 188576c8eb9735b5cc7c0b3fa728e29f2fb63bff Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 22:31:59 +0100 Subject: [PATCH 12/17] #89 stage 1: VERIFICATION.md records the five SP-14 plants as Lean and the audits refuse them --- VERIFICATION.md | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/VERIFICATION.md b/VERIFICATION.md index 445db758c..ad2b9276c 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -1134,13 +1134,15 @@ what the case runs; their outputs were recorded on Linux x86-64 with Lean conformance_sp_14 --nocapture`. Planted (a), a wrong lemma: the first scalar well-typedness lemma the -certificate applies (`LexLeanPreservation.Rust.wt_u32` in the root's `wtl_cons` -chain) renamed to `LexLeanPreservation.Rust.wt_bool` in every constant node +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 -WRONG_LEMMA +/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 @@ -1149,7 +1151,9 @@ 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 -CHANGED_STATEMENT +/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` @@ -1157,7 +1161,9 @@ renamed to `.flags`. Expected: the kernel refuses the row, since certificate B's root theorem is about the crate, not the flags. ```text -FORGED_CRATE +/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 @@ -1165,7 +1171,7 @@ made the `root` row's proof. Expected: the data audit refuses the module before any Lean runs, naming the forbidden constant. ```text -ADDED_AXIOM +the forbidden constant `sorryAx` ``` Planted (e), a lying policy: the `root` row's policy changed from the three @@ -1175,7 +1181,7 @@ every row of a data certificate, refuses the row whose policy does not state what Lean prints. ```text -LYING_POLICY +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 From 2557684556d74647cc1617d8717d3ed2151d5ad5 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 22:56:39 +0100 Subject: [PATCH 13/17] #89 stage 1: repair the merge joins (SP-13 and SP-14 rows, scenarios, tests); CONFORMANCE.md regenerated --- CONFORMANCE.md | 5 +---- VERIFICATION.md | 1 + crates/conformance/tests/conformance.rs | 3 +++ features/suites/preservation.feature | 1 + model/ids.toml | 2 ++ 5 files changed, 8 insertions(+), 4 deletions(-) diff --git a/CONFORMANCE.md b/CONFORMANCE.md index bd5a6587f..56e8a0b7b 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -337,11 +337,8 @@ the error registry does not sanction (R5, `ERRORS.md`). | `SP-10` | `build` | A production root whose parameters can hold a map, set, or graph, directly or inside options, results, products, lists, document types, and recursive groups of them, is lowered with a generated entry function that calls the root only when the generated validators of each such parameter accept it and returns none otherwise; certificate A proves each validator decides exactly the proposition §17.12 states of its type and the entry's two outcomes; a validator is called only by the entry and by validators, so no proof-only invariant becomes a runtime check, and a validator called from inside the program is refused by the lowering; and a validator dropped from the entry, one weakened to admit an equal key, and a rendering whose entry drops a validator are each refused by Lean at the relation they change; a lowering whose entry skips a validated parameter is refused by the generator, which judges the validated parameters from the source types alone, and the differentials break each validated parameter's invariant in turn, which the interpreter, Lean, the declared machine, and rustc each refuse with none. | | `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. | -<<<<<<< HEAD -| `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. | -======= | `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. | ->>>>>>> origin/main +| `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/VERIFICATION.md b/VERIFICATION.md index fd33dbf80..13d5e9fdf 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -1168,6 +1168,7 @@ carries the header of the lifted budgets), and the derivation bound of `tests/negative/certificate-generation-limit` (5 285 358 bytes before, 4 259 854 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 diff --git a/crates/conformance/tests/conformance.rs b/crates/conformance/tests/conformance.rs index 8608cb894..d647ddeed 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -1563,6 +1563,9 @@ fn conformance_sp_12() { #[test] fn conformance_sp_13() { repo_conformance::cases::run("SP-13"); +} + +#[test] fn conformance_sp_14() { repo_conformance::cases::run("SP-14"); } diff --git a/features/suites/preservation.feature b/features/suites/preservation.feature index 162c37036..1ec0698ad 100644 --- a/features/suites/preservation.feature +++ b/features/suites/preservation.feature @@ -92,6 +92,7 @@ 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 diff --git a/model/ids.toml b/model/ids.toml index 487fddc90..807a31935 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -1879,6 +1879,8 @@ id = "SP-13" 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" From 9d7c802a6bc2bd6984cdfbd49038430c38a0def4 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 15 Oct 2026 23:43:06 +0100 Subject: [PATCH 14/17] #89 stage 1: records regenerated after the merge of main (#101) --- examples/models/expected/verify/preserve/preservation.json | 2 +- examples/reasoning/expected/verify/preserve/preservation.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/models/expected/verify/preserve/preservation.json b/examples/models/expected/verify/preserve/preservation.json index ae8ca0419..0cb86e03e 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":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":208207,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":201067,"composed":{"byte_length":3064,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd","sha256":"3298af0830d376b688d70b187a472e9c38a2251e68270bbbf2807a7c1e863976","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd","sha256":"afebcf0ccf47eb0a459da6a546cde611e409750d396736627f1f02e6c1a221c7","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"39f163323cb5ed530c70cc9b97df0277a07dd9ba384a6b577bb99913af987496","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.root"},{"byte_length":218385,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208269,"composed":{"byte_length":3064,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd","sha256":"d3a1b439be1826b7b0faf46d526431505def0b3e60dd804ad7344098da4e3086","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd","sha256":"f853e24e3da9a738e0ebe9dedaae8383300eb1da75cf9ebc33baf96216206ccb","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"487c1782e978ab0a3605ce1e5a1e104048a8d9b072c85e2ed8d855ff7b466a04","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.root"},{"byte_length":87037,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":3700,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd","sha256":"b0090efc769371d0019fd99f52e720e58fb6adeafa84d13e641611f568f19f7a","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd","sha256":"9b13048ac2c1f45577cb3615d7d7299da40535ac6cd8d8a4fa360b1f4ed930e5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"3b3284fa5c2d959b38a97a8b5e37410f643910f386be54155afdc61b4b97b9ef","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.root"},{"byte_length":41456,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":2318,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd","sha256":"ff1a3f9da82fc9310370bee5e88c640ddb00549ebae2cfa9e797b04258e07794","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd","sha256":"d7aa2e04cbd09f62f1d6e305c8243d78b9b38ec1188a6c1347b1da64feb6c513","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"f7587654c04f21e68cc44e485afcb9a6f5a1346a33897edbd646ce809cae2e2f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.root"},{"byte_length":16496,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":2450,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd","sha256":"eaffcc0cc04e7d4afb84a892314725b255a0997e4a347ddfc0e1a02563575316","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd","sha256":"d38569568c1150f9dd4e2af271516b5fcaf5f25d8da65495f68da0bef669f4e2","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"672d14f5acfe083f63d3eb3ca91a9ca9fc07eb1761f924b41dea6d635e424b4f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":1679,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd","sha256":"ee58a84735e87765771142c1735bf702c28877c89d03fc17429723e4cf4e4f0c","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd","sha256":"cccb962143e5e57db430235f81d07aef3b7b06b0c5619d3ae2eb047a4b694a21","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"aca5b5d30b9d6742f26371f80302d74914a5d4451752c447981f53244acd4cca","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":1679,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd","sha256":"5eac2617460e21a6ab6cf1e57b915eda5d6a99230830281b2672a3069f502e21","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd","sha256":"898ebf4aad14a875402e30111db2daa88d28941c2c277594f1cd713a81c95bb5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"4323b6d1a5e2428961e64b00bbcb99b6cf777df8707f764a7e9b40335359d361","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":1482,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd","sha256":"1e8995ad984aa5402928f577b59b608cc08153edb83e4538d39a858648b760e4","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd","sha256":"c775e3adcb89ad8dd51cac17907e8dd9b6ba78082f2791753bdab3fd06e764f1","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"c05b03fab688130ba7918d6864b91256692300b169242b575313d48644165807","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.root"},{"byte_length":28222,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":1679,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd","sha256":"4d3279bda50e50f5ddf9d419a17066cb79326b561114f21bb161b79d0ed49660","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd","sha256":"a2585a915305ef5c41ab91ec89fdb862ae867add94f46f1114107ae04b2f43bc","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"e703b82136f2f6c83c844175dc5827b5862073aee9e9b3953c68f75cb309cc06","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":208207,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0","program":{"byte_length":81179,"sha256":"19c6696a115eee2945d9bc249774c91c5aa79a832ce10f52e67adb1a18bad77a"},"renderings":[{"byte_length":201067,"composed":{"byte_length":17306,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd","sha256":"c27bb292cd4eb64ad5bfb3de08c6398f0d698be0f1a70788ead84571c1af963d","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.Compose.RustStd.root"},"crate":{"byte_length":29901,"sha256":"52b8e3b70d563369f42dfff8d391090bce768b71ed790f646aa9760fb4ec6d6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd","sha256":"afebcf0ccf47eb0a459da6a546cde611e409750d396736627f1f02e6c1a221c7","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.RustStd.root"}],"root":"Models.Main.classify","sha256":"39f163323cb5ed530c70cc9b97df0277a07dd9ba384a6b577bb99913af987496","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R0.root"},{"byte_length":218385,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1","program":{"byte_length":83992,"sha256":"dce1e094aa452ad9f91b8784cdd0b834f9d69ea208e937eea7aa7d24c0c2addb"},"renderings":[{"byte_length":208269,"composed":{"byte_length":17521,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd","sha256":"66c40a1909a220c1951ddd7195b51da88e9fe95fc392cfef5e4dcd84b470e4bf","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.Compose.RustStd.root"},"crate":{"byte_length":30770,"sha256":"67121441756174b7f9423e6843041eea64787ce77aa9dcb6762bd775fd74881e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd","sha256":"f853e24e3da9a738e0ebe9dedaae8383300eb1da75cf9ebc33baf96216206ccb","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.RustStd.root"}],"root":"Models.Main.classifyChecked","sha256":"487c1782e978ab0a3605ce1e5a1e104048a8d9b072c85e2ed8d855ff7b466a04","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R1.root"},{"byte_length":87037,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2","program":{"byte_length":26060,"sha256":"09ddae4f092ac53b13ff3761c53a1371557124c89d6961d20261654bc4b1bdd9"},"renderings":[{"byte_length":84448,"composed":{"byte_length":18585,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd","sha256":"e184abd8946877206abe64fa4978904338f653fbd7f3d5650a0aa10462dc469b","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.Compose.RustStd.root"},"crate":{"byte_length":21425,"sha256":"f576dc3bf699ab120bb97fe7962cea4bf4f465cea6730924fea750d36285f2c5"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd","sha256":"9b13048ac2c1f45577cb3615d7d7299da40535ac6cd8d8a4fa360b1f4ed930e5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.RustStd.root"}],"root":"Models.Main.respond","sha256":"3b3284fa5c2d959b38a97a8b5e37410f643910f386be54155afdc61b4b97b9ef","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R2.root"},{"byte_length":41456,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3","program":{"byte_length":11441,"sha256":"5eb0b277acebe2fd4e4accd84aada754039021640f20e31e8a810623b617a840"},"renderings":[{"byte_length":42275,"composed":{"byte_length":17938,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd","sha256":"7a8a3609adc6167327031d969000b4e5762a47151ea1db820b40b9362bbb01ae","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.Compose.RustStd.root"},"crate":{"byte_length":17019,"sha256":"5f186f5373dce90862c9a810e08bd13a8abf477bd797f8d5ec8716e8d63f652b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd","sha256":"d7aa2e04cbd09f62f1d6e305c8243d78b9b38ec1188a6c1347b1da64feb6c513","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.RustStd.root"}],"root":"Models.Main.admitCosts","sha256":"f7587654c04f21e68cc44e485afcb9a6f5a1346a33897edbd646ce809cae2e2f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R3.root"},{"byte_length":16496,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4","program":{"byte_length":4260,"sha256":"36d1687bd2f49a8a4e634440ac23148a5f94ed7d3c5ec222fe66c0615e9208af"},"renderings":[{"byte_length":16667,"composed":{"byte_length":17860,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd","sha256":"fb14621c423a5c24efe80965ed4c792a7974163c2559eee9336da3a487045a87","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.Compose.RustStd.root"},"crate":{"byte_length":14275,"sha256":"9580e86941cdeea970dc62f25bbf63090547dd2dc3618a0a303a687147a8f2e8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd","sha256":"d38569568c1150f9dd4e2af271516b5fcaf5f25d8da65495f68da0bef669f4e2","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.RustStd.root"}],"root":"Models.Main.step","sha256":"672d14f5acfe083f63d3eb3ca91a9ca9fc07eb1761f924b41dea6d635e424b4f","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R4.root"},{"byte_length":16539,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5","program":{"byte_length":3912,"sha256":"223f35bd805c466609ba87317bb05b5d4c84e8ddb34eda0a212e475fa06ed6d0"},"renderings":[{"byte_length":13176,"composed":{"byte_length":13517,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd","sha256":"e9b895841cbb1d7070d7ab2663bcbf581828f25b4044975e94cad264939cc437","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.Compose.RustStd.root"},"crate":{"byte_length":13783,"sha256":"e8382fdebcad23a5a1550fafd501fdb4e10d1fc1aefe4a8b2313567cf49a4f5c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd","sha256":"cccb962143e5e57db430235f81d07aef3b7b06b0c5619d3ae2eb047a4b694a21","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.RustStd.root"}],"root":"Models.Main.ledgerPost","sha256":"aca5b5d30b9d6742f26371f80302d74914a5d4451752c447981f53244acd4cca","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R5.root"},{"byte_length":22235,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6","program":{"byte_length":4889,"sha256":"503bc027d950639ac5de5927de7fa4a04fca266c6fd0df3660196e5e287d7ce5"},"renderings":[{"byte_length":18749,"composed":{"byte_length":13517,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd","sha256":"870bd00b6d3a0f520e0ce2329cca58e467c235d8cf3afeb32d772670ac2cb6aa","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.Compose.RustStd.root"},"crate":{"byte_length":14211,"sha256":"898563f8bae88021f224534c1354540b6a565545d6c7c6e0b6cddfd30fe6a429"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd","sha256":"898ebf4aad14a875402e30111db2daa88d28941c2c277594f1cd713a81c95bb5","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.RustStd.root"}],"root":"Models.Main.ledgerFull","sha256":"4323b6d1a5e2428961e64b00bbcb99b6cf777df8707f764a7e9b40335359d361","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R6.root"},{"byte_length":11285,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7","program":{"byte_length":2614,"sha256":"8f1d418b689da95074ce318bd41caf146e0fc0c6e303165f2b1ca0abd385459d"},"renderings":[{"byte_length":8772,"composed":{"byte_length":12282,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd","sha256":"b4825b044edcf21428fe1af863e36de8c76b4cf4efffa85dd2fad99d6d3caaa4","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.Compose.RustStd.root"},"crate":{"byte_length":13420,"sha256":"0250a47719d614ca1aac8b544aa0168a202e61e5eb0011f6aaff82e3e73e59dd"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd","sha256":"c775e3adcb89ad8dd51cac17907e8dd9b6ba78082f2791753bdab3fd06e764f1","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.RustStd.root"}],"root":"Models.Main.guessChecked","sha256":"c05b03fab688130ba7918d6864b91256692300b169242b575313d48644165807","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R7.root"},{"byte_length":28222,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8","program":{"byte_length":8003,"sha256":"61d87ac85673bcb778de069cf6923996eb9e821ad05d71bfde3d36dd1bb3d241"},"renderings":[{"byte_length":26659,"composed":{"byte_length":13588,"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd","sha256":"c294ccba78e294711da1ddcf0ca47374307b717fb06f37df261d9dd9cc7a2378","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.Compose.RustStd.root"},"crate":{"byte_length":14939,"sha256":"e4f361765740eab4808750f5d31762757ae333d2e23d94047ba8761aeb607264"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd","sha256":"a2585a915305ef5c41ab91ec89fdb862ae867add94f46f1114107ae04b2f43bc","target":"rust-std","theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.RustStd.root"}],"root":"Models.Main.flowStep","sha256":"e703b82136f2f6c83c844175dc5827b5862073aee9e9b3953c68f75cb309cc06","targets":["rust-std"],"theorem":"LexLeanPreserve.Ccca462bfe8cabc3365338af96b591362.R8.root"}],"spec":"lexlean/preservation/1"} diff --git a/examples/reasoning/expected/verify/preserve/preservation.json b/examples/reasoning/expected/verify/preserve/preservation.json index 0787fe380..b6ff99983 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":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":141563,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187486,"composed":{"byte_length":6698,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore","sha256":"0a2068ab249efda29a0a85d2fcac3a1b8edc3e13b018a1428d3352ff735683d3","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore","sha256":"dbdf792b97c9bfd85ab6e538becf6e259591c55e44a125db8c0139cc90ef00d9","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"381c4d707b7d7729ff7620cab159da75406c160decc111932f425d3ec9600e2e","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.root"},{"byte_length":143462,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188860,"composed":{"byte_length":6698,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore","sha256":"be1e48c87649c824c320bd3f8736dd8eb017843270189f61f7408ca928bc8dad","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore","sha256":"a5b466d5743e565f0fa7d6a0c792ca3598c3c7a4fce740726e55b8d0bc7a757e","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"b4293a5f385a647dc3d8c9e62436052e3841e88334367231deb072bbd6df4119","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.root"},{"byte_length":189443,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283431,"composed":{"byte_length":8531,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd","sha256":"c2de34ce6fe278317505d430c5c57c049159d74ac308088318313402548c4ca8","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd","sha256":"241319528d14f9272e57b6734b4e2deee8e5d11f31732c78b3c85c95e3658ad7","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"cd712b0c22b0ae79316fe4e8b7cfc4ccc25cbbac5e96fd50c57ded29779b5a79","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.root"},{"byte_length":155284,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":230142,"composed":{"byte_length":5565,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd","sha256":"30769e1a23c5a73a64eb9de186e5bdba450d3a65f141b53376ee71e07dfb0d28","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd","sha256":"e8e3fa5bd11adab9e0bfe449883a107328a3f6b5074087ffbda839c7cb527f5c","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"743e77004a5f4afe5c809b23d810763d2bb74ed76dd296e9663dda4cc62413bb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.root"},{"byte_length":42567,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":3403,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd","sha256":"0e7ebec69703c7ef101de1bbb9daf2d98b95756354de9c823f765471de306a4b","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd","sha256":"697cf6fcd67bd5414da7e11e1b5e050f71d51a422be03b80114a1e221a4c38ff","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"842356d3e066cd5f18866b55f2e9f810e9d46e59a4bf23fa1aadeb146b244552","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.root"},{"byte_length":130218,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175999,"composed":{"byte_length":6671,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore","sha256":"b9d51815a74e6fc9591408996a42309d15d2def784e1860ea17c8c8593c58794","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore","sha256":"731051f84c765f81bbcc0362e37ad56209a02d093a789c77740ea4eaa5d189ae","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"3e2106d5a82afdf691e67037277bce1a6fe51f7f6119387c13e618e0cb0d19e2","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.root"},{"byte_length":116887,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164251,"composed":{"byte_length":4998,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd","sha256":"7194dd8140b33ec121ae4471816803699f20f4829df8cad6500f8205789eea49","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd","sha256":"1b1bf1df38151d34bed65a608d05a7c4f4bebfbe777764d3f257032424c92359","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"4f05c09d3d376cce7bfd22fa2eb2099f6c460517d22a18a653606ca2c9dc8824","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.root"},{"byte_length":60948,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":2228,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd","sha256":"9727b1e523905625cf8f563cb69c81a4609d9325b3420a57f3f4307d63ebb130","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd","sha256":"62ef83f100a1e86cef2719a1611985cf993614d9434d9dd55eb6c78881ab7608","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"837ce5ae2804ba4b2ae770e12a6b656c504104b62a38742eb39d1622b16d4acb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.root"}],"spec":"lexlean/preservation/1"} +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"9b759e47541781eb530e49000bac2c0f22fbcda44821350a66b1d27936daa54f"},"roots":[{"byte_length":141563,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0","program":{"byte_length":36186,"sha256":"3f39f0a6f1b7639eb1a021d09aa351a8a51cde520fe0d8fcb48317283f1e3d63"},"renderings":[{"byte_length":187486,"composed":{"byte_length":40217,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore","sha256":"c42fce0855a93d62f5a1a5f77272334ea90bfa769f2c41569260e16a447f05ae","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.Compose.RustCore.root"},"crate":{"byte_length":25957,"sha256":"373227b883bed3b90092ff7c99c97a8a2479213d7c773852355fff7648beaf0e"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore","sha256":"dbdf792b97c9bfd85ab6e538becf6e259591c55e44a125db8c0139cc90ef00d9","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.RustCore.root"}],"root":"Reasoning.Main.triageLevel","sha256":"381c4d707b7d7729ff7620cab159da75406c160decc111932f425d3ec9600e2e","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R0.root"},{"byte_length":143462,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1","program":{"byte_length":36679,"sha256":"9e2f7386e9b0f0c3f8861e9e54bba15353cc8c7b465664f5e992b8210e83815f"},"renderings":[{"byte_length":188860,"composed":{"byte_length":40218,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore","sha256":"b1cf9765470bae527b91b846ab8cb6b32b580f9e2380cdd6c62733b46ad162fa","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.Compose.RustCore.root"},"crate":{"byte_length":26098,"sha256":"ac88de1419f5c1f6ed9e589a800cfc4afcf42b55c77f46b29c439164d44f68c7"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore","sha256":"a5b466d5743e565f0fa7d6a0c792ca3598c3c7a4fce740726e55b8d0bc7a757e","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.RustCore.root"}],"root":"Reasoning.Main.gatewayLevel","sha256":"b4293a5f385a647dc3d8c9e62436052e3841e88334367231deb072bbd6df4119","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R1.root"},{"byte_length":189443,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2","program":{"byte_length":47876,"sha256":"2a46e167d6afdf96fd1c4ed4ddd462c30eb1ab849e08b0847f3c4aa87ab5fd0a"},"renderings":[{"byte_length":283431,"composed":{"byte_length":52978,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd","sha256":"d2e59cb7e7f96279b0823f3f81ab69c07484ad80ce8e8b723a3c0ec4a14e341a","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.Compose.RustStd.root"},"crate":{"byte_length":45349,"sha256":"5cdcbdf73202f418deae91f5ed3daf71e8457190441c122784ee1fa157a61251"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd","sha256":"241319528d14f9272e57b6734b4e2deee8e5d11f31732c78b3c85c95e3658ad7","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.RustStd.root"}],"root":"Reasoning.Main.triageSteps","sha256":"cd712b0c22b0ae79316fe4e8b7cfc4ccc25cbbac5e96fd50c57ded29779b5a79","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R2.root"},{"byte_length":155284,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3","program":{"byte_length":41744,"sha256":"9a5f37cae3bc362991271aa26ace2db53c7ca9c38618a34455fbc70882ae476d"},"renderings":[{"byte_length":230142,"composed":{"byte_length":40371,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd","sha256":"56ff6fc98f77523c7cf1b6b9f0c86e87429e7aaed01363769e1d33f90e16c6f6","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.Compose.RustStd.root"},"crate":{"byte_length":39550,"sha256":"b66e8320820654694b9a745a745a90017dcfa9a7713e85d44d8257fd7d3d9c51"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd","sha256":"e8e3fa5bd11adab9e0bfe449883a107328a3f6b5074087ffbda839c7cb527f5c","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.RustStd.root"}],"root":"Reasoning.Main.planLeft","sha256":"743e77004a5f4afe5c809b23d810763d2bb74ed76dd296e9663dda4cc62413bb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R3.root"},{"byte_length":42567,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4","program":{"byte_length":11798,"sha256":"3a65f411f6eb41c898bd2f895719b295fbc8afaefc20212dfc8e111f582a3db5"},"renderings":[{"byte_length":62656,"composed":{"byte_length":26414,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd","sha256":"a949c814a1c9f07562ff1ebeba2a40cbf1b0e9097eed5862ea9bcbaf07e9f7ba","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.Compose.RustStd.root"},"crate":{"byte_length":20147,"sha256":"7ffb7b92f94e45432a616d2778e61294d980f58e03d30392ae519e3002aaa41b"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd","sha256":"697cf6fcd67bd5414da7e11e1b5e050f71d51a422be03b80114a1e221a4c38ff","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.RustStd.root"}],"root":"Reasoning.Main.doseLevel","sha256":"842356d3e066cd5f18866b55f2e9f810e9d46e59a4bf23fa1aadeb146b244552","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R4.root"},{"byte_length":130218,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5","program":{"byte_length":33983,"sha256":"96c393acd11d0f45f881f960db3eba8734d1115aa71b0b73b3e73d13f08a0488"},"renderings":[{"byte_length":175999,"composed":{"byte_length":40210,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore","sha256":"048b5d7ca4412ef096d4ac80e6ea984cc23abd0e52ffa03f6ab3ce6ff31088fe","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.Compose.RustCore.root"},"crate":{"byte_length":24856,"sha256":"e759aefcfa353eb5202d08cc08c7dcc378cd0994d8be42bca802c174d340d28d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore","sha256":"731051f84c765f81bbcc0362e37ad56209a02d093a789c77740ea4eaa5d189ae","target":"rust-core","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.RustCore.root"}],"root":"Reasoning.Main.gradeLevel","sha256":"3e2106d5a82afdf691e67037277bce1a6fe51f7f6119387c13e618e0cb0d19e2","targets":["rust-core"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R5.root"},{"byte_length":116887,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6","program":{"byte_length":28344,"sha256":"8c9c2a16fb25398ae97777f69e934175246b5e37acece648c6661c6f3dfc7282"},"renderings":[{"byte_length":164251,"composed":{"byte_length":37750,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd","sha256":"39e149446a8329fba91e32a82b3295f35dd08a48d0d4fdc713d5e8996458b081","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.Compose.RustStd.root"},"crate":{"byte_length":32915,"sha256":"224dabc5daa77c8128eb9d49f2dcd528155354328a75b0129ec1818f247b918c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd","sha256":"1b1bf1df38151d34bed65a608d05a7c4f4bebfbe777764d3f257032424c92359","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.RustStd.root"}],"root":"Reasoning.Main.screenDose","sha256":"4f05c09d3d376cce7bfd22fa2eb2099f6c460517d22a18a653606ca2c9dc8824","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R6.root"},{"byte_length":60948,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7","program":{"byte_length":16614,"sha256":"bf95bba329a7f73d9a7036f8fd91df829a4b615b2c3a7249c9998238687ecfee"},"renderings":[{"byte_length":57695,"composed":{"byte_length":15140,"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd","sha256":"3ad364ea7bfb645ff54cdd99016e6a24230c3d60a7eee83e7830fc490c25412d","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.Compose.RustStd.root"},"crate":{"byte_length":18308,"sha256":"2d2db53b580aa55f9a76a185cbcde3ca8a0689b2607c2f3fc11e2b94fb89ac8d"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd","sha256":"62ef83f100a1e86cef2719a1611985cf993614d9434d9dd55eb6c78881ab7608","target":"rust-std","theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.RustStd.root"}],"root":"Reasoning.Main.spendLeft","sha256":"837ce5ae2804ba4b2ae770e12a6b656c504104b62a38742eb39d1622b16d4acb","targets":["rust-std"],"theorem":"LexLeanPreserve.C6d3e375f76cbc573b09fef98086539e0.R7.root"}],"spec":"lexlean/preservation/1"} From 928fb2c694a0aa88a4886eaaef061007bb71c432 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Fri, 16 Oct 2026 08:27:21 +0100 Subject: [PATCH 15/17] #89 stage 1: RP-11's SP range ends at SP-14; a data certificate lifts the heartbeat budgets as the text did (SP-02) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f631c0323..67b4ba5d7 100644 --- a/README.md +++ b/README.md @@ -169,7 +169,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 | `PX-01`..`PX-12` | `build` | From c8294404e1710cd0dc4261724269b7f8d90944b3 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Fri, 16 Oct 2026 08:51:20 +0100 Subject: [PATCH 16/17] #89 stage 1: the conformance cases read certificate E as data (SP-09 statement and namespaces, the composition plants over the DAG), the legacy rendering lifts the heartbeat budgets, failing_declaration reads the decoder's message, 383 register rows --- CHANGELOG.md | 2 +- README.md | 2 +- SPEC.md | 2 +- crates/conformance/src/cases/preservation.rs | 396 +++++++++++++++++- crates/conformance/src/cases/repository.rs | 2 +- crates/conformance/src/preservation.rs | 188 ++++++++- crates/lexlean/src/backend/core.rs | 7 + .../src/production/certificate/data.rs | 2 +- crates/lexlean/src/production/preserve.rs | 9 + xtask/src/spec_links.rs | 4 +- 10 files changed, 593 insertions(+), 21 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 466e2b82c..3b07b1d93 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -32,7 +32,7 @@ versions, and the entries below say what each tag does and does not claim. (`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` (382 rows with `SP-13` and `RB-09`). + untouched. No diagnostic code is new; the register gains `SP-14` (383 rows with `SP-13`, `RB-09`, and `PX-13`). - Child deadlines remain active while reading inherited output pipes after the direct child exits (#132). The process group stays registered until both readers finish, so a timeout or an embedding host can end the remaining diff --git a/README.md b/README.md index 2e7b36449..faa5ad5b8 100644 --- a/README.md +++ b/README.md @@ -137,7 +137,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 382 registered conformance IDs are implemented and pass; `just vv` runs clean from a checkout with the pinned toolchain installed. +All 383 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. diff --git a/SPEC.md b/SPEC.md index 524c4761f..067015e8b 100644 --- a/SPEC.md +++ b/SPEC.md @@ -9259,7 +9259,7 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `AU-11` | `authoring` | Malformed core notation fails closed and never panics: an unclosed delimiter, a keyword used as a name, a label that is not the number of its node, a reference to a node not yet written, a numeral with a redundant leading zero, a statement that defines no node, a nesting beyond the bound, and every single-token deletion and duplication of a committed module fail with a registered code at a position in the notation or link to a module that decodes. | §17.21.8 | | `AU-12` | `authoring` | A core module written with names for its statements and its variables reads to exactly the module its canonical notation reads to, and the canonical notation keeps the names of the binders and writes the numbers of the statements: a variable is written by the name of its binder exactly when no nearer binder has the name, a constant a binder in scope is named like is written as a string, a theorem added to the certification library by name reads to the committed module and is written as the committed bytes, and an unknown or repeated statement name and a variable given universe levels are refused with a position. | §17.21.8 | -**Total required capability IDs:** 382. +**Total required capability IDs:** 383. 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/crates/conformance/src/cases/preservation.rs b/crates/conformance/src/cases/preservation.rs index 9b0d44046..4de3846f6 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 @@ -2828,7 +3206,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)); } } } @@ -2865,12 +3243,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 { @@ -2918,14 +3291,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}"); } } diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index 48dd0f419..a3c48a201 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(), 382, "§31 has 382 rows"); + assert_eq!(table.len(), 383, "§31 has 383 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/preservation.rs b/crates/conformance/src/preservation.rs index 092b3d850..0d7776bca 100644 --- a/crates/conformance/src/preservation.rs +++ b/crates/conformance/src/preservation.rs @@ -670,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] @@ -697,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 { @@ -1054,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/lexlean/src/backend/core.rs b/crates/lexlean/src/backend/core.rs index 25ea9a0de..3c0672f21 100644 --- a/crates/lexlean/src/backend/core.rs +++ b/crates/lexlean/src/backend/core.rs @@ -1417,6 +1417,13 @@ fn lean_text_with(core: &CoreModule, legacy_scope: Option<&str>) -> Result Composer<'g, 'a> { 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)) + 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 diff --git a/crates/lexlean/src/production/preserve.rs b/crates/lexlean/src/production/preserve.rs index 99976fcf5..46fb27349 100644 --- a/crates/lexlean/src/production/preserve.rs +++ b/crates/lexlean/src/production/preserve.rs @@ -1752,6 +1752,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/xtask/src/spec_links.rs b/xtask/src/spec_links.rs index 36fe0aa47..19ce9650b 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() != 382 { - return Err(format!("RP-07: the §31 table has {} rows, not 382", rows.len()).into()); + if rows.len() != 383 { + return Err(format!("RP-07: the §31 table has {} rows, not 383", 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. From 63473cc37f7f601ed80ce01588619e7fc6177dee Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 19:22:54 +0000 Subject: [PATCH 17/17] chore(#146): regenerate the language-1.2 records and fixtures on the combined tree (certificate E as data, main with #158) The verification records of the four certificate corpora and the two certificate fixtures are regenerated by the repository's writers on the tree that merges #158; check-calculus, check-golden, check-production-export, validate-model and validate-spec-links pass on it. --- .../R0/Compose/RustStd.lex.tex | 585 +++++ .../R1/Compose/RustStd.lex.tex | 590 ++++++ .../R2/Compose/RustStd.lex.tex | 621 ++++++ .../R3/Compose/RustStd.lex.tex | 600 ++++++ .../R4/Compose/RustStd.lex.tex | 601 ++++++ .../R5/Compose/RustStd.lex.tex | 471 +++++ .../R6/Compose/RustStd.lex.tex | 471 +++++ .../R7/Compose/RustStd.lex.tex | 421 ++++ .../R8/Compose/RustStd.lex.tex | 474 +++++ .../models/expected/verify/preserve/audit.txt | 12 +- .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../R0/Compose/RustStd.lex.tex | 1883 +++++++++++++++++ .../R1/Compose/RustStd.lex.tex | 728 +++++++ .../R10/Compose/RustCore.lex.tex | 462 ++++ .../R10/Compose/RustStd.lex.tex | 462 ++++ .../R11/Compose/RustCore.lex.tex | 463 ++++ .../R11/Compose/RustStd.lex.tex | 463 ++++ .../R12/Compose/RustCore.lex.tex | 578 +++++ .../R12/Compose/RustStd.lex.tex | 578 +++++ .../R13/Compose/RustStd.lex.tex | 585 +++++ .../R14/Compose/RustCore.lex.tex | 776 +++++++ .../R14/Compose/RustStd.lex.tex | 776 +++++++ .../R15/Compose/RustCore.lex.tex | 615 ++++++ .../R15/Compose/RustStd.lex.tex | 615 ++++++ .../R16/Compose/RustCore.lex.tex | 424 ++++ .../R16/Compose/RustStd.lex.tex | 424 ++++ .../R17/Compose/RustCore.lex.tex | 521 +++++ .../R17/Compose/RustStd.lex.tex | 521 +++++ .../R18/Compose/RustCore.lex.tex | 462 ++++ .../R18/Compose/RustStd.lex.tex | 462 ++++ .../R19/Compose/RustStd.lex.tex | 463 ++++ .../R2/Compose/RustStd.lex.tex | 658 ++++++ .../R20/Compose/RustCore.lex.tex | 418 ++++ .../R20/Compose/RustStd.lex.tex | 418 ++++ .../R21/Compose/RustCore.lex.tex | 475 +++++ .../R21/Compose/RustStd.lex.tex | 475 +++++ .../R22/Compose/RustCore.lex.tex | 501 +++++ .../R22/Compose/RustStd.lex.tex | 501 +++++ .../R23/Compose/RustCore.lex.tex | 543 +++++ .../R23/Compose/RustStd.lex.tex | 543 +++++ .../R24/Compose/RustCore.lex.tex | 546 +++++ .../R24/Compose/RustStd.lex.tex | 546 +++++ .../R25/Compose/RustCore.lex.tex | 495 +++++ .../R25/Compose/RustStd.lex.tex | 495 +++++ .../R26/Compose/RustStd.lex.tex | 604 ++++++ .../R27/Compose/RustStd.lex.tex | 428 ++++ .../R28/Compose/RustStd.lex.tex | 488 +++++ .../R29/Compose/RustStd.lex.tex | 490 +++++ .../R3/Compose/RustStd.lex.tex | 617 ++++++ .../R30/Compose/RustStd.lex.tex | 637 ++++++ .../R31/Compose/RustStd.lex.tex | 885 ++++++++ .../R32/Compose/RustCore.lex.tex | 467 ++++ .../R32/Compose/RustStd.lex.tex | 467 ++++ .../R33/Compose/RustStd.lex.tex | 573 +++++ .../R4/Compose/RustStd.lex.tex | 606 ++++++ .../R5/Compose/RustStd.lex.tex | 468 ++++ .../R6/Compose/RustStd.lex.tex | 676 ++++++ .../R7/Compose/RustStd.lex.tex | 626 ++++++ .../R8/Compose/RustStd.lex.tex | 1570 ++++++++++++++ .../R9/Compose/RustStd.lex.tex | 501 +++++ .../expected/verify/preserve/audit.txt | 44 +- .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../R0/Compose/RustCore.lex.tex | 464 ++++ .../R0/Compose/RustStd.lex.tex | 464 ++++ .../R1/Compose/RustCore.lex.tex | 565 +++++ .../R1/Compose/RustStd.lex.tex | 564 +++++ .../R2/Compose/RustCore.lex.tex | 417 ++++ .../R2/Compose/RustStd.lex.tex | 416 ++++ .../R3/Compose/RustCore.lex.tex | 417 ++++ .../R3/Compose/RustStd.lex.tex | 416 ++++ .../R4/Compose/RustStd.lex.tex | 461 ++++ .../R5/Compose/RustStd.lex.tex | 461 ++++ .../expected/verify/preserve/audit.txt | 4 +- .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../R0/Compose/RustCore.lex.tex | 1341 ++++++++++++ .../R1/Compose/RustCore.lex.tex | 1341 ++++++++++++ .../R2/Compose/RustStd.lex.tex | 1741 +++++++++++++++ .../R3/Compose/RustStd.lex.tex | 1301 ++++++++++++ .../R4/Compose/RustStd.lex.tex | 877 ++++++++ .../R5/Compose/RustCore.lex.tex | 1341 ++++++++++++ .../R6/Compose/RustStd.lex.tex | 1218 +++++++++++ .../R7/Compose/RustStd.lex.tex | 505 +++++ .../expected/verify/preserve/audit.txt | 50 +- .../verify/preserve/preservation.json | 2 +- .../preserve/LexLeanPreserve.Audit.json | 2 +- .../expected/command.json | 2 +- .../expected/diagnostics.json | 2 +- 90 files changed, 48187 insertions(+), 65 deletions(-) create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R0/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R1/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R2/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R3/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R4/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R5/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R6/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R7/Compose/RustStd.lex.tex create mode 100644 examples/models/expected/verify/preserve/LexLeanPreserve/C6e8361ce3941a9dbed4a89b310886cf8/R8/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R0/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R1/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R10/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R11/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R12/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R13/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R14/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R15/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R16/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R17/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R18/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R19/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R2/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R20/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R21/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R22/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R23/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R24/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R25/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R26/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R27/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R28/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R29/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R3/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R30/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R31/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustCore.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R32/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R33/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R4/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R5/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R6/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R7/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R8/Compose/RustStd.lex.tex create mode 100644 examples/production-coverage/expected/verify/preserve/LexLeanPreserve/Cc2030093ffdb7a3e8068874ff75532ac/R9/Compose/RustStd.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustCore.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R0/Compose/RustStd.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustCore.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R1/Compose/RustStd.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustCore.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R2/Compose/RustStd.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustCore.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R3/Compose/RustStd.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R4/Compose/RustStd.lex.tex create mode 100644 examples/production/expected/verify/preserve/LexLeanPreserve/C3950237c975b30f5dd9298b8e09919c9/R5/Compose/RustStd.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R0/Compose/RustCore.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R1/Compose/RustCore.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R2/Compose/RustStd.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R3/Compose/RustStd.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R4/Compose/RustStd.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R5/Compose/RustCore.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R6/Compose/RustStd.lex.tex create mode 100644 examples/reasoning/expected/verify/preserve/LexLeanPreserve/Cd362aa768021aa2dd83c667dc02645c0/R7/Compose/RustStd.lex.tex 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.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.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.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.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.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.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.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.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 d8d3edb2c..f0a0bc728 100644 --- a/examples/models/expected/verify/preserve/audit.txt +++ b/examples/models/expected/verify/preserve/audit.txt @@ -7800,12 +7800,12 @@ 'LexLeanPreserve.C6e8361ce3941a9dbed4a89b310886cf8.R8.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C0f600e9a78a6f4d72a3e289fa7bc71d4.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C0f600e9a78a6f4d72a3e289fa7bc71d4.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C0f600e9a78a6f4d72a3e289fa7bc71d4.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C0f600e9a78a6f4d72a3e289fa7bc71d4.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.C0f600e9a78a6f4d72a3e289fa7bc71d4.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C0f600e9a78a6f4d72a3e289fa7bc71d4.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] +'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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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 00e34cdd6..c6ec7e5d5 100644 --- a/examples/production-coverage/expected/verify/preserve/audit.txt +++ b/examples/production-coverage/expected/verify/preserve/audit.txt @@ -8065,28 +8065,28 @@ 'LexLeanPreserve.Cc2030093ffdb7a3e8068874ff75532ac.R33.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R0.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R0.Compose.RustStd.__wtItems_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R0.Compose.RustStd.__wtAux_1' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R0.Compose.RustStd.__wtItems_3' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R0.Compose.RustStd.__wtAux_4' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R0.Compose.RustStd.__wtAux_2' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R0.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R12.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R12.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R13.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R14.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R14.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R14.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R14.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R14.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R14.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R30.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R30.Compose.RustStd.__wtItems_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R31.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R31.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R31.Compose.RustStd.__wtItems_0' depends on axioms: [propext] -'LexLeanPreserve.Ce371869b9b3ca32388daafe8348a6ca5.R33.Compose.RustStd.__wt_0' depends on axioms: [propext] +'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.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.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.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.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.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.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.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.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.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.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 e7814ba59..5759e90b4 100644 --- a/examples/production/expected/verify/preserve/audit.txt +++ b/examples/production/expected/verify/preserve/audit.txt @@ -7803,8 +7803,8 @@ 'LexLeanPreserve.C3950237c975b30f5dd9298b8e09919c9.R5.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.C0873d7adc0406a004403264fdb2d9dea.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.C0873d7adc0406a004403264fdb2d9dea.R1.Compose.RustStd.__wt_0' depends on axioms: [propext] +'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.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.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.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.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.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.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.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.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 ff3313bf3..3c882db36 100644 --- a/examples/reasoning/expected/verify/preserve/audit.txt +++ b/examples/reasoning/expected/verify/preserve/audit.txt @@ -7793,31 +7793,31 @@ 'LexLeanPreserve.Cd362aa768021aa2dd83c667dc02645c0.R7.Compose.RustStd.root' depends on axioms: [propext, Classical.choice, Quot.sound] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R0.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R0.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R0.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R1.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R1.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R1.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R2.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R2.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R2.Compose.RustStd.__wt_3' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R2.Compose.RustStd.__wt_4' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R2.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R3.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R3.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R3.Compose.RustStd.__wt_3' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R3.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R4.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R4.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R5.Compose.RustCore.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R5.Compose.RustCore.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R5.Compose.RustCore.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R6.Compose.RustStd.__wt_0' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R6.Compose.RustStd.__wt_2' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R6.Compose.RustStd.__wt_3' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R6.Compose.RustStd.__wt_1' depends on axioms: [propext] -'LexLeanPreserve.Cf04b35f2e1794332ed2a5b996f01296f.R7.Compose.RustStd.__wt_0' depends on axioms: [propext] +'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/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"}]