From 772364032eea79f7fa8371feaec5bc59ea6ddebf Mon Sep 17 00:00:00 2001 From: Alexander Flom Date: Thu, 12 Nov 2026 05:13:37 +0000 Subject: [PATCH 1/6] Add owned bounded kernel type inspection --- CONFORMANCE.md | 1 + Cargo.toml | 2 +- SPEC.md | 13 +- crates/conformance/src/cases/verification.rs | 62 +++++ crates/conformance/tests/conformance.rs | 5 + crates/lexlean/src/api.rs | 3 + crates/lexlean/src/api/inspection.rs | 210 +++++++++++++++ crates/lexlean/src/api/inspection_core.rs | 243 ++++++++++++++++++ crates/lexlean/src/cli.rs | 56 ++++ crates/lexlean/src/production/lcnf.rs | 62 ++++- features/suites/verification.feature | 8 + language/lcnf-1.2/tooling/src/Extract.lex.tex | 232 ++--------------- model/ids.toml | 6 + spec/src/Chapter22.lex.tex | 68 +++++ spec/src/IdsVR.lex.tex | 7 + 15 files changed, 766 insertions(+), 212 deletions(-) create mode 100644 crates/lexlean/src/api/inspection.rs create mode 100644 crates/lexlean/src/api/inspection_core.rs diff --git a/CONFORMANCE.md b/CONFORMANCE.md index 6b045945a9..b6fa6387f8 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -684,6 +684,7 @@ the error registry does not sanction (R5, `ERRORS.md`). | `VR-21` | `build` | A multi-module project whose imports form nontrivial frontiers verifies at width 1 and at a larger width to byte-identical verified directories and the same attestation identity, observed axiom sets, and policy rows, and no completion order orders a record or changes which failure is reported. | | `VR-22` | `build` | Performance telemetry is written only to the CI evidence directory the environment names, a verification with telemetry on publishes byte-identical artifacts to one without, and telemetry planted in a verified artifact fails the gate. | | `VR-23` | `build` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused. | +| `VR-28` | `build` | Kernel type inspection runs an owned bounded adapter against the pinned local Lean environment, preserves structural names, universe levels and binder visibility, rejects unresolved terms and exhausted traversal budgets, and returns inspection data without a verification attestation or proof-acceptance claim. | ## Cited authorities diff --git a/Cargo.toml b/Cargo.toml index 7688d3f806..809cb57f87 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,7 +29,7 @@ rustix = { version = "1", default-features = false, features = ["std", "process" same-file = "1.0" semver = "1.0" serde = { version = "1", features = ["derive"] } -serde_json = { version = "1", features = ["unbounded_depth"] } +serde_json = { version = "1", features = ["unbounded_depth", "arbitrary_precision"] } sha2 = "0.10" signal-hook = { version = "0.3", default-features = false, features = ["iterator"] } tempfile = "3" diff --git a/SPEC.md b/SPEC.md index ec2771174b..401f5e16fc 100644 --- a/SPEC.md +++ b/SPEC.md @@ -9502,6 +9502,16 @@ Wall time, resident-set and swap measurements, scheduling and completion order, Telemetry is write-only: no stage reads it, no ID or verified artifact contains any of it, and a failure to write it changes no result. Every key it uses is in a closed vocabulary (`wall_ms`, `started_unix_ms`, `peak_rss_kib`, `peak_swap_kib`, `mem_total_kib`, `mem_available_kib`, `swap_total_kib`, `swap_used_kib`, `host_cpus`, `process_width`, `completion_seq`), and a JSON key of that vocabulary anywhere in a verified directory fails the gate: `cargo xtask verify-examples` checks every example's verified directory for one. +### 22.13 Kernel type inspection + +`lexlean inspect` and the sibling `api::inspection` API inspect declarations in the pinned local Lean environment. Inspection is data retrieval, not verification: it runs no proof acceptance shortcut and publishes no verification attestation (`VR-28`). The caller supplies explicit import modules and declaration names; the compiler admits at most 64 declarations, a positive traversal budget no larger than 65536 nodes, a depth bound no larger than 128, and a report bound no larger than 8388608 bytes. Invalid requests fail before running the adapter. + +The compiler renders its embedded LexLean tooling adapter through the typed tooling backend and checks the pinned toolchain and registered authority signatures before use. The adapter obtains each declaration's actual kernel type and universe parameters from the loaded environment. It preserves structural names, universes, binder visibility, lambdas, dependent functions, lets, literals and projections; metadata annotations may be omitted because they do not change the kernel type. It rejects free variables, expression metavariables and universe metavariables. A shared traversal budget covers repeated occurrences, names and universes before invoking serialization, so expanding a shared expression cannot bypass the bounds. Budget exhaustion refuses the inspection; it never substitutes a truncated type. + +The result binds the admitted import and declaration request, compiler identity and actual tool identities to the bounded process record and inspected data. Only a normal successful owned process with the exact output schema produces an inspection result. A malformed, noisy, timed-out or interrupted adapter fails without accepted inspection output. The caller remains responsible for owning and pinning the imported library build; inspection data alone establishes neither that ownership nor a theorem's proof acceptance. + +Each declaration also carries a native-core view when its names and expressions are representable by the native-core schema. That view preserves universe parameters, binder visibility, natural literals and scalar-valued string literals and uses only backward arena references. When a kernel projection has no reported elaborator projection label, or a structural name is outside the native-core name schema, the view explicitly reports why it is unrepresentable; the complete structural kernel type remains available. Neither form is a proof candidate or acceptance receipt. + --- ## 23. Command-line interface @@ -11150,6 +11160,7 @@ Every row below is normative, has honesty level `build`, and is projected byte-f | `VR-21` | `verification` | A multi-module project whose imports form nontrivial frontiers verifies at width 1 and at a larger width to byte-identical verified directories and the same attestation identity, observed axiom sets, and policy rows, and no completion order orders a record or changes which failure is reported. | §22.3, §22.4, §22.11 | | `VR-22` | `verification` | Performance telemetry is written only to the CI evidence directory the environment names, a verification with telemetry on publishes byte-identical artifacts to one without, and telemetry planted in a verified artifact fails the gate. | §22.12 | | `VR-23` | `verification` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused. | §9.4, §22.11 | +| `VR-28` | `verification` | Kernel type inspection runs an owned bounded adapter against the pinned local Lean environment, preserves structural names, universe levels and binder visibility, rejects unresolved terms and exhausted traversal budgets, and returns inspection data without a verification attestation or proof-acceptance claim. | §22.13 | | `CL-01` | `cli-api` | Global options and upward project discovery obey the exact CLI contract. | §23.1, §23.2 | | `CL-02` | `cli-api` | Init creates the complete canonical skeleton only in an absent or empty destination and never overwrites. | §23.4 | | `CL-03` | `cli-api` | Lock check, local update, and explicit network acquisition obey their exact mutually exclusive behavior. | §23.4 | @@ -11413,7 +11424,7 @@ Every row below is normative, has honesty level `build`, and is projected byte-f | `NS-06` | `normative-source` | The hand-edited normative inputs of the repository are the `.lex.tex` modules of the specification project: `model/` holds only the projected files and the copies an authority row vendors, every Markdown file at the root is a projection or is on the closed list of hand-written documents, the projections carry the notice that names their source, and no hand-written document restates a registered statement, a plant of each being refused naming R1. | §27.2, §27.5, §27.10 | | `NS-07` | `normative-source` | `cargo xtask spec` changes the chapter modules of the specification project by item: it replaces a block, inserts one after a block, and ports the hunks of a merged SPEC.md that lie outside derived regions, each through the authoring SDK, and it writes nothing unless the regenerated SPEC.md equals the intended text outside derived regions, refusing a first line that matches no block or two and a hunk that spans two blocks. | §24.8, §27.5 | -**Total required capability IDs:** 486. +**Total required capability IDs:** 487. 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/verification.rs b/crates/conformance/src/cases/verification.rs index 3cbe4020a9..58acbfea37 100644 --- a/crates/conformance/src/cases/verification.rs +++ b/crates/conformance/src/cases/verification.rs @@ -36,6 +36,68 @@ const LEAN_BACKED: [&str; 14] = [ ]; pub(crate) fn run(id: &str) { + if id == "VR-28" { + let project = P::example(); + let (exit, help, errors) = project.cli(&["inspect", "--help"]); + assert_eq!(exit, 0, "inspection is a public command: {errors}"); + assert!(help.contains("--declaration") && help.contains("--max-nodes")); + if !support::lean_backed(id) { + return; + } + let (exit, _, errors) = project.cli(&[ + "inspect", + "--import", + "Init", + "--declaration", + "Eq.refl", + "--max-nodes", + "4096", + "--max-depth", + "64", + "--out", + "inspection.json", + ]); + assert_eq!(exit, 0, "owned kernel inspection: {errors}"); + let report: serde_json::Value = serde_json::from_slice( + &std::fs::read(project.root.join("inspection.json")).expect("inspection report"), + ) + .expect("inspection JSON"); + assert_eq!(report["spec"], "lexlean/kernel-inspection/1"); + assert!(report.get("attestation_id").is_none()); + let declarations = report["declarations"].as_array().expect("declarations"); + assert_eq!(declarations.len(), 1); + assert_eq!(declarations[0]["native"]["status"], "available"); + let arena = declarations[0]["native"]["nodes"] + .as_array() + .expect("native arena"); + let root = declarations[0]["native"]["root"] + .as_u64() + .expect("native root") as usize; + assert!(root < arena.len()); + assert_eq!(arena[root]["k"], "p"); + let ty = declarations[0]["type"].to_string(); + assert!(ty.contains("forallE") && ty.contains("implicit")); + assert!(!declarations[0]["parameters"] + .as_array() + .expect("universe parameters") + .is_empty()); + let (exit, _, _) = project.cli(&[ + "inspect", + "--import", + "Init", + "--declaration", + "Eq.refl", + "--max-nodes", + "1", + "--max-depth", + "1", + "--out", + "refused.json", + ]); + assert_ne!(exit, 0, "bounded inspection cannot truncate a type"); + assert!(!project.root.join("refused.json").exists()); + return; + } // The operational cases (§22.11, §22.12) gate their own Lean-backed halves. if matches!(id, "VR-20" | "VR-21" | "VR-22" | "VR-23") { super::operational::run(id); diff --git a/crates/conformance/tests/conformance.rs b/crates/conformance/tests/conformance.rs index c984ab0689..decd9b8337 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -1125,6 +1125,11 @@ fn conformance_vr_23() { repo_conformance::cases::run("VR-23"); } +#[test] +fn conformance_vr_28() { + repo_conformance::cases::run("VR-28"); +} + #[test] fn conformance_cl_01() { repo_conformance::cases::run("CL-01"); diff --git a/crates/lexlean/src/api.rs b/crates/lexlean/src/api.rs index d6cf1b74c7..1210e72b32 100644 --- a/crates/lexlean/src/api.rs +++ b/crates/lexlean/src/api.rs @@ -22,6 +22,9 @@ use crate::source::coverage::Coverage; // The production export contract (§24.7): the stable façade through which a // consumer compiles production roots to certified Rust packages and replays // the result without the source. +/// Bounded kernel type inspection, without proof acceptance. +pub mod inspection; +mod inspection_core; pub mod production; // The migration of a language-1.1 project to language 1.2 (§17.12): one diff --git a/crates/lexlean/src/api/inspection.rs b/crates/lexlean/src/api/inspection.rs new file mode 100644 index 0000000000..9fce096b9c --- /dev/null +++ b/crates/lexlean/src/api/inspection.rs @@ -0,0 +1,210 @@ +//! Owned, bounded kernel-type inspection (§22.13). This produces input data, +//! never a verification attestation. The caller owns its library build. + +use camino::Utf8PathBuf; +use serde::{Deserialize, Serialize}; + +use super::Engine; +use crate::artifact::content_id::Sha256Digest; +use crate::diagnostic::Diagnostic; +use crate::error::LexLeanError; +use crate::verify::child::{self, ChildHome, ChildSpec, Normalizer}; + +/// A bounded query against the project's pinned local Lean environment. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct InspectionRequest { + /// Fully qualified module names, imported in this order. + pub imports: Vec, + /// Fully qualified declaration names, inspected in this order. + pub declarations: Vec, + /// Shared traversal budget, including names and universe levels. + pub max_nodes: u64, + /// Maximum structural nesting depth. + pub max_depth: u64, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct RawReport { + spec: String, + lean: LeanIdentity, + declarations: Vec, +} + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct LeanIdentity { + version: String, + githash: String, +} + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Declaration { + name: serde_json::Value, + parameters: Vec, + #[serde(rename = "type")] + ty: serde_json::Value, +} + +fn refusal(reason: impl Into) -> LexLeanError { + LexLeanError::from_diagnostic(Diagnostic::new(crate::code!("LLV7002"), reason)) +} + +fn identifier(name: &str) -> bool { + !name.is_empty() + && name.len() <= 4096 + && name.split('.').all(|segment| { + let mut bytes = segment.bytes(); + bytes + .next() + .is_some_and(|b| b.is_ascii_alphabetic() || b == b'_') + && bytes.all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'\'') + }) +} + +fn structural_name(name: &str) -> serde_json::Value { + name.split('.').fold( + serde_json::Value::Null, + |parent, segment| serde_json::json!({"str": [parent, segment]}), + ) +} + +/// Inspect exact kernel types through the embedded LexLean-authored adapter. +/// No caller-supplied type or receipt participates in the result. +/// +/// # Errors +/// Rejects invalid bounds/names, toolchain drift, failed or noisy processes, +/// incomplete reports, unresolved terms, and exhausted traversal budgets. +pub fn inspect(engine: &Engine, request: &InspectionRequest) -> Result, LexLeanError> { + if request.declarations.is_empty() + || request.declarations.len() > 64 + || request.imports.is_empty() + || request.imports.len() > 64 + || !(1..=65536).contains(&request.max_nodes) + || !(1..=128).contains(&request.max_depth) + || !request + .imports + .iter() + .chain(&request.declarations) + .all(|name| identifier(name)) + || request + .declarations + .iter() + .collect::>() + .len() + != request.declarations.len() + { + return Err(LexLeanError::from_diagnostic(Diagnostic::new( + crate::code!("LLC0002"), "inspection requires 1..64 distinct qualified declarations, 1..64 imports, 1..65536 nodes and 1..128 depth", + ))); + } + let project = engine.project(); + let mut limits = project.config.limits.clone(); + limits.max_child_output_bytes = limits.max_child_output_bytes.min(8388608); + let toolchain = + crate::verify::toolchain::preflight(&limits).map_err(LexLeanError::from_diagnostic)?; + let request_bytes = serde_json::to_vec(request).map_err(|error| refusal(error.to_string()))?; + let request_id = Sha256Digest::of(&request_bytes); + let driver = crate::production::lcnf::inspection_driver( + &request_id.to_hex()[..32], + &request.declarations, + &request.imports, + request.max_nodes, + request.max_depth, + ) + .map_err(refusal)?; + let scratch = tempfile::Builder::new() + .prefix("lexlean-inspection-") + .tempdir() + .map_err(|error| refusal(format!("inspection staging: {error}")))?; + let directory = Utf8PathBuf::from_path_buf(scratch.path().to_owned()) + .map_err(|_| refusal("inspection staging path is not UTF-8"))?; + let source = directory.join(format!("{}.lean", driver.name)); + std::fs::write(&source, driver.text.as_bytes()) + .map_err(|error| refusal(format!("inspection source: {error}")))?; + let workspace = project.root.join(&project.config.lean_workspace); + let bin = toolchain.root.join("bin"); + // Preserve literal kernel strings: path normalization would alter their meaning. + let record = child::run( + &ChildSpec { + tool: "lean", + module: Some(driver.name), + program: &toolchain.lake.path, + executable_sha256: toolchain.lake.sha256, + argv: vec![ + "env".to_owned(), + toolchain.lean.path.to_string(), + source.to_string(), + ], + cwd: &workspace, + extra_env: Vec::new(), + home: ChildHome::Toolchain { + toolchain_bin: &bin, + }, + }, + &limits, + &Normalizer::default(), + ) + .map_err(LexLeanError::from_diagnostic)?; + if record.exit_code != 0 || !record.stderr.trim().is_empty() { + return Err(refusal(format!( + "kernel inspection failed: {}{}", + record.stdout, record.stderr + ))); + } + // The owned adapter prechecks structural depth and total expansion before + // serialization; the process cap also bounds this parser's input bytes. + let mut decoder = serde_json::Deserializer::from_str(&record.stdout); + decoder.disable_recursion_limit(); + let raw = RawReport::deserialize(&mut decoder) + .map_err(|error| refusal(format!("kernel inspection report: {error}")))?; + decoder + .end() + .map_err(|error| refusal(format!("noisy kernel inspection: {error}")))?; + if raw.spec != "lexlean/kernel-inspection/1" + || raw.lean.version != "4.32.1" + || raw.lean.githash != "f054605aea4b840552cca2e725580bffd1e1b704" + || raw.declarations.len() != request.declarations.len() + || raw + .declarations + .iter() + .zip(&request.declarations) + .any(|(row, name)| row.name != structural_name(name)) + { + return Err(refusal( + "kernel inspection identity or declaration coverage mismatch", + )); + } + let executable = std::env::current_exe() + .map_err(|error| refusal(format!("inspection compiler identity: {error}")))?; + let executable_bytes = std::fs::read(executable) + .map_err(|error| refusal(format!("inspection compiler identity: {error}")))?; + let declarations = raw + .declarations + .iter() + .map(|row| { + serde_json::json!({ + "name": row.name, "parameters": row.parameters, "type": row.ty, + "native": super::inspection_core::convert(&row.ty, &row.parameters), + }) + }) + .collect::>(); + let report = serde_json::json!({ + "spec": raw.spec, "lean": raw.lean, "declarations": declarations, + "request": request, "request_id": request_id.to_hex(), + "compiler_semantics_id": crate::compiler_semantics_id_for(&project.config.language).to_hex(), + "adapter_sha256": Sha256Digest::of(driver.text.as_bytes()).to_hex(), + "lexlean_sha256": Sha256Digest::of(&executable_bytes).to_hex(), + "lean_sha256": toolchain.lean.sha256.to_hex(), + "lake_sha256": toolchain.lake.sha256.to_hex(), + "process": {"exit_code": record.exit_code, "stdout_sha256": Sha256Digest::of(record.stdout.as_bytes()).to_hex(), "stderr_sha256": Sha256Digest::of(record.stderr.as_bytes()).to_hex()} + }); + let mut bytes = serde_json::to_vec(&report).map_err(|error| refusal(error.to_string()))?; + bytes.push(b'\n'); + if bytes.len() > 8388608 { + return Err(refusal("kernel inspection report exceeds 8388608 bytes")); + } + Ok(bytes) +} diff --git a/crates/lexlean/src/api/inspection_core.rs b/crates/lexlean/src/api/inspection_core.rs new file mode 100644 index 0000000000..5c69ec64b9 --- /dev/null +++ b/crates/lexlean/src/api/inspection_core.rs @@ -0,0 +1,243 @@ +//! A deterministic native-core view of inspected kernel types. The structural +//! kernel report remains available when elaborator-only projection labels are +//! absent; no invented declaration name is substituted for such metadata. + +use serde::Serialize; +use serde_json::Value; + +use crate::ir::core::{CoreBinderInfo, CoreLevel, CoreNode}; + +#[derive(Serialize)] +#[serde(tag = "status", rename_all = "snake_case")] +pub(super) enum NativeType { + Available { + nodes: Vec, + root: usize, + levels: Vec, + }, + Unrepresentable { + reason: String, + }, +} + +fn keys(value: &Value, expected: &[&str]) -> Result<(), String> { + let object = value.as_object().ok_or("expected structural object")?; + if object.len() != expected.len() || expected.iter().any(|key| !object.contains_key(*key)) { + return Err("unexpected structural fields".to_owned()); + } + Ok(()) +} + +fn tuple(value: &Value, length: usize) -> Result<&[Value], String> { + let values = value.as_array().ok_or("expected structural tuple")?; + if values.len() != length { + return Err("unexpected structural tuple length".to_owned()); + } + Ok(values) +} + +fn natural(value: &Value) -> Result { + value + .as_u64() + .and_then(|number| usize::try_from(number).ok()) + .ok_or_else(|| "structural index is outside the native index range".to_owned()) +} + +fn name(value: &Value) -> Result { + if value.is_null() { + return Ok(String::new()); + } + let (tag, numeric) = if value.get("str").is_some() { + ("str", false) + } else { + ("num", true) + }; + keys(value, &[tag])?; + let parts = tuple(&value[tag], 2)?; + let parent = name(&parts[0])?; + let segment = if numeric { + let number = parts[1] + .as_number() + .ok_or("invalid numeric name component")? + .to_string(); + if number.is_empty() || !number.bytes().all(|byte| byte.is_ascii_digit()) { + return Err("invalid numeric name component".to_owned()); + } + format!("#{number}") + } else { + let text = parts[1].as_str().ok_or("invalid string name component")?; + if text.is_empty() || text.chars().any(char::is_control) { + return Err( + "native-core names cannot represent empty or control-character segments".to_owned(), + ); + } + text.replace('\\', "\\\\") + .replace('.', "\\d") + .replace('#', "\\h") + }; + Ok(if parent.is_empty() { + segment + } else { + format!("{parent}.{segment}") + }) +} + +fn level(value: &Value) -> Result { + let object = value.as_object().ok_or("expected universe level")?; + if object.len() != 1 { + return Err("unexpected universe fields".to_owned()); + } + let (tag, argument) = object.iter().next().ok_or("missing universe constructor")?; + match tag.as_str() { + "zero" if argument.is_null() => Ok(CoreLevel::Zero), + "succ" => Ok(CoreLevel::Succ(Box::new(level(argument)?))), + "max" | "imax" => { + let pair = tuple(argument, 2)?; + let pair = Box::new((level(&pair[0])?, level(&pair[1])?)); + Ok(if tag == "max" { + CoreLevel::Max(pair) + } else { + CoreLevel::IMax(pair) + }) + } + "param" => Ok(CoreLevel::Param(name(argument)?)), + _ => Err("unresolved or unknown universe constructor".to_owned()), + } +} + +fn binder(value: &Value) -> Result { + match value.as_str() { + Some("default") => Ok(CoreBinderInfo::Explicit), + Some("implicit") => Ok(CoreBinderInfo::Implicit), + Some("strictImplicit") => Ok(CoreBinderInfo::StrictImplicit), + Some("instImplicit") => Ok(CoreBinderInfo::Instance), + _ => Err("unknown binder visibility".to_owned()), + } +} + +fn expression(value: &Value, nodes: &mut Vec) -> Result { + let object = value.as_object().ok_or("expected kernel expression")?; + let node = if let Some(constant) = object.get("const") { + keys(value, &["const", "levels"])?; + let levels = object["levels"] + .as_array() + .ok_or("constant universe list missing")?; + CoreNode::Const { + n: name(constant)?, + u: levels.iter().map(level).collect::>()?, + } + } else { + if object.len() != 1 { + return Err("unexpected expression fields".to_owned()); + } + let (tag, argument) = object + .iter() + .next() + .ok_or("missing expression constructor")?; + match tag.as_str() { + "bvar" => CoreNode::BVar { i: natural(argument)? }, + "sort" => CoreNode::Sort { l: level(argument)? }, + "app" => { + let pair = tuple(argument, 2)?; + CoreNode::App { f: expression(&pair[0], nodes)?, x: expression(&pair[1], nodes)? } + } + "lam" | "forallE" => { + keys(argument, &["name", "type", "body", "bi"])?; + let n = name(&argument["name"])?; + let b = binder(&argument["bi"])?; + let t = expression(&argument["type"], nodes)?; + let v = expression(&argument["body"], nodes)?; + if tag == "lam" { CoreNode::Lambda { n, b, t, v } } else { CoreNode::Forall { n, b, t, v } } + } + "letE" => { + keys(argument, &["name", "type", "value", "body", "nondep"])?; + CoreNode::Let { + n: name(&argument["name"])?, t: expression(&argument["type"], nodes)?, + v: expression(&argument["value"], nodes)?, body: expression(&argument["body"], nodes)?, + d: argument["nondep"].as_bool().ok_or("let dependency flag missing")?, + } + } + "lit" => { + if let Some(number) = argument.get("natVal") { + keys(argument, &["natVal"])?; + let digits = number.as_number().ok_or("natural literal is not a number")?.to_string(); + if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) { + return Err("natural literal is not a natural number".to_owned()); + } + CoreNode::Nat { v: digits } + } else { + keys(argument, &["strVal"])?; + CoreNode::String { v: argument["strVal"].as_str().ok_or("string literal is not text")?.chars().map(u32::from).collect() } + } + } + "proj" => return Err("native-core projection labels require elaborator metadata; the exact kernel projection remains in type".to_owned()), + _ => return Err("unresolved or unknown kernel expression".to_owned()), + } + }; + let index = nodes.len(); + nodes.push(node); + Ok(index) +} + +pub(super) fn convert(ty: &Value, parameters: &[Value]) -> NativeType { + let converted = (|| { + let levels = parameters.iter().map(name).collect::, _>>()?; + let mut nodes = Vec::new(); + let root = expression(ty, &mut nodes)?; + Ok::<_, String>((nodes, root, levels)) + })(); + match converted { + Ok((nodes, root, levels)) => NativeType::Available { + nodes, + root, + levels, + }, + Err(reason) => NativeType::Unrepresentable { reason }, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn structural_name_components_remain_distinct() { + assert_eq!( + name(&json!({"str":[null,"a.b#c\\d"]})).unwrap(), + "a\\db\\hc\\\\d" + ); + assert_ne!( + name(&json!({"str":[null,"#0"]})).unwrap(), + name(&json!({"num":[null,0]})).unwrap() + ); + } + + #[test] + fn binder_visibility_and_large_naturals_are_preserved() { + let literal: Value = + serde_json::from_str("{\"lit\":{\"natVal\":184467440737095516160}}").unwrap(); + let ty = json!({"forallE":{"name":null,"bi":"strictImplicit","type":{"sort":{"zero":null}},"body":literal}}); + let NativeType::Available { nodes, root, .. } = convert(&ty, &[]) else { + panic!("representable type"); + }; + assert!(matches!(&nodes[1], CoreNode::Nat { v } if v == "184467440737095516160")); + assert!(matches!( + nodes[root], + CoreNode::Forall { + b: CoreBinderInfo::StrictImplicit, + t: 0, + v: 1, + .. + } + )); + } + + #[test] + fn unresolved_terms_cannot_become_native_candidates() { + assert!(matches!( + convert(&json!({"mvar":null}), &[]), + NativeType::Unrepresentable { .. } + )); + } +} diff --git a/crates/lexlean/src/cli.rs b/crates/lexlean/src/cli.rs index fe7546d2da..ce693097e0 100644 --- a/crates/lexlean/src/cli.rs +++ b/crates/lexlean/src/cli.rs @@ -104,6 +104,24 @@ enum CommandKind { /// Explicit input modules. inputs: Vec, }, + /// Inspect bounded kernel types from the pinned local Lean environment. + Inspect { + /// Modules to import, in order. + #[arg(long = "import", required = true)] + imports: Vec, + /// Fully qualified declarations to inspect. + #[arg(long = "declaration", required = true)] + declarations: Vec, + /// Shared structural traversal budget. + #[arg(long, default_value_t = 65536)] + max_nodes: u64, + /// Maximum structural depth. + #[arg(long, default_value_t = 128)] + max_depth: u64, + /// Destination for the complete inspection report. + #[arg(long)] + out: Utf8PathBuf, + }, /// Build a selection to the fixed content-addressed layout. Build { /// Every module beneath every source root. @@ -568,6 +586,7 @@ pub fn run( CommandKind::Lock { .. } => "lock", CommandKind::Check { .. } => "check", CommandKind::Snapshot { .. } => "snapshot", + CommandKind::Inspect { .. } => "inspect", CommandKind::Build { .. } => "build", CommandKind::Verify { .. } => "verify", CommandKind::Fmt { .. } => "fmt", @@ -667,6 +686,43 @@ pub fn run( outcome.document = Some(snapshot.canonical_bytes()); Ok(()) } + CommandKind::Inspect { + imports, + declarations, + max_nodes, + max_depth, + out, + } => { + let bytes = crate::api::inspection::inspect( + &engine, + &crate::api::inspection::InspectionRequest { + imports, + declarations, + max_nodes, + max_depth, + }, + )?; + let destination = if out.is_absolute() { + out + } else { + working_directory.join(out) + }; + let parent = destination + .parent() + .ok_or_else(|| usage_error("inspection output has no parent"))?; + let mut temporary = tempfile::NamedTempFile::new_in(parent) + .map_err(|error| usage_error(format!("inspection output: {error}")))?; + temporary + .write_all(&bytes) + .map_err(|error| usage_error(format!("inspection output: {error}")))?; + temporary + .persist(&destination) + .map_err(|error| usage_error(format!("inspection output: {error}")))?; + outcome.artifacts.push(destination.to_string()); + outcome.summary = + "inspected kernel types; no verification attestation issued\n".to_owned(); + Ok(()) + } CommandKind::Build { all, inputs } => { let result = engine.build(BuildRequest { selection: selection_from(all, inputs)?, diff --git a/crates/lexlean/src/production/lcnf.rs b/crates/lexlean/src/production/lcnf.rs index 8e85b69d2e..a75ce5fbf1 100644 --- a/crates/lexlean/src/production/lcnf.rs +++ b/crates/lexlean/src/production/lcnf.rs @@ -200,10 +200,66 @@ pub fn driver( /// Returns the reason the driver's declarations do not check against the /// module, or the module does not render. pub fn driver_of( - mut module: ToolingModule, + module: ToolingModule, semantic_hex32: &str, roots: &[String], modules: &[String], +) -> Result { + driver_entry( + module, + semantic_hex32, + modules, + RUN_FUNCTION, + vec![texts(roots), texts(modules)], + ) +} + +/// Render the bounded kernel inspector with the extraction adapter's exact +/// source-pinned signature and registry checks. Names remain structural terms. +/// +/// # Errors +/// Returns an unavailable or ill-typed embedded adapter. +pub fn inspection_driver( + semantic_hex32: &str, + names: &[String], + imports: &[String], + nodes: u64, + depth: u64, +) -> Result { + driver_entry( + adapter()?.clone(), + semantic_hex32, + imports, + "LexLeanExtract.inspectMain", + vec![ + ToolTerm::List { + element: ToolType::Const { + name: "Lean.Name".to_owned(), + arguments: Vec::new(), + }, + elements: names + .iter() + .map(|name| ToolTerm::Name { + value: name.clone(), + }) + .collect(), + }, + ToolTerm::Nat { + value: nodes.to_string(), + }, + ToolTerm::Nat { + value: depth.to_string(), + }, + ], + ) +} + +fn driver_entry( + mut module: ToolingModule, + semantic_hex32: &str, + modules: &[String], + entry: &str, + arguments: Vec, ) -> Result { let mut probes = Vec::new(); let (mut calls, mut plumbing, mut opaques) = (Vec::new(), Vec::new(), Vec::new()); @@ -301,8 +357,8 @@ pub fn driver_of( arguments: vec![texts(&calls), rows, texts(&opaques), texts(&plumbing)], }); module.declarations.push(ToolDeclaration::Evaluate { - function: RUN_FUNCTION.to_owned(), - arguments: vec![texts(roots), texts(modules)], + function: entry.to_owned(), + arguments, }); crate::ir::tooling_check::check(&module) .map_err(|failure| format!("the extraction module: {}", failure.reason))?; diff --git a/features/suites/verification.feature b/features/suites/verification.feature index 0444b94c7e..476e4325c2 100644 --- a/features/suites/verification.feature +++ b/features/suites/verification.feature @@ -2,6 +2,14 @@ Feature: verification The fixed verification pipeline, replay, axiom audit, and attestations (§22). + @VR-28 @build + Scenario: Kernel type inspection runs an owned bounded adapter against the pinned local Lean environment, preserves structural names, universe levels and binder visibility, rejects unresolved terms and exhausted traversal budgets, and returns inspection data without a verification attestation or proof-acceptance claim. + Given the pinned local Lean environment and the embedded typed inspection adapter + When declarations with universe parameters and implicit binders are inspected + Then the report preserves their complete structural kernel types without a verification attestation + And exhausted node or depth budgets refuse inspection without truncated output + And malformed requests and unresolved terms cannot produce accepted inspection data + @VR-01 @build Scenario: Verification runs every specified stage in order and exposes no stage-suppression option. Given the committed nat-add-zero example project verified against the pinned Lean 4.32.1 toolchain diff --git a/language/lcnf-1.2/tooling/src/Extract.lex.tex b/language/lcnf-1.2/tooling/src/Extract.lex.tex index 35ac2d935b..ad512700b9 100644 --- a/language/lcnf-1.2/tooling/src/Extract.lex.tex +++ b/language/lcnf-1.2/tooling/src/Extract.lex.tex @@ -88,16 +88,7 @@ sha256: ca8ef13f4bb13725ebf7bc23c7de72ff1e0af75580a7007f5d3a7c69cc4004de } }, - type{ - name: Lean.BinderInfo, - parameters: [], - constructors: [], - opaque: true, - source: { - file: src/lean/Lean/Expr.lean, - sha256: "7d4418bf9fef6f72eac422db70613848f849f074573392e79fb86fe745e79f7e" - } - }, + type{name: "Lean.BinderInfo", parameters: [], constructors: [{name: "default", fields: []}, {name: "implicit", fields: []}, {name: "strictImplicit", fields: []}, {name: "instImplicit", fields: []}], source: {file: "src/lean/Lean/Expr.lean", sha256: "7d4418bf9fef6f72eac422db70613848f849f074573392e79fb86fe745e79f7e"}}, type{ name: Lean.Compiler.InlineAttributeKind, parameters: [], @@ -1346,16 +1337,7 @@ sha256: c1691a3a7491bca520600d91d74160f5772b2a7ef072ea09ab2dbb19ce586401 } }, - type{ - name: Lean.Level, - parameters: [], - constructors: [], - opaque: true, - source: { - file: src/lean/Lean/Level.lean, - sha256: c1691a3a7491bca520600d91d74160f5772b2a7ef072ea09ab2dbb19ce586401 - } - }, + type{name: "Lean.Level", parameters: [], constructors: [{name: "zero", fields: []}, {name: "succ", fields: [{name: "f0", type: const{name: "Lean.Level", arguments: []}}]}, {name: "max", fields: [{name: "f0", type: const{name: "Lean.Level", arguments: []}}, {name: "f1", type: const{name: "Lean.Level", arguments: []}}]}, {name: "imax", fields: [{name: "f0", type: const{name: "Lean.Level", arguments: []}}, {name: "f1", type: const{name: "Lean.Level", arguments: []}}]}, {name: "param", fields: [{name: "f0", type: const{name: "Lean.Name", arguments: []}}]}, {name: "mvar", fields: [{name: "f0", type: const{name: "Lean.LevelMVarId", arguments: []}}]}], source: {file: "src/lean/Lean/Level.lean", sha256: "c1691a3a7491bca520600d91d74160f5772b2a7ef072ea09ab2dbb19ce586401"}}, type{ name: Lean.LevelMetavarDecl, parameters: [], @@ -1366,16 +1348,7 @@ sha256: "80324069c223d9d4e79f83ac7e9102e073c52168f6673bc6efd2ae4e918bf751" } }, - type{ - name: Lean.Literal, - parameters: [], - constructors: [], - opaque: true, - source: { - file: src/lean/Lean/Expr.lean, - sha256: "7d4418bf9fef6f72eac422db70613848f849f074573392e79fb86fe745e79f7e" - } - }, + type{name: "Lean.Literal", parameters: [], constructors: [{name: "natVal", fields: [{name: "val", type: const{name: "Nat", arguments: []}}]}, {name: "strVal", fields: [{name: "val", type: const{name: "String", arguments: []}}]}], source: {file: "src/lean/Lean/Expr.lean", sha256: "7d4418bf9fef6f72eac422db70613848f849f074573392e79fb86fe745e79f7e"}}, type{ name: Lean.LocalDecl, parameters: [], @@ -3982,182 +3955,7 @@ sha256: "44f86ebbb9ab743a05c6ebe2c674aadbf2c822bee874f1b16d7e6c8d56318dc9" } }, - plumbing{ - names: [ - Applicative.toPure, - Array.casesOn, - Array.mkEmpty, - Bool.casesOn, - Char.ofNat, - EIO, - EmptyCollection.emptyCollection, - Eq, - Eq.casesOn, - Eq.ndrec, - Eq.refl, - Eq.symm, - False, - False.elim, - HEq, - HEq.refl, - IO.RealWorld, - Inhabited, - Inhabited.default, - Inhabited.mk, - Lean.Compiler.LCNF.Alt.casesOn, - Lean.Compiler.LCNF.Arg.casesOn, - Lean.Compiler.LCNF.Cases.casesOn, - Lean.Compiler.LCNF.Code.casesOn, - Lean.Compiler.LCNF.CompilerM.State.mk, - Lean.Compiler.LCNF.CtorInfo.casesOn, - Lean.Compiler.LCNF.Decl.toSignature, - Lean.Compiler.LCNF.Decl.value, - Lean.Compiler.LCNF.DeclValue.casesOn, - Lean.Compiler.LCNF.FunDecl.casesOn, - Lean.Compiler.LCNF.LCtx.mk, - Lean.Compiler.LCNF.LetDecl.fvarId, - Lean.Compiler.LCNF.LetDecl.type, - Lean.Compiler.LCNF.LetDecl.value, - Lean.Compiler.LCNF.LetValue.casesOn, - Lean.Compiler.LCNF.LitValue.casesOn, - Lean.Compiler.LCNF.Param.borrow, - Lean.Compiler.LCNF.Param.fvarId, - Lean.Compiler.LCNF.Param.type, - Lean.Compiler.LCNF.Purity.ctorIdx, - Lean.Compiler.LCNF.Signature.levelParams, - Lean.Compiler.LCNF.Signature.name, - Lean.Compiler.LCNF.Signature.params, - Lean.Compiler.LCNF.Signature.safe, - Lean.Compiler.LCNF.Signature.type, - Lean.ConstantInfo.casesOn, - Lean.ConstantInfo.ctorIdx, - Lean.ConstantInfo.rec, - Lean.ConstantKind.casesOn, - Lean.ConstantVal.type, - Lean.ConstructorVal.induct, - Lean.ConstructorVal.numFields, - Lean.ConstructorVal.numParams, - Lean.ConstructorVal.toConstantVal, - Lean.Core.instAddMessageContextCoreM, - Lean.Core.instInhabitedCoreM, - Lean.Core.instMonadCoreM, - Lean.Core.instMonadEnvCoreM, - Lean.Core.instMonadLiftIOCoreM, - Lean.Core.instMonadNameGeneratorCoreM, - Lean.Core.instMonadRefCoreM, - Lean.DefinitionSafety.casesOn, - Lean.DefinitionVal.safety, - Lean.Elab.Command.instAddErrorMessageContextCommandElabM, - Lean.Elab.Command.instInhabitedCommandElabM, - Lean.Elab.Command.instMonadCommandElabM, - Lean.Elab.Command.instMonadEnvCommandElabM, - Lean.Elab.Command.instMonadExceptOfExceptionCommandElabM, - Lean.Elab.Command.instMonadLiftTIOCommandElabM, - Lean.Elab.Command.instMonadRefCommandElabM, - Lean.Elab.MonadMacroAdapter.toMonadQuotation, - Lean.Elab.Term.instAddErrorMessageContextTermElabM, - Lean.Elab.Term.instMonadMacroAdapterTermElabM, - Lean.Elab.Term.instMonadTermElabM, - Lean.Expr.casesOn, - Lean.Expr.ctorIdx, - Lean.Expr.instBEq, - Lean.Expr.instHashable, - Lean.Expr.rec, - Lean.FVarId.casesOn, - Lean.FVarId.name, - Lean.InductiveVal.ctors, - Lean.InductiveVal.isRec, - Lean.InductiveVal.numIndices, - Lean.InductiveVal.numParams, - Lean.Level.instBEq, - Lean.Level.instToString, - Lean.LocalContext.mk, - Lean.Meta.Cache.mk, - Lean.Meta.Context.mk, - Lean.Meta.Diagnostics.mk, - Lean.Meta.State.mk, - Lean.Meta.instBEqDefEqCacheKey, - Lean.Meta.instBEqExprConfigCacheKey, - Lean.Meta.instBEqInfoCacheKey, - Lean.Meta.instBEqSynthInstanceCacheKey, - Lean.Meta.instHashableDefEqCacheKey, - Lean.Meta.instHashableExprConfigCacheKey, - Lean.Meta.instHashableInfoCacheKey, - Lean.Meta.instHashableSynthInstanceCacheKey, - Lean.Meta.instInhabitedConfigWithKey, - Lean.Meta.instMonadEnvMetaM, - Lean.Meta.instMonadMCtxMetaM, - Lean.Meta.instMonadMetaM, - Lean.MetavarContext.mk, - Lean.MonadError.mk, - Lean.MonadQuotation.toMonadRef, - Lean.Name.instBEq, - Lean.ParserDescr.binary, - Lean.ParserDescr.cat, - Lean.ParserDescr.const, - Lean.ParserDescr.node, - Lean.ParserDescr.symbol, - Lean.PersistentArray.mk, - Lean.PersistentArrayNode.node, - Lean.PersistentHashMap.Node.entries, - Lean.PersistentHashMap.mk, - Lean.instAddErrorMessageContextOfAddMessageContextOfMonad, - Lean.instBEqBinderInfo, - Lean.instBEqFVarId, - Lean.instBEqLevelMVarId, - Lean.instBEqLiteral, - Lean.instBEqMVarId, - Lean.instEmptyCollectionFVarIdMap, - Lean.instEmptyCollectionFVarIdSet, - Lean.instHashableFVarId, - Lean.instHashableLevelMVarId, - Lean.instHashableMVarId, - Lean.instHashableName, - Lean.instMonadEnvOfMonadLift, - Lean.instMonadExceptOfExceptionCoreM, - Lean.instMonadMCtxOfMonadLift, - List.casesOn, - List.instBEq, - List.toArray, - Monad.toBind, - Nat.hasNotBit, - Nat.land, - Nat.ne_of_beq_eq_false, - Nat.shiftRight, - OfNat.ofNat, - Option.casesOn, - Prod.fst, - Prod.snd, - ReaderT.instApplicativeOfMonad, - ReaderT.instMonadExceptOf, - ReaderT.instMonadLift, - StateRefT', - StateRefT'.instMonad, - StateRefT'.instMonadExceptOf, - StateRefT'.instMonadLift, - Std.HashMap.instEmptyCollection, - String.instInhabited, - USize.toNat, - eq_of_heq, - instBEqOfDecidableEq, - instDecidableEqBool, - instDecidableEqChar, - instDecidableEqNat, - instDecidableEqString, - instInhabitedBool, - instInhabitedList, - instInhabitedProd, - instMonadEIO, - instMonadLiftT, - instMonadLiftTOfMonadLift, - instOfNatNat, - instToStringList, - instToStringNat, - instToStringString, - ite, - noConfusion_of_Nat - ] - }, + plumbing{names: ["Applicative.toPure", "Array.casesOn", "Array.mkEmpty", "Bool.casesOn", "Char.ofNat", "EIO", "EmptyCollection.emptyCollection", "Eq", "Eq.casesOn", "Eq.ndrec", "Eq.refl", "Eq.symm", "False", "False.elim", "HEq", "HEq.refl", "IO.RealWorld", "Inhabited", "Inhabited.default", "Inhabited.mk", "Lean.BinderInfo.casesOn", "Lean.Compiler.LCNF.Alt.casesOn", "Lean.Compiler.LCNF.Arg.casesOn", "Lean.Compiler.LCNF.Cases.casesOn", "Lean.Compiler.LCNF.Code.casesOn", "Lean.Compiler.LCNF.CompilerM.State.mk", "Lean.Compiler.LCNF.CtorInfo.casesOn", "Lean.Compiler.LCNF.Decl.toSignature", "Lean.Compiler.LCNF.Decl.value", "Lean.Compiler.LCNF.DeclValue.casesOn", "Lean.Compiler.LCNF.FunDecl.casesOn", "Lean.Compiler.LCNF.LCtx.mk", "Lean.Compiler.LCNF.LetDecl.fvarId", "Lean.Compiler.LCNF.LetDecl.type", "Lean.Compiler.LCNF.LetDecl.value", "Lean.Compiler.LCNF.LetValue.casesOn", "Lean.Compiler.LCNF.LitValue.casesOn", "Lean.Compiler.LCNF.Param.borrow", "Lean.Compiler.LCNF.Param.fvarId", "Lean.Compiler.LCNF.Param.type", "Lean.Compiler.LCNF.Purity.ctorIdx", "Lean.Compiler.LCNF.Signature.levelParams", "Lean.Compiler.LCNF.Signature.name", "Lean.Compiler.LCNF.Signature.params", "Lean.Compiler.LCNF.Signature.safe", "Lean.Compiler.LCNF.Signature.type", "Lean.ConstantInfo.casesOn", "Lean.ConstantInfo.ctorIdx", "Lean.ConstantInfo.rec", "Lean.ConstantKind.casesOn", "Lean.ConstantVal.type", "Lean.ConstructorVal.induct", "Lean.ConstructorVal.numFields", "Lean.ConstructorVal.numParams", "Lean.ConstructorVal.toConstantVal", "Lean.Core.instAddMessageContextCoreM", "Lean.Core.instInhabitedCoreM", "Lean.Core.instMonadCoreM", "Lean.Core.instMonadEnvCoreM", "Lean.Core.instMonadLiftIOCoreM", "Lean.Core.instMonadNameGeneratorCoreM", "Lean.Core.instMonadRefCoreM", "Lean.DefinitionSafety.casesOn", "Lean.DefinitionVal.safety", "Lean.Elab.Command.instAddErrorMessageContextCommandElabM", "Lean.Elab.Command.instInhabitedCommandElabM", "Lean.Elab.Command.instMonadCommandElabM", "Lean.Elab.Command.instMonadEnvCommandElabM", "Lean.Elab.Command.instMonadExceptOfExceptionCommandElabM", "Lean.Elab.Command.instMonadLiftTIOCommandElabM", "Lean.Elab.Command.instMonadRefCommandElabM", "Lean.Elab.MonadMacroAdapter.toMonadQuotation", "Lean.Elab.Term.instAddErrorMessageContextTermElabM", "Lean.Elab.Term.instMonadMacroAdapterTermElabM", "Lean.Elab.Term.instMonadTermElabM", "Lean.Expr.casesOn", "Lean.Expr.ctorIdx", "Lean.Expr.instBEq", "Lean.Expr.instHashable", "Lean.Expr.rec", "Lean.FVarId.casesOn", "Lean.FVarId.name", "Lean.InductiveVal.ctors", "Lean.InductiveVal.isRec", "Lean.InductiveVal.numIndices", "Lean.InductiveVal.numParams", "Lean.Level.casesOn", "Lean.Level.instBEq", "Lean.Level.instToString", "Lean.Literal.casesOn", "Lean.LocalContext.mk", "Lean.Meta.Cache.mk", "Lean.Meta.Context.mk", "Lean.Meta.Diagnostics.mk", "Lean.Meta.State.mk", "Lean.Meta.instBEqDefEqCacheKey", "Lean.Meta.instBEqExprConfigCacheKey", "Lean.Meta.instBEqInfoCacheKey", "Lean.Meta.instBEqSynthInstanceCacheKey", "Lean.Meta.instHashableDefEqCacheKey", "Lean.Meta.instHashableExprConfigCacheKey", "Lean.Meta.instHashableInfoCacheKey", "Lean.Meta.instHashableSynthInstanceCacheKey", "Lean.Meta.instInhabitedConfigWithKey", "Lean.Meta.instMonadEnvMetaM", "Lean.Meta.instMonadMCtxMetaM", "Lean.Meta.instMonadMetaM", "Lean.MetavarContext.mk", "Lean.MonadError.mk", "Lean.MonadQuotation.toMonadRef", "Lean.Name.casesOn", "Lean.Name.instBEq", "Lean.ParserDescr.binary", "Lean.ParserDescr.cat", "Lean.ParserDescr.const", "Lean.ParserDescr.node", "Lean.ParserDescr.symbol", "Lean.PersistentArray.mk", "Lean.PersistentArrayNode.node", "Lean.PersistentHashMap.Node.entries", "Lean.PersistentHashMap.mk", "Lean.instAddErrorMessageContextOfAddMessageContextOfMonad", "Lean.instBEqBinderInfo", "Lean.instBEqFVarId", "Lean.instBEqLevelMVarId", "Lean.instBEqLiteral", "Lean.instBEqMVarId", "Lean.instEmptyCollectionFVarIdMap", "Lean.instEmptyCollectionFVarIdSet", "Lean.instHashableFVarId", "Lean.instHashableLevelMVarId", "Lean.instHashableMVarId", "Lean.instHashableName", "Lean.instMonadEnvOfMonadLift", "Lean.instMonadExceptOfExceptionCoreM", "Lean.instMonadMCtxOfMonadLift", "List.casesOn", "List.instBEq", "List.toArray", "Monad.toBind", "Nat.hasNotBit", "Nat.land", "Nat.ne_of_beq_eq_false", "Nat.shiftRight", "OfNat.ofNat", "Option.casesOn", "Prod.fst", "Prod.snd", "ReaderT.instApplicativeOfMonad", "ReaderT.instMonadExceptOf", "ReaderT.instMonadLift", "StateRefT'", "StateRefT'.instMonad", "StateRefT'.instMonadExceptOf", "StateRefT'.instMonadLift", "Std.HashMap.instEmptyCollection", "String.instInhabited", "USize.toNat", "eq_of_heq", "instBEqOfDecidableEq", "instDecidableEqBool", "instDecidableEqChar", "instDecidableEqNat", "instDecidableEqString", "instInhabitedBool", "instInhabitedList", "instInhabitedProd", "instMonadEIO", "instMonadLiftT", "instMonadLiftTOfMonadLift", "instOfNatNat", "instToStringList", "instToStringNat", "instToStringString", "ite", "noConfusion_of_Nat"]}, function{ name: LexLeanExtract.escape, type_parameters: [], @@ -15047,7 +14845,27 @@ name: LexLeanExtract.signatureCommand, atoms: [token{text: "lexlean_signature "}, ident{}, token{text: " : "}, type{}], elaborator: LexLeanExtract.elabSignature - } + }, + call{name: "Nat.sub", role: "bounded structural kernel inspection", signature: arrow{domain: const{name: "Nat"}, codomain: arrow{domain: const{name: "Nat"}, codomain: const{name: "Nat"}}}, source: {file: "src/lean/Init/Prelude.lean", sha256: "44f86ebbb9ab743a05c6ebe2c674aadbf2c822bee874f1b16d7e6c8d56318dc9"}}, + call{name: "Nat.log2", role: "bounded structural kernel inspection", signature: arrow{domain: const{name: "Nat"}, codomain: const{name: "Nat"}}, source: {file: "src/lean/Init/Data/Nat/Log2.lean", sha256: "afef53e5ebc17001038c5f4c9000e8e2856d3976bec23019266840f91743da6b"}}, + call{name: "String.utf8ByteSize", role: "bounded structural kernel inspection", signature: arrow{domain: const{name: "String"}, codomain: const{name: "Nat"}}, source: {file: "src/lean/Init/Prelude.lean", sha256: "44f86ebbb9ab743a05c6ebe2c674aadbf2c822bee874f1b16d7e6c8d56318dc9"}}, + call{name: "Lean.ConstantInfo.levelParams", role: "kernel declaration universe parameters", signature: arrow{domain: const{name: "Lean.ConstantInfo"}, codomain: app{function: const{name: "List"}, arguments: [const{name: "Lean.Name"}]}}, source: {file: "src/lean/Lean/Declaration.lean", sha256: "ca8ef13f4bb13725ebf7bc23c7de72ff1e0af75580a7007f5d3a7c69cc4004de"}}, + type{name: "Lean.LevelMVarId", parameters: [], constructors: [], opaque: true, source: {file: "src/lean/Lean/Level.lean", sha256: "c1691a3a7491bca520600d91d74160f5772b2a7ef072ea09ab2dbb19ce586401"}}, + function{name: "LexLeanExtract.inspectText", type_parameters: [], parameters: [{name: "text", type: const{name: "String", arguments: []}}, {name: "fuel", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [call{function: "Nat.add", arguments: [call{function: "String.utf8ByteSize", arguments: [var{name: "text"}], type_arguments: []}, nat{value: "1"}], type_arguments: []}, var{name: "fuel"}], type_arguments: []}, then_branch: call{function: "Nat.sub", arguments: [var{name: "fuel"}, call{function: "Nat.add", arguments: [call{function: "String.utf8ByteSize", arguments: [var{name: "text"}], type_arguments: []}, nat{value: "1"}], type_arguments: []}], type_arguments: []}, else_branch: nat{value: "0"}}, partial: false, public: false}, + function{name: "LexLeanExtract.inspectNumber", type_parameters: [], parameters: [{name: "number", type: const{name: "Nat", arguments: []}}, {name: "fuel", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [call{function: "Nat.add", arguments: [call{function: "Nat.log2", arguments: [var{name: "number"}], type_arguments: []}, nat{value: "1"}], type_arguments: []}, var{name: "fuel"}], type_arguments: []}, then_branch: call{function: "Nat.sub", arguments: [var{name: "fuel"}, call{function: "Nat.add", arguments: [call{function: "Nat.log2", arguments: [var{name: "number"}], type_arguments: []}, nat{value: "1"}], type_arguments: []}], type_arguments: []}, else_branch: nat{value: "0"}}, partial: false, public: false}, + function{name: "LexLeanExtract.inspectName", type_parameters: [], parameters: [{name: "name", type: const{name: "Lean.Name", arguments: []}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: if{condition: call{function: "Bool.and", arguments: [call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "fuel"}], type_arguments: []}, call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "depth"}], type_arguments: []}], type_arguments: []}, then_branch: let{binder: "left", type: const{name: "Nat", arguments: []}, value: call{function: "Nat.sub", arguments: [var{name: "fuel"}, nat{value: "1"}], type_arguments: []}, body: let{binder: "down", type: const{name: "Nat", arguments: []}, value: call{function: "Nat.sub", arguments: [var{name: "depth"}, nat{value: "1"}], type_arguments: []}, body: match{scrutinee: var{name: "name"}, branches: [{constructor: "Lean.Name.anonymous", binders: [], body: var{name: "left"}}, {constructor: "Lean.Name.str", binders: ["parent", "text"], body: call{function: "LexLeanExtract.inspectText", arguments: [var{name: "text"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "parent"}, var{name: "left"}, var{name: "down"}], type_arguments: []}], type_arguments: []}}, {constructor: "Lean.Name.num", binders: ["parent", "number"], body: call{function: "LexLeanExtract.inspectNumber", arguments: [var{name: "number"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "parent"}, var{name: "left"}, var{name: "down"}], type_arguments: []}], type_arguments: []}}]}}}, else_branch: nat{value: "0"}}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectLevel", type_parameters: [], parameters: [{name: "level", type: const{name: "Lean.Level", arguments: []}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: if{condition: call{function: "Bool.and", arguments: [call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "fuel"}], type_arguments: []}, call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "depth"}], type_arguments: []}], type_arguments: []}, then_branch: let{binder: "left", type: const{name: "Nat", arguments: []}, value: call{function: "Nat.sub", arguments: [var{name: "fuel"}, nat{value: "1"}], type_arguments: []}, body: let{binder: "down", type: const{name: "Nat", arguments: []}, value: call{function: "Nat.sub", arguments: [var{name: "depth"}, nat{value: "1"}], type_arguments: []}, body: match{scrutinee: var{name: "level"}, branches: [{constructor: "Lean.Level.zero", binders: [], body: var{name: "left"}}, {constructor: "Lean.Level.succ", binders: ["child"], body: call{function: "LexLeanExtract.inspectLevel", arguments: [var{name: "child"}, var{name: "left"}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Level.max", binders: ["a", "b"], body: call{function: "LexLeanExtract.inspectLevel", arguments: [var{name: "b"}, call{function: "LexLeanExtract.inspectLevel", arguments: [var{name: "a"}, var{name: "left"}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Level.imax", binders: ["a", "b"], body: call{function: "LexLeanExtract.inspectLevel", arguments: [var{name: "b"}, call{function: "LexLeanExtract.inspectLevel", arguments: [var{name: "a"}, var{name: "left"}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Level.param", binders: ["name"], body: call{function: "LexLeanExtract.inspectName", arguments: [var{name: "name"}, var{name: "left"}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Level.mvar", binders: ["id"], body: nat{value: "0"}}]}}}, else_branch: nat{value: "0"}}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectNames", type_parameters: [], parameters: [{name: "items", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "fuel"}], type_arguments: []}, then_branch: match{scrutinee: var{name: "items"}, branches: [{constructor: "List.nil", binders: [], body: var{name: "fuel"}}, {constructor: "List.cons", binders: ["head", "tail"], body: call{function: "LexLeanExtract.inspectNames", arguments: [var{name: "tail"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "head"}, var{name: "fuel"}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}}]}, else_branch: nat{value: "0"}}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectLevels", type_parameters: [], parameters: [{name: "items", type: const{name: "List", arguments: [const{name: "Lean.Level", arguments: []}]}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "fuel"}], type_arguments: []}, then_branch: match{scrutinee: var{name: "items"}, branches: [{constructor: "List.nil", binders: [], body: var{name: "fuel"}}, {constructor: "List.cons", binders: ["head", "tail"], body: call{function: "LexLeanExtract.inspectLevels", arguments: [var{name: "tail"}, call{function: "LexLeanExtract.inspectLevel", arguments: [var{name: "head"}, var{name: "fuel"}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}}]}, else_branch: nat{value: "0"}}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectLiteral", type_parameters: [], parameters: [{name: "literal", type: const{name: "Lean.Literal", arguments: []}}, {name: "fuel", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: match{scrutinee: var{name: "literal"}, branches: [{constructor: "Lean.Literal.natVal", binders: ["number"], body: call{function: "LexLeanExtract.inspectNumber", arguments: [var{name: "number"}, var{name: "fuel"}], type_arguments: []}}, {constructor: "Lean.Literal.strVal", binders: ["text"], body: call{function: "LexLeanExtract.inspectText", arguments: [var{name: "text"}, var{name: "fuel"}], type_arguments: []}}]}, partial: false, public: false}, + function{name: "LexLeanExtract.inspectExpr", type_parameters: [], parameters: [{name: "expr", type: const{name: "Lean.Expr", arguments: []}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}], result: const{name: "Nat", arguments: []}, body: if{condition: call{function: "Bool.and", arguments: [call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "fuel"}], type_arguments: []}, call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "depth"}], type_arguments: []}], type_arguments: []}, then_branch: let{binder: "left", type: const{name: "Nat", arguments: []}, value: call{function: "Nat.sub", arguments: [var{name: "fuel"}, nat{value: "1"}], type_arguments: []}, body: let{binder: "down", type: const{name: "Nat", arguments: []}, value: call{function: "Nat.sub", arguments: [var{name: "depth"}, nat{value: "1"}], type_arguments: []}, body: match{scrutinee: var{name: "expr"}, branches: [{constructor: "Lean.Expr.bvar", binders: ["index"], body: call{function: "LexLeanExtract.inspectNumber", arguments: [var{name: "index"}, var{name: "left"}], type_arguments: []}}, {constructor: "Lean.Expr.fvar", binders: ["id"], body: nat{value: "0"}}, {constructor: "Lean.Expr.mvar", binders: ["id"], body: nat{value: "0"}}, {constructor: "Lean.Expr.sort", binders: ["level"], body: call{function: "LexLeanExtract.inspectLevel", arguments: [var{name: "level"}, var{name: "left"}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Expr.const", binders: ["name", "levels"], body: call{function: "LexLeanExtract.inspectLevels", arguments: [var{name: "levels"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "name"}, var{name: "left"}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Expr.app", binders: ["fn", "arg"], body: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "arg"}, call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "fn"}, var{name: "left"}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Expr.lam", binders: ["name", "type", "body", "info"], body: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "body"}, call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "type"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "name"}, var{name: "left"}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Expr.forallE", binders: ["name", "type", "body", "info"], body: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "body"}, call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "type"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "name"}, var{name: "left"}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Expr.letE", binders: ["name", "type", "value", "body", "nondep"], body: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "body"}, call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "value"}, call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "type"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "name"}, var{name: "left"}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Expr.lit", binders: ["literal"], body: call{function: "LexLeanExtract.inspectLiteral", arguments: [var{name: "literal"}, var{name: "left"}], type_arguments: []}}, {constructor: "Lean.Expr.mdata", binders: ["metadata", "body"], body: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "body"}, var{name: "left"}, var{name: "down"}], type_arguments: []}}, {constructor: "Lean.Expr.proj", binders: ["name", "index", "body"], body: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "body"}, call{function: "LexLeanExtract.inspectNumber", arguments: [var{name: "index"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "name"}, var{name: "left"}, var{name: "down"}], type_arguments: []}], type_arguments: []}, var{name: "down"}], type_arguments: []}}]}}}, else_branch: nat{value: "0"}}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectNameJson", type_parameters: [], parameters: [{name: "name", type: const{name: "Lean.Name", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "name"}, branches: [{constructor: "Lean.Name.anonymous", binders: [], body: string{value: "null"}}, {constructor: "Lean.Name.str", binders: ["parent", "text"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "str"}, call{function: "LexLeanExtract.arr", arguments: [list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "parent"}], type_arguments: []}, call{function: "LexLeanExtract.str", arguments: [var{name: "text"}], type_arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Name.num", binders: ["parent", "number"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "num"}, call{function: "LexLeanExtract.arr", arguments: [list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "parent"}], type_arguments: []}, call{function: "ToString.toString", arguments: [var{name: "number"}], type_arguments: [const{name: "Nat", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}]}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectLevelJson", type_parameters: [], parameters: [{name: "level", type: const{name: "Lean.Level", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "level"}, branches: [{constructor: "Lean.Level.zero", binders: [], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "zero"}, string{value: "null"}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Level.succ", binders: ["child"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "succ"}, call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "child"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Level.max", binders: ["a", "b"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "max"}, call{function: "LexLeanExtract.arr", arguments: [list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "a"}], type_arguments: []}, call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "b"}], type_arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Level.imax", binders: ["a", "b"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "imax"}, call{function: "LexLeanExtract.arr", arguments: [list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "a"}], type_arguments: []}, call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "b"}], type_arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Level.param", binders: ["name"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "param"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Level.mvar", binders: ["id"], body: string{value: "null"}}]}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectBinderJson", type_parameters: [], parameters: [{name: "info", type: const{name: "Lean.BinderInfo", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "info"}, branches: [{constructor: "Lean.BinderInfo.default", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "default"}], type_arguments: []}}, {constructor: "Lean.BinderInfo.implicit", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "implicit"}], type_arguments: []}}, {constructor: "Lean.BinderInfo.strictImplicit", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "strictImplicit"}], type_arguments: []}}, {constructor: "Lean.BinderInfo.instImplicit", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "instImplicit"}], type_arguments: []}}]}, partial: false, public: false}, + function{name: "LexLeanExtract.inspectLiteralJson", type_parameters: [], parameters: [{name: "literal", type: const{name: "Lean.Literal", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "literal"}, branches: [{constructor: "Lean.Literal.natVal", binders: ["number"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "natVal"}, call{function: "ToString.toString", arguments: [var{name: "number"}], type_arguments: [const{name: "Nat", arguments: []}]}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Literal.strVal", binders: ["text"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "strVal"}, call{function: "LexLeanExtract.str", arguments: [var{name: "text"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}]}, partial: false, public: false}, + function{name: "LexLeanExtract.inspectExprJson", type_parameters: [], parameters: [{name: "expr", type: const{name: "Lean.Expr", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "expr"}, branches: [{constructor: "Lean.Expr.bvar", binders: ["index"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "bvar"}, call{function: "ToString.toString", arguments: [var{name: "index"}], type_arguments: [const{name: "Nat", arguments: []}]}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.fvar", binders: ["id"], body: string{value: "null"}}, {constructor: "Lean.Expr.mvar", binders: ["id"], body: string{value: "null"}}, {constructor: "Lean.Expr.sort", binders: ["level"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "sort"}, call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "level"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.const", binders: ["name", "levels"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "const"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "levels"}, call{function: "LexLeanExtract.arr", arguments: [call{function: "List.map", arguments: [lambda{parameters: [{name: "level", type: const{name: "Lean.Level", arguments: []}}], body: call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "level"}], type_arguments: []}}, var{name: "levels"}], type_arguments: [const{name: "Lean.Level", arguments: []}, const{name: "String", arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.app", binders: ["fn", "arg"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "app"}, call{function: "LexLeanExtract.arr", arguments: [list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "fn"}], type_arguments: []}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "arg"}], type_arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.lam", binders: ["name", "type", "body", "info"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "lam"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "body"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "bi"}, call{function: "LexLeanExtract.inspectBinderJson", arguments: [var{name: "info"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.forallE", binders: ["name", "type", "body", "info"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "forallE"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "body"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "bi"}, call{function: "LexLeanExtract.inspectBinderJson", arguments: [var{name: "info"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.letE", binders: ["name", "type", "value", "body", "nondep"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "letE"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "value"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "value"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "body"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "nondep"}, call{function: "LexLeanExtract.bool", arguments: [var{name: "nondep"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.lit", binders: ["literal"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "lit"}, call{function: "LexLeanExtract.inspectLiteralJson", arguments: [var{name: "literal"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.mdata", binders: ["metadata", "body"], body: call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}}, {constructor: "Lean.Expr.proj", binders: ["name", "index", "body"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "proj"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "typeName"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "idx"}, call{function: "ToString.toString", arguments: [var{name: "index"}], type_arguments: [const{name: "Nat", arguments: []}]}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "struct"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}]}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectRows", type_parameters: [], parameters: [{name: "names", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}, {name: "rows", type: const{name: "List", arguments: [const{name: "String", arguments: []}]}}], result: const{name: "Lean.Core.CoreM", arguments: [const{name: "String", arguments: []}]}, body: match{scrutinee: var{name: "names"}, branches: [{constructor: "List.nil", binders: [], body: call{function: "Pure.pure", arguments: [call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "spec"}, call{function: "LexLeanExtract.str", arguments: [string{value: "lexlean/kernel-inspection/1"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "lean"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "version"}, call{function: "LexLeanExtract.str", arguments: [call{function: "Lean.versionString", arguments: [], type_arguments: []}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "githash"}, call{function: "LexLeanExtract.str", arguments: [call{function: "Lean.githash", arguments: [], type_arguments: []}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "declarations"}, call{function: "LexLeanExtract.arr", arguments: [var{name: "rows"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}]}}, {constructor: "List.cons", binders: ["head", "tail"], body: call{function: "Bind.bind", arguments: [call{function: "Lean.getConstInfo", arguments: [var{name: "head"}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}]}, lambda{parameters: [{name: "info", type: const{name: "Lean.ConstantInfo", arguments: []}}], body: let{binder: "params", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}, value: call{function: "Lean.ConstantInfo.levelParams", arguments: [var{name: "info"}], type_arguments: []}, body: let{binder: "type", type: const{name: "Lean.Expr", arguments: []}, value: call{function: "Lean.ConstantInfo.type", arguments: [var{name: "info"}], type_arguments: []}, body: let{binder: "remaining", type: const{name: "Nat", arguments: []}, value: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "type"}, call{function: "LexLeanExtract.inspectNames", arguments: [var{name: "params"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "head"}, var{name: "fuel"}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "remaining"}], type_arguments: []}, then_branch: call{function: "LexLeanExtract.inspectRows", arguments: [var{name: "tail"}, var{name: "remaining"}, var{name: "depth"}, call{function: "List.append", arguments: [var{name: "rows"}, list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "head"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "parameters"}, call{function: "LexLeanExtract.arr", arguments: [call{function: "List.map", arguments: [lambda{parameters: [{name: "param", type: const{name: "Lean.Name", arguments: []}}], body: call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "param"}], type_arguments: []}}, var{name: "params"}], type_arguments: [const{name: "Lean.Name", arguments: []}, const{name: "String", arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}]}], type_arguments: [const{name: "String", arguments: []}]}], type_arguments: []}, else_branch: call{function: "Lean.throwError", arguments: [call{function: "Lean.stringToMessageData", arguments: [string{value: "lexlean-inspection-refused: traversal budget exhausted or unresolved kernel term"}], type_arguments: []}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}]}}}}}}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "Lean.ConstantInfo", arguments: []}, const{name: "String", arguments: []}]}}]}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectMain", type_parameters: [], parameters: [{name: "names", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}}, {name: "nodes", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}], result: const{name: "Lean.Elab.Command.CommandElabM", arguments: [const{name: "Unit", arguments: []}]}, body: call{function: "Lean.Elab.Command.liftCoreM", arguments: [call{function: "Bind.bind", arguments: [call{function: "LexLeanExtract.inspectRows", arguments: [var{name: "names"}, call{function: "Nat.add", arguments: [var{name: "nodes"}, nat{value: "1"}], type_arguments: []}, var{name: "depth"}, list{element: const{name: "String", arguments: []}, elements: []}], type_arguments: []}, lambda{parameters: [{name: "text", type: const{name: "String", arguments: []}}], body: call{function: "MonadLiftT.monadLift", arguments: [call{function: "IO.println", arguments: [var{name: "text"}], type_arguments: [const{name: "String", arguments: []}]}], type_arguments: [const{name: "IO", arguments: []}, const{name: "Lean.Core.CoreM", arguments: []}, const{name: "Unit", arguments: []}]}}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}, const{name: "Unit", arguments: []}]}], type_arguments: [const{name: "Unit", arguments: []}]}, partial: false, public: false} ], imports: [] } diff --git a/model/ids.toml b/model/ids.toml index abca384879..eceb6c334c 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -1354,6 +1354,12 @@ level = "build" suite = "verification" statement = "A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused." +[[id]] +id = "VR-28" +level = "build" +suite = "verification" +statement = "Kernel type inspection runs an owned bounded adapter against the pinned local Lean environment, preserves structural names, universe levels and binder visibility, rejects unresolved terms and exhausted traversal budgets, and returns inspection data without a verification attestation or proof-acceptance claim." + [[id]] id = "CL-01" level = "build" diff --git a/spec/src/Chapter22.lex.tex b/spec/src/Chapter22.lex.tex index 9b376fbb2a..8e0363fa4d 100644 --- a/spec/src/Chapter22.lex.tex +++ b/spec/src/Chapter22.lex.tex @@ -1081,6 +1081,74 @@ name: i0081, parameters: [], result: DocRows::Item, + body: constructor{ + arguments: [3, 1, "22.13 Kernel type inspection"], + constructor: DocRows::Item.heading, + type_arguments: [] + }, + executable: true +} + +definition{ + name: i0082, + parameters: [], + result: DocRows::Item, + body: constructor{ + arguments: [ + (cons "`lexlean inspect` and the sibling `api::inspection` API inspect declarations in the pinned local Lean environment. Inspection is data retrieval, not verification: it runs no proof acceptance shortcut and publishes no verification attestation (`VR-28`). The caller supplies explicit import modules and declaration names; the compiler admits at most 64 declarations, a positive traversal budget no larger than 65536 nodes, a depth bound no larger than 128, and a report bound no larger than 8388608 bytes. Invalid requests fail before running the adapter." (nil String)) + ], + constructor: DocRows::Item.para, + type_arguments: [] + }, + executable: true +} + +definition{ + name: i0083, + parameters: [], + result: DocRows::Item, + body: constructor{ + arguments: [ + (cons "The compiler renders its embedded LexLean tooling adapter through the typed tooling backend and checks the pinned toolchain and registered authority signatures before use. The adapter obtains each declaration's actual kernel type and universe parameters from the loaded environment. It preserves structural names, universes, binder visibility, lambdas, dependent functions, lets, literals and projections; metadata annotations may be omitted because they do not change the kernel type. It rejects free variables, expression metavariables and universe metavariables. A shared traversal budget covers repeated occurrences, names and universes before invoking serialization, so expanding a shared expression cannot bypass the bounds. Budget exhaustion refuses the inspection; it never substitutes a truncated type." (nil String)) + ], + constructor: DocRows::Item.para, + type_arguments: [] + }, + executable: true +} + +definition{ + name: i0084, + parameters: [], + result: DocRows::Item, + body: constructor{ + arguments: [ + (cons "The result binds the admitted import and declaration request, compiler identity and actual tool identities to the bounded process record and inspected data. Only a normal successful owned process with the exact output schema produces an inspection result. A malformed, noisy, timed-out or interrupted adapter fails without accepted inspection output. The caller remains responsible for owning and pinning the imported library build; inspection data alone establishes neither that ownership nor a theorem's proof acceptance." (nil String)) + ], + constructor: DocRows::Item.para, + type_arguments: [] + }, + executable: true +} + +definition{ + name: i0085, + parameters: [], + result: DocRows::Item, + body: constructor{ + arguments: [ + (cons "Each declaration also carries a native-core view when its names and expressions are representable by the native-core schema. That view preserves universe parameters, binder visibility, natural literals and scalar-valued string literals and uses only backward arena references. When a kernel projection has no reported elaborator projection label, or a structural name is outside the native-core name schema, the view explicitly reports why it is unrepresentable; the complete structural kernel type remains available. Neither form is a proof candidate or acceptance receipt." (nil String)) + ], + constructor: DocRows::Item.para, + type_arguments: [] + }, + executable: true +} + +definition{ + name: i0086, + parameters: [], + result: DocRows::Item, body: constructor{ arguments: [(cons "---" (nil String))], constructor: DocRows::Item.para, diff --git a/spec/src/IdsVR.lex.tex b/spec/src/IdsVR.lex.tex index a70da32f7a..243697583a 100644 --- a/spec/src/IdsVR.lex.tex +++ b/spec/src/IdsVR.lex.tex @@ -187,5 +187,12 @@ body: (record Rows::IdRow {id := "VR-23", level := "build", suite := "verification", statement := "A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused.", sections := "§9.4, §22.11"}), executable: true } +definition{ + name: vr28, + parameters: [], + result: Rows::IdRow, + body: (record Rows::IdRow {id := "VR-28", level := "build", suite := "verification", statement := "Kernel type inspection runs an owned bounded adapter against the pinned local Lean environment, preserves structural names, universe levels and binder visibility, rejects unresolved terms and exhausted traversal budgets, and returns inspection data without a verification attestation or proof-acceptance claim.", sections := "§22.13"}), + executable: true +} \end{semanticmodule} \end{lexlean} From 0463fa74122f0c04d2f22284bb80c2dc577670be Mon Sep 17 00:00:00 2001 From: Alexander Flom Date: Thu, 12 Nov 2026 05:26:13 +0000 Subject: [PATCH 2/6] Use copied inspection limits without redundant cloning --- crates/lexlean/src/api/inspection.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/lexlean/src/api/inspection.rs b/crates/lexlean/src/api/inspection.rs index 9fce096b9c..d3469e2810 100644 --- a/crates/lexlean/src/api/inspection.rs +++ b/crates/lexlean/src/api/inspection.rs @@ -101,7 +101,7 @@ pub fn inspect(engine: &Engine, request: &InspectionRequest) -> Result, ))); } let project = engine.project(); - let mut limits = project.config.limits.clone(); + let mut limits = project.config.limits; limits.max_child_output_bytes = limits.max_child_output_bytes.min(8388608); let toolchain = crate::verify::toolchain::preflight(&limits).map_err(LexLeanError::from_diagnostic)?; From 9ab10de692c11515171af931d62c29fb4e8055b4 Mon Sep 17 00:00:00 2001 From: Alexander Flom Date: Thu, 12 Nov 2026 05:45:36 +0000 Subject: [PATCH 3/6] Refresh project locks for bounded inspection identity --- examples/collections/lexlean.lock | 2 +- examples/fold-laws/lexlean.lock | 2 +- examples/helpdesk/lexlean.lock | 2 +- examples/higher-order/lexlean.lock | 2 +- examples/language-1.2/lexlean.lock | 2 +- examples/models/lexlean.lock | 2 +- examples/performance-corpus/lexlean.lock | 2 +- examples/production-coverage/lexlean.lock | 2 +- examples/production/lexlean.lock | 2 +- examples/reasoning/lexlean.lock | 2 +- examples/recursion/lexlean.lock | 2 +- examples/recursive-data/lexlean.lock | 2 +- kappa/lexlean.lock | 2 +- spec/lexlean.lock | 2 +- std-models/lexlean.lock | 2 +- std-reasoning/lexlean.lock | 2 +- stdlib/lexlean.lock | 2 +- tests/negative/application-arity/project/lexlean.lock | 2 +- tests/negative/application-non-function/project/lexlean.lock | 2 +- tests/negative/binder-bool-literal-name/project/lexlean.lock | 2 +- tests/negative/binder-capture/project/lexlean.lock | 2 +- .../binder-pattern-constructor-name/project/lexlean.lock | 2 +- tests/negative/cases-bool-branch-binder/project/lexlean.lock | 2 +- tests/negative/cases-bool-branch-repeated/project/lexlean.lock | 2 +- tests/negative/cases-bool-induction/project/lexlean.lock | 2 +- tests/negative/cases-bool-missing-branch/project/lexlean.lock | 2 +- tests/negative/certificate-b-rejected/project/lexlean.lock | 2 +- tests/negative/certificate-e-rejected/project/lexlean.lock | 2 +- .../negative/certificate-generation-limit/project/lexlean.lock | 2 +- .../certificate-heartbeat-rejected/project/lexlean.lock | 2 +- tests/negative/certificate-rejected/project/lexlean.lock | 2 +- .../certificate-resource-exhausted/project/lexlean.lock | 2 +- tests/negative/certificate-size-limit/project/lexlean.lock | 2 +- tests/negative/certificates-total-limit/project/lexlean.lock | 2 +- tests/negative/collection-duplicate-key/project/lexlean.lock | 2 +- .../negative/collection-fold-type-mismatch/project/lexlean.lock | 2 +- tests/negative/collection-literal-limit/project/lexlean.lock | 2 +- tests/negative/collection-noncanonical-key/project/lexlean.lock | 2 +- tests/negative/collection-nonliteral-key/project/lexlean.lock | 2 +- tests/negative/collection-out-of-range-key/project/lexlean.lock | 2 +- .../collection-unbounded-iteration/project/lexlean.lock | 2 +- tests/negative/collection-unordered-key/project/lexlean.lock | 2 +- tests/negative/cross-version-glossary/project/lexlean.lock | 2 +- tests/negative/declaration-lean-name/project/lexlean.lock | 2 +- tests/negative/eligibility-report-limit/project/lexlean.lock | 2 +- .../eligibility-reports-total-limit/project/lexlean.lock | 2 +- tests/negative/escaping-closure-in-data/project/lexlean.lock | 2 +- tests/negative/escaping-closure-parameter/project/lexlean.lock | 2 +- tests/negative/escaping-closure-structure/project/lexlean.lock | 2 +- tests/negative/escaping-closure/project/lexlean.lock | 2 +- tests/negative/executable-calls-formal/project/lexlean.lock | 2 +- tests/negative/extraction-authority-drift/project/lexlean.lock | 2 +- tests/negative/extraction-rejected/project/lexlean.lock | 2 +- .../extraction-uncompiled-external/project/lexlean.lock | 2 +- tests/negative/gnaf-certificate-malformed/project/lexlean.lock | 2 +- tests/negative/gnaf-request-malformed/project/lexlean.lock | 2 +- tests/negative/graph-duplicate-edge/project/lexlean.lock | 2 +- tests/negative/graph-invalid-reference/project/lexlean.lock | 2 +- tests/negative/lambda-capture-extra/project/lexlean.lock | 2 +- tests/negative/lambda-capture-missing/project/lexlean.lock | 2 +- tests/negative/lambda-type-mismatch/project/lexlean.lock | 2 +- .../lock-schema-language-mismatch-1.1/project/lexlean.lock | 2 +- tests/negative/lowering-depth-limit/project/lexlean.lock | 2 +- tests/negative/lowering-size-limit/project/lexlean.lock | 2 +- tests/negative/member-generated-name/project/lexlean.lock | 2 +- .../negative/model-artifact-decode-budget/project/lexlean.lock | 2 +- .../model-artifact-digest-mismatch/project/lexlean.lock | 2 +- tests/negative/model-artifact-invalid-utf8/project/lexlean.lock | 2 +- .../model-artifact-length-mismatch/project/lexlean.lock | 2 +- tests/negative/model-artifact-missing/project/lexlean.lock | 2 +- tests/negative/model-artifact-over-limit/project/lexlean.lock | 2 +- .../negative/model-artifact-rank-overflow/project/lexlean.lock | 2 +- .../negative/model-artifact-role-violation/project/lexlean.lock | 2 +- .../model-artifact-schema-violation/project/lexlean.lock | 2 +- .../negative/model-artifact-shape-mismatch/project/lexlean.lock | 2 +- tests/negative/model-artifact-symlink/project/lexlean.lock | 2 +- tests/negative/model-artifact-unconfigured/project/lexlean.lock | 2 +- .../negative/model-check-without-validator/project/lexlean.lock | 2 +- .../model-composition-forged-junction/project/lexlean.lock | 2 +- .../model-composition-missing-junction/project/lexlean.lock | 2 +- .../model-composition-type-mismatch/project/lexlean.lock | 2 +- .../model-contract-realization-mismatch/project/lexlean.lock | 2 +- tests/negative/model-encoder-width-forged/project/lexlean.lock | 2 +- tests/negative/model-false-evidence/project/lexlean.lock | 2 +- tests/negative/model-float-descriptor/project/lexlean.lock | 2 +- tests/negative/model-foreign-evidence/project/lexlean.lock | 2 +- tests/negative/model-forged-evidence/project/lexlean.lock | 2 +- tests/negative/model-missing-entry/project/lexlean.lock | 2 +- tests/negative/model-opaque-member/project/lexlean.lock | 2 +- tests/negative/model-predicate-signature/project/lexlean.lock | 2 +- tests/negative/model-realization-bypass/project/lexlean.lock | 2 +- tests/negative/model-unregistered-claim/project/lexlean.lock | 2 +- tests/negative/model-unvalidated-boundary/project/lexlean.lock | 2 +- .../model-unvalidated-postcondition/project/lexlean.lock | 2 +- tests/negative/model-vacuous-claim/project/lexlean.lock | 2 +- .../model-validator-unsound-statement/project/lexlean.lock | 2 +- tests/negative/module-name-dotted-first/project/lexlean.lock | 2 +- tests/negative/module-name-dotted-last/project/lexlean.lock | 2 +- tests/negative/module-name-lean-namespace/project/lexlean.lock | 2 +- .../module-prefix-target-production/project/lexlean.lock | 2 +- tests/negative/mutual-group-noncontiguous/project/lexlean.lock | 2 +- tests/negative/mutual-label-shared/project/lexlean.lock | 2 +- tests/negative/nat-bitwise-complement/project/lexlean.lock | 2 +- tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock | 2 +- tests/negative/nat-bitwise-production-root/project/lexlean.lock | 2 +- tests/negative/nat-bitwise-shift-amount/project/lexlean.lock | 2 +- tests/negative/polymorphic-ambiguity/project/lexlean.lock | 2 +- tests/negative/polymorphic-recursion/project/lexlean.lock | 2 +- tests/negative/preservation-drift/project/lexlean.lock | 2 +- tests/negative/production-effect-mismatch/project/lexlean.lock | 2 +- .../negative/production-expectation-stale/project/lexlean.lock | 2 +- .../production-formal-only-dependency/project/lexlean.lock | 2 +- .../negative/production-hidden-dependency/project/lexlean.lock | 2 +- .../production-higher-order-escape/project/lexlean.lock | 2 +- tests/negative/production-literal-width/project/lexlean.lock | 2 +- .../production-named-type-boundary/project/lexlean.lock | 2 +- .../production-package-name-keyword/project/lexlean.lock | 2 +- .../production-phantom-type-parameter/project/lexlean.lock | 2 +- tests/negative/production-polymorphic-root/project/lexlean.lock | 2 +- .../negative/production-request-malformed/project/lexlean.lock | 2 +- .../production-root-not-executable/project/lexlean.lock | 2 +- tests/negative/production-root-unknown/project/lexlean.lock | 2 +- .../production-runtime-incompatible-type/project/lexlean.lock | 2 +- .../production-target-unregistered/project/lexlean.lock | 2 +- tests/negative/production-unbounded-type/project/lexlean.lock | 2 +- .../negative/production-universe-boundary/project/lexlean.lock | 2 +- tests/negative/production-unknown-target/project/lexlean.lock | 2 +- .../negative/reasoning-accept-bypass-alias/project/lexlean.lock | 2 +- .../reasoning-accept-bypass-invariant/project/lexlean.lock | 2 +- .../reasoning-accept-bypass-observation/project/lexlean.lock | 2 +- tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock | 2 +- .../reasoning-answer-correct-inexact/project/lexlean.lock | 2 +- .../reasoning-answer-correct-unsorted/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- tests/negative/reasoning-answer-type/project/lexlean.lock | 2 +- tests/negative/reasoning-binder-reserved/project/lexlean.lock | 2 +- tests/negative/reasoning-budget-not-nat/project/lexlean.lock | 2 +- tests/negative/reasoning-claims-duplicate/project/lexlean.lock | 2 +- tests/negative/reasoning-claims-unsorted/project/lexlean.lock | 2 +- .../reasoning-conclude-bypass-invariant/project/lexlean.lock | 2 +- .../reasoning-conclude-bypass-observation/project/lexlean.lock | 2 +- .../reasoning-deduplicate-unordered-state/project/lexlean.lock | 2 +- tests/negative/reasoning-duplicate-rule/project/lexlean.lock | 2 +- .../reasoning-elaboration-over-limit/project/lexlean.lock | 2 +- .../reasoning-extract-bypass-alias/project/lexlean.lock | 2 +- .../reasoning-extract-bypass-branch/project/lexlean.lock | 2 +- .../reasoning-extract-bypass-invariant/project/lexlean.lock | 2 +- .../reasoning-extract-bypass-reasoner/project/lexlean.lock | 2 +- .../negative/reasoning-extract-bypass-ref/project/lexlean.lock | 2 +- .../reasoning-false-answer-correct/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- tests/negative/reasoning-forged-trace/project/lexlean.lock | 2 +- tests/negative/reasoning-formal-rule/project/lexlean.lock | 2 +- .../reasoning-forward-without-fuel/project/lexlean.lock | 2 +- tests/negative/reasoning-frontier-not-nat/project/lexlean.lock | 2 +- .../negative/reasoning-fuel-bound-inexact/project/lexlean.lock | 2 +- tests/negative/reasoning-fuel-not-nat/project/lexlean.lock | 2 +- tests/negative/reasoning-generate-claims/project/lexlean.lock | 2 +- .../reasoning-generate-subject-mismatch/project/lexlean.lock | 2 +- .../negative/reasoning-generate-with-logic/project/lexlean.lock | 2 +- .../negative/reasoning-generate-with-rules/project/lexlean.lock | 2 +- .../reasoning-generate-without-budget/project/lexlean.lock | 2 +- tests/negative/reasoning-generator-type/project/lexlean.lock | 2 +- .../reasoning-inconsistent-verifier/project/lexlean.lock | 2 +- tests/negative/reasoning-initial-inexact/project/lexlean.lock | 2 +- .../reasoning-initial-without-invariant/project/lexlean.lock | 2 +- tests/negative/reasoning-insufficient-fuel/project/lexlean.lock | 2 +- tests/negative/reasoning-interface-rebound/project/lexlean.lock | 2 +- .../reasoning-invalid-rule-application/project/lexlean.lock | 2 +- .../negative/reasoning-invariant-signature/project/lexlean.lock | 2 +- .../reasoning-invariant-unpreserved/project/lexlean.lock | 2 +- .../reasoning-logic-type-parameters/project/lexlean.lock | 2 +- tests/negative/reasoning-no-rules/project/lexlean.lock | 2 +- .../negative/reasoning-nonterminating-rule/project/lexlean.lock | 2 +- .../reasoning-observation-initial-inexact/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- tests/negative/reasoning-observation-type/project/lexlean.lock | 2 +- .../reasoning-observation-unsorted/project/lexlean.lock | 2 +- tests/negative/reasoning-opaque-member/project/lexlean.lock | 2 +- .../reasoning-progress-without-ranking/project/lexlean.lock | 2 +- tests/negative/reasoning-ranking-signature/project/lexlean.lock | 2 +- .../reasoning-reasoner-rule-type-arguments/project/lexlean.lock | 2 +- .../reasoning-relation-not-definition/project/lexlean.lock | 2 +- .../negative/reasoning-relation-signature/project/lexlean.lock | 2 +- .../reasoning-reserved-declaration-name/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock | 2 +- .../negative/reasoning-rule-bypass-branch/project/lexlean.lock | 2 +- .../reasoning-rule-bypass-generator/project/lexlean.lock | 2 +- tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock | 2 +- .../negative/reasoning-rule-bypass-iterate/project/lexlean.lock | 2 +- .../negative/reasoning-rule-bypass-lambda/project/lexlean.lock | 2 +- .../negative/reasoning-rule-bypass-observe/project/lexlean.lock | 2 +- tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock | 2 +- tests/negative/reasoning-rule-bypass/project/lexlean.lock | 2 +- .../reasoning-rule-candidates-type/project/lexlean.lock | 2 +- .../reasoning-rule-conclusion-type/project/lexlean.lock | 2 +- .../negative/reasoning-rule-foreign-logic/project/lexlean.lock | 2 +- tests/negative/reasoning-rule-guard-type/project/lexlean.lock | 2 +- .../reasoning-rule-progress-inexact/project/lexlean.lock | 2 +- .../reasoning-rule-soundness-inexact/project/lexlean.lock | 2 +- .../negative/reasoning-rule-type-arguments/project/lexlean.lock | 2 +- .../negative/reasoning-rule-unknown-logic/project/lexlean.lock | 2 +- .../negative/reasoning-rules-without-logic/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../reasoning-search-step-bypass-invariant/project/lexlean.lock | 2 +- .../reasoning-search-without-frontier/project/lexlean.lock | 2 +- .../reasoning-specification-signature/project/lexlean.lock | 2 +- .../reasoning-terminates-without-initial/project/lexlean.lock | 2 +- .../reasoning-terminates-without-progress/project/lexlean.lock | 2 +- .../reasoning-terminates-without-ranking/project/lexlean.lock | 2 +- .../negative/reasoning-terminating-search/project/lexlean.lock | 2 +- tests/negative/reasoning-unknown-rule/project/lexlean.lock | 2 +- tests/negative/reasoning-unknown-verifier/project/lexlean.lock | 2 +- .../negative/reasoning-unregistered-claim/project/lexlean.lock | 2 +- .../reasoning-unregistered-strategy/project/lexlean.lock | 2 +- tests/negative/reasoning-unverified-answer/project/lexlean.lock | 2 +- .../reasoning-verifier-formal-check/project/lexlean.lock | 2 +- tests/negative/reasoning-verifier-inexact/project/lexlean.lock | 2 +- .../negative/reasoning-verifier-signature/project/lexlean.lock | 2 +- .../reasoning-verifier-subject-mismatch/project/lexlean.lock | 2 +- .../reasoning-verifier-type-mismatch/project/lexlean.lock | 2 +- tests/negative/reasoning-zero-frontier/project/lexlean.lock | 2 +- tests/negative/recursion-cyclic-measure/project/lexlean.lock | 2 +- .../recursion-evidence-omits-match/project/lexlean.lock | 2 +- tests/negative/recursion-false-evidence/project/lexlean.lock | 2 +- tests/negative/recursion-forged-evidence/project/lexlean.lock | 2 +- .../negative/recursion-member-under-lambda/project/lexlean.lock | 2 +- tests/negative/recursion-missing-case/project/lexlean.lock | 2 +- tests/negative/recursion-missing-evidence/project/lexlean.lock | 2 +- tests/negative/recursion-mixed-families/project/lexlean.lock | 2 +- .../recursion-mutual-cyclic-measure/project/lexlean.lock | 2 +- .../negative/recursion-mutual-disconnected/project/lexlean.lock | 2 +- .../recursion-mutual-member-without-call/project/lexlean.lock | 2 +- tests/negative/recursion-mutual-mixed/project/lexlean.lock | 2 +- tests/negative/recursion-nondecreasing/project/lexlean.lock | 2 +- tests/negative/recursion-under-lambda/project/lexlean.lock | 2 +- .../recursion-well-founded-reference/project/lexlean.lock | 2 +- tests/negative/recursion-wrong-argument/project/lexlean.lock | 2 +- .../recursive-constructor-mismatch/project/lexlean.lock | 2 +- .../recursive-match-foreign-constructor/project/lexlean.lock | 2 +- .../negative/recursive-mutual-uninhabited/project/lexlean.lock | 2 +- tests/negative/recursive-structure/project/lexlean.lock | 2 +- tests/negative/recursive-type-arguments/project/lexlean.lock | 2 +- tests/negative/recursive-type-forward/project/lexlean.lock | 2 +- tests/negative/recursive-type-nonuniform/project/lexlean.lock | 2 +- tests/negative/recursive-type-positivity/project/lexlean.lock | 2 +- tests/negative/recursive-type-uninhabited/project/lexlean.lock | 2 +- .../negative/semantic-module-v1-under-1.2/project/lexlean.lock | 2 +- .../negative/term-cases-definition-absent/project/lexlean.lock | 2 +- .../term-cases-definition-repeated/project/lexlean.lock | 2 +- .../term-cases-definitions-unsorted/project/lexlean.lock | 2 +- .../negative/term-cases-empty-definitions/project/lexlean.lock | 2 +- tests/negative/term-cases-reserved-name/project/lexlean.lock | 2 +- .../term-cases-scrutinee-not-inductive/project/lexlean.lock | 2 +- tests/negative/text-window-zero-capacity/project/lexlean.lock | 2 +- .../tooling-module-in-user-project/project/lexlean.lock | 2 +- tests/negative/type-argument-universe/project/lexlean.lock | 2 +- tests/negative/type-parameter-capture/project/lexlean.lock | 2 +- tests/preservation-certificates/lists/lexlean.lock | 2 +- tests/rust-backend/loop-ends/lexlean.lock | 2 +- 263 files changed, 263 insertions(+), 263 deletions(-) diff --git a/examples/collections/lexlean.lock b/examples/collections/lexlean.lock index f1219a33d7..c9888a876e 100644 --- a/examples/collections/lexlean.lock +++ b/examples/collections/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "902cce2e0ccf037e4769589b7b9af2aac26250c50181b306fecec9028e2a63ff" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/fold-laws/lexlean.lock b/examples/fold-laws/lexlean.lock index 10e4b82a24..0a6685470f 100644 --- a/examples/fold-laws/lexlean.lock +++ b/examples/fold-laws/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "5d2c8a2881629ee86d82b9e70a1be6fff2518c562d5ca6f45dea96d41edbc005" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/helpdesk/lexlean.lock b/examples/helpdesk/lexlean.lock index 5596693cb1..b77ecd16c2 100644 --- a/examples/helpdesk/lexlean.lock +++ b/examples/helpdesk/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "30e9380b31a91b74c3c02f5882a9070290c6a5c41e1dd3bf56d9c617396343e7" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/higher-order/lexlean.lock b/examples/higher-order/lexlean.lock index 993d543034..e80ff73c9f 100644 --- a/examples/higher-order/lexlean.lock +++ b/examples/higher-order/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "2854e1de7560697fdce6b84ea09e897fa3936fd6c0fbca153d62201ce8ed4d61" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/language-1.2/lexlean.lock b/examples/language-1.2/lexlean.lock index f43f1fd594..9b7cd86258 100644 --- a/examples/language-1.2/lexlean.lock +++ b/examples/language-1.2/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "83557b5053642ede054857828d95f4c17d6d6e14fab13f017a7feb166bd89c0f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/models/lexlean.lock b/examples/models/lexlean.lock index a8949b8708..d3109f637d 100644 --- a/examples/models/lexlean.lock +++ b/examples/models/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b79e1070aab27c02ec4396ee66aa4bad7b90f9bca923932529eb9eb26264761a" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/performance-corpus/lexlean.lock b/examples/performance-corpus/lexlean.lock index c4dcf8ea01..ef83871662 100644 --- a/examples/performance-corpus/lexlean.lock +++ b/examples/performance-corpus/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "f94da2d4131decea3a9f53124824e0d81f88c75fefbe62fa443d3203e84a9b39" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production-coverage/lexlean.lock b/examples/production-coverage/lexlean.lock index dffcbfccfa..7578bd3e3b 100644 --- a/examples/production-coverage/lexlean.lock +++ b/examples/production-coverage/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "8c8f206d89e67b327167aecf57185e532cb99e5ebda5aa538d04fce39951f22e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production/lexlean.lock b/examples/production/lexlean.lock index de144ce319..87bcc6c524 100644 --- a/examples/production/lexlean.lock +++ b/examples/production/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "f2cbda9bf591701cef68498eabd2f96cf838e61cca5c7193c83c78d7fce1560f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/reasoning/lexlean.lock b/examples/reasoning/lexlean.lock index 4b86dcabc3..ef0e121dda 100644 --- a/examples/reasoning/lexlean.lock +++ b/examples/reasoning/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "254deddb728df2532affa57ca92fefae0324c34d616c713273d63bd4cccbb2bf" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursion/lexlean.lock b/examples/recursion/lexlean.lock index ca3e881a8d..f243f3b524 100644 --- a/examples/recursion/lexlean.lock +++ b/examples/recursion/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "92ff94a2dc1a550b8d47ebdd8b8e9b9d89371435ef550e661022fe74cf51594d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursive-data/lexlean.lock b/examples/recursive-data/lexlean.lock index f2e8601122..75f3332cd4 100644 --- a/examples/recursive-data/lexlean.lock +++ b/examples/recursive-data/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "1642b5144f8137f7c2f980a40564f8bcd579515bbb15411ada96c9e513ba0499" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/kappa/lexlean.lock b/kappa/lexlean.lock index fc52c627c4..21ba7f734c 100644 --- a/kappa/lexlean.lock +++ b/kappa/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b5a7664cf56fe322a652d657d726eaea2f825b6130260db1c8e7d6ed8961d4da" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/spec/lexlean.lock b/spec/lexlean.lock index e02a68d7b0..c2d47e5b34 100644 --- a/spec/lexlean.lock +++ b/spec/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "29ba9126f5a06fcb4eb426cf07b2fb0462a0adad864ffc2187a644076d840201" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/std-models/lexlean.lock b/std-models/lexlean.lock index a1db38713e..0ca7e8284b 100644 --- a/std-models/lexlean.lock +++ b/std-models/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b23bdec83131b3e4f0a45197f98f9b7144a208ff5a2692289262e5096a455001" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/std-reasoning/lexlean.lock b/std-reasoning/lexlean.lock index 624a8094f6..7bc5542de6 100644 --- a/std-reasoning/lexlean.lock +++ b/std-reasoning/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "76ead6f0bc516e1d9669cf1333e7b75d9e7c19c7f3f8aeb000ca36ad15d432bc" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/stdlib/lexlean.lock b/stdlib/lexlean.lock index cb2be38e18..2036b2b4e5 100644 --- a/stdlib/lexlean.lock +++ b/stdlib/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "4ec208494fa7641b35f82cda91b06851ca826caaefa4d0385110c8d8b2b65878" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-arity/project/lexlean.lock b/tests/negative/application-arity/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/application-arity/project/lexlean.lock +++ b/tests/negative/application-arity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-non-function/project/lexlean.lock b/tests/negative/application-non-function/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/application-non-function/project/lexlean.lock +++ b/tests/negative/application-non-function/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-bool-literal-name/project/lexlean.lock b/tests/negative/binder-bool-literal-name/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/binder-bool-literal-name/project/lexlean.lock +++ b/tests/negative/binder-bool-literal-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-capture/project/lexlean.lock b/tests/negative/binder-capture/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/binder-capture/project/lexlean.lock +++ b/tests/negative/binder-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock index fc2c912332..a96fdf1df6 100644 --- a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock +++ b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "81ee2a9ef8c129bd8d1d2c5a002526675b1f2cbabb784a33bbb447892bd48c9f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-branch-binder/project/lexlean.lock b/tests/negative/cases-bool-branch-binder/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/cases-bool-branch-binder/project/lexlean.lock +++ b/tests/negative/cases-bool-branch-binder/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-branch-repeated/project/lexlean.lock b/tests/negative/cases-bool-branch-repeated/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/cases-bool-branch-repeated/project/lexlean.lock +++ b/tests/negative/cases-bool-branch-repeated/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-induction/project/lexlean.lock b/tests/negative/cases-bool-induction/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/cases-bool-induction/project/lexlean.lock +++ b/tests/negative/cases-bool-induction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-missing-branch/project/lexlean.lock b/tests/negative/cases-bool-missing-branch/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/cases-bool-missing-branch/project/lexlean.lock +++ b/tests/negative/cases-bool-missing-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-b-rejected/project/lexlean.lock b/tests/negative/certificate-b-rejected/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/certificate-b-rejected/project/lexlean.lock +++ b/tests/negative/certificate-b-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-e-rejected/project/lexlean.lock b/tests/negative/certificate-e-rejected/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/certificate-e-rejected/project/lexlean.lock +++ b/tests/negative/certificate-e-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-generation-limit/project/lexlean.lock b/tests/negative/certificate-generation-limit/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/certificate-generation-limit/project/lexlean.lock +++ b/tests/negative/certificate-generation-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock +++ b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-rejected/project/lexlean.lock b/tests/negative/certificate-rejected/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/certificate-rejected/project/lexlean.lock +++ b/tests/negative/certificate-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-resource-exhausted/project/lexlean.lock b/tests/negative/certificate-resource-exhausted/project/lexlean.lock index a5d6b6a737..d4021fa8c9 100644 --- a/tests/negative/certificate-resource-exhausted/project/lexlean.lock +++ b/tests/negative/certificate-resource-exhausted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "533c8a12cea89372dcb6f4707ed7e213695aac97bb956164fc7240cf3ef64a1c" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-size-limit/project/lexlean.lock b/tests/negative/certificate-size-limit/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/certificate-size-limit/project/lexlean.lock +++ b/tests/negative/certificate-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificates-total-limit/project/lexlean.lock b/tests/negative/certificates-total-limit/project/lexlean.lock index 3a0dcbac3a..a7e1661416 100644 --- a/tests/negative/certificates-total-limit/project/lexlean.lock +++ b/tests/negative/certificates-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "19396dab32e876e6744d5feb41043ceae6961ae8b3e677fc770b3b09fcdbc8ad" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-duplicate-key/project/lexlean.lock b/tests/negative/collection-duplicate-key/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/collection-duplicate-key/project/lexlean.lock +++ b/tests/negative/collection-duplicate-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock +++ b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-literal-limit/project/lexlean.lock b/tests/negative/collection-literal-limit/project/lexlean.lock index 49d6819082..1fd4f648c2 100644 --- a/tests/negative/collection-literal-limit/project/lexlean.lock +++ b/tests/negative/collection-literal-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "86eb9da7c6c50be25511dfe1cbf99f5e0ac82b411c2ed9b5b4e6c94924af2253" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-noncanonical-key/project/lexlean.lock b/tests/negative/collection-noncanonical-key/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/collection-noncanonical-key/project/lexlean.lock +++ b/tests/negative/collection-noncanonical-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-nonliteral-key/project/lexlean.lock b/tests/negative/collection-nonliteral-key/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/collection-nonliteral-key/project/lexlean.lock +++ b/tests/negative/collection-nonliteral-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-out-of-range-key/project/lexlean.lock b/tests/negative/collection-out-of-range-key/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/collection-out-of-range-key/project/lexlean.lock +++ b/tests/negative/collection-out-of-range-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unbounded-iteration/project/lexlean.lock b/tests/negative/collection-unbounded-iteration/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/collection-unbounded-iteration/project/lexlean.lock +++ b/tests/negative/collection-unbounded-iteration/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unordered-key/project/lexlean.lock b/tests/negative/collection-unordered-key/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/collection-unordered-key/project/lexlean.lock +++ b/tests/negative/collection-unordered-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cross-version-glossary/project/lexlean.lock b/tests/negative/cross-version-glossary/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/cross-version-glossary/project/lexlean.lock +++ b/tests/negative/cross-version-glossary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/declaration-lean-name/project/lexlean.lock b/tests/negative/declaration-lean-name/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/declaration-lean-name/project/lexlean.lock +++ b/tests/negative/declaration-lean-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-report-limit/project/lexlean.lock b/tests/negative/eligibility-report-limit/project/lexlean.lock index ec9553f84a..3e479956fa 100644 --- a/tests/negative/eligibility-report-limit/project/lexlean.lock +++ b/tests/negative/eligibility-report-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock index ec9553f84a..3e479956fa 100644 --- a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock +++ b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-in-data/project/lexlean.lock b/tests/negative/escaping-closure-in-data/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/escaping-closure-in-data/project/lexlean.lock +++ b/tests/negative/escaping-closure-in-data/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-parameter/project/lexlean.lock b/tests/negative/escaping-closure-parameter/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/escaping-closure-parameter/project/lexlean.lock +++ b/tests/negative/escaping-closure-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-structure/project/lexlean.lock b/tests/negative/escaping-closure-structure/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/escaping-closure-structure/project/lexlean.lock +++ b/tests/negative/escaping-closure-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure/project/lexlean.lock b/tests/negative/escaping-closure/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/escaping-closure/project/lexlean.lock +++ b/tests/negative/escaping-closure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/executable-calls-formal/project/lexlean.lock b/tests/negative/executable-calls-formal/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/executable-calls-formal/project/lexlean.lock +++ b/tests/negative/executable-calls-formal/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-authority-drift/project/lexlean.lock b/tests/negative/extraction-authority-drift/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/extraction-authority-drift/project/lexlean.lock +++ b/tests/negative/extraction-authority-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-rejected/project/lexlean.lock b/tests/negative/extraction-rejected/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/extraction-rejected/project/lexlean.lock +++ b/tests/negative/extraction-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-uncompiled-external/project/lexlean.lock b/tests/negative/extraction-uncompiled-external/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/extraction-uncompiled-external/project/lexlean.lock +++ b/tests/negative/extraction-uncompiled-external/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/gnaf-certificate-malformed/project/lexlean.lock b/tests/negative/gnaf-certificate-malformed/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/gnaf-certificate-malformed/project/lexlean.lock +++ b/tests/negative/gnaf-certificate-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/gnaf-request-malformed/project/lexlean.lock b/tests/negative/gnaf-request-malformed/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/gnaf-request-malformed/project/lexlean.lock +++ b/tests/negative/gnaf-request-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-duplicate-edge/project/lexlean.lock b/tests/negative/graph-duplicate-edge/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/graph-duplicate-edge/project/lexlean.lock +++ b/tests/negative/graph-duplicate-edge/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-invalid-reference/project/lexlean.lock b/tests/negative/graph-invalid-reference/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/graph-invalid-reference/project/lexlean.lock +++ b/tests/negative/graph-invalid-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-extra/project/lexlean.lock b/tests/negative/lambda-capture-extra/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/lambda-capture-extra/project/lexlean.lock +++ b/tests/negative/lambda-capture-extra/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-missing/project/lexlean.lock b/tests/negative/lambda-capture-missing/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/lambda-capture-missing/project/lexlean.lock +++ b/tests/negative/lambda-capture-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-type-mismatch/project/lexlean.lock b/tests/negative/lambda-type-mismatch/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/lambda-type-mismatch/project/lexlean.lock +++ b/tests/negative/lambda-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lock-schema-language-mismatch-1.1/project/lexlean.lock b/tests/negative/lock-schema-language-mismatch-1.1/project/lexlean.lock index 8137b21b08..1f9b645e0c 100644 --- a/tests/negative/lock-schema-language-mismatch-1.1/project/lexlean.lock +++ b/tests/negative/lock-schema-language-mismatch-1.1/project/lexlean.lock @@ -1,4 +1,4 @@ -spec = "lexlean/lock/2" +spec = "lexlean/lock/1" language = "1.1" compiler_semantics = "11732e9ac8c66a5b8f0453280381e489939da3f669dbbd9be0f942b9a1be80ec" project_config_sha256 = "2e7890849a54aa8b06f18c26e5ba80b31db9d2e367bedc23410d7bcb0a16af03" diff --git a/tests/negative/lowering-depth-limit/project/lexlean.lock b/tests/negative/lowering-depth-limit/project/lexlean.lock index 61c2424041..cb822624f9 100644 --- a/tests/negative/lowering-depth-limit/project/lexlean.lock +++ b/tests/negative/lowering-depth-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "0ef90b79ef115752acdab64e47ead3e354657b99e6ddcb26ec636f024e7ef5ee" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lowering-size-limit/project/lexlean.lock b/tests/negative/lowering-size-limit/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/lowering-size-limit/project/lexlean.lock +++ b/tests/negative/lowering-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/member-generated-name/project/lexlean.lock b/tests/negative/member-generated-name/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/member-generated-name/project/lexlean.lock +++ b/tests/negative/member-generated-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-decode-budget/project/lexlean.lock b/tests/negative/model-artifact-decode-budget/project/lexlean.lock index 39a14477bc..8d7f284d8d 100644 --- a/tests/negative/model-artifact-decode-budget/project/lexlean.lock +++ b/tests/negative/model-artifact-decode-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "97224c1005c098cfb00c28986caa7733eb43fd183f038947ba92d676edede581" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock index e01bbbee8b..d7a2c55b6d 100644 --- a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock index 95c5260fe6..f910fa5ccb 100644 --- a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock +++ b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "7407260b337f63f50bc003afdc8e09e578096041ae6365e5b1f39d0dc3d8e093" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock index e01bbbee8b..d7a2c55b6d 100644 --- a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-missing/project/lexlean.lock b/tests/negative/model-artifact-missing/project/lexlean.lock index e01bbbee8b..d7a2c55b6d 100644 --- a/tests/negative/model-artifact-missing/project/lexlean.lock +++ b/tests/negative/model-artifact-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-over-limit/project/lexlean.lock b/tests/negative/model-artifact-over-limit/project/lexlean.lock index ab579e56cd..06d2edd123 100644 --- a/tests/negative/model-artifact-over-limit/project/lexlean.lock +++ b/tests/negative/model-artifact-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6b2d40a11356013ad4366b900361329faecae628242794cbc0d2ba8a54ff7d4c" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock index 153dfeae40..c5e2d841d1 100644 --- a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock +++ b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "9f0dd9fc1743c1e5be95b546a6d77274f7fd5ffc95c0920b73cfe4e007b47fe0" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-role-violation/project/lexlean.lock b/tests/negative/model-artifact-role-violation/project/lexlean.lock index e01bbbee8b..d7a2c55b6d 100644 --- a/tests/negative/model-artifact-role-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-role-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-schema-violation/project/lexlean.lock b/tests/negative/model-artifact-schema-violation/project/lexlean.lock index e01bbbee8b..d7a2c55b6d 100644 --- a/tests/negative/model-artifact-schema-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-schema-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock index b9c24e70cf..cba5b7b8be 100644 --- a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-symlink/project/lexlean.lock b/tests/negative/model-artifact-symlink/project/lexlean.lock index e01bbbee8b..d7a2c55b6d 100644 --- a/tests/negative/model-artifact-symlink/project/lexlean.lock +++ b/tests/negative/model-artifact-symlink/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-unconfigured/project/lexlean.lock b/tests/negative/model-artifact-unconfigured/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-artifact-unconfigured/project/lexlean.lock +++ b/tests/negative/model-artifact-unconfigured/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-check-without-validator/project/lexlean.lock b/tests/negative/model-check-without-validator/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-check-without-validator/project/lexlean.lock +++ b/tests/negative/model-check-without-validator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-forged-junction/project/lexlean.lock b/tests/negative/model-composition-forged-junction/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-composition-forged-junction/project/lexlean.lock +++ b/tests/negative/model-composition-forged-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-missing-junction/project/lexlean.lock b/tests/negative/model-composition-missing-junction/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-composition-missing-junction/project/lexlean.lock +++ b/tests/negative/model-composition-missing-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-type-mismatch/project/lexlean.lock b/tests/negative/model-composition-type-mismatch/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-composition-type-mismatch/project/lexlean.lock +++ b/tests/negative/model-composition-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock +++ b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-encoder-width-forged/project/lexlean.lock b/tests/negative/model-encoder-width-forged/project/lexlean.lock index b9c24e70cf..cba5b7b8be 100644 --- a/tests/negative/model-encoder-width-forged/project/lexlean.lock +++ b/tests/negative/model-encoder-width-forged/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-false-evidence/project/lexlean.lock b/tests/negative/model-false-evidence/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-false-evidence/project/lexlean.lock +++ b/tests/negative/model-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-float-descriptor/project/lexlean.lock b/tests/negative/model-float-descriptor/project/lexlean.lock index e01bbbee8b..d7a2c55b6d 100644 --- a/tests/negative/model-float-descriptor/project/lexlean.lock +++ b/tests/negative/model-float-descriptor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-foreign-evidence/project/lexlean.lock b/tests/negative/model-foreign-evidence/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-foreign-evidence/project/lexlean.lock +++ b/tests/negative/model-foreign-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-forged-evidence/project/lexlean.lock b/tests/negative/model-forged-evidence/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-forged-evidence/project/lexlean.lock +++ b/tests/negative/model-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-missing-entry/project/lexlean.lock b/tests/negative/model-missing-entry/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-missing-entry/project/lexlean.lock +++ b/tests/negative/model-missing-entry/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-opaque-member/project/lexlean.lock b/tests/negative/model-opaque-member/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-opaque-member/project/lexlean.lock +++ b/tests/negative/model-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-predicate-signature/project/lexlean.lock b/tests/negative/model-predicate-signature/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-predicate-signature/project/lexlean.lock +++ b/tests/negative/model-predicate-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-realization-bypass/project/lexlean.lock b/tests/negative/model-realization-bypass/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-realization-bypass/project/lexlean.lock +++ b/tests/negative/model-realization-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unregistered-claim/project/lexlean.lock b/tests/negative/model-unregistered-claim/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-unregistered-claim/project/lexlean.lock +++ b/tests/negative/model-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-boundary/project/lexlean.lock b/tests/negative/model-unvalidated-boundary/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-unvalidated-boundary/project/lexlean.lock +++ b/tests/negative/model-unvalidated-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock +++ b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-vacuous-claim/project/lexlean.lock b/tests/negative/model-vacuous-claim/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-vacuous-claim/project/lexlean.lock +++ b/tests/negative/model-vacuous-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-validator-unsound-statement/project/lexlean.lock b/tests/negative/model-validator-unsound-statement/project/lexlean.lock index daa472f9cc..67cf31952d 100644 --- a/tests/negative/model-validator-unsound-statement/project/lexlean.lock +++ b/tests/negative/model-validator-unsound-statement/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-first/project/lexlean.lock b/tests/negative/module-name-dotted-first/project/lexlean.lock index 9e8c31ee44..54adea95bd 100644 --- a/tests/negative/module-name-dotted-first/project/lexlean.lock +++ b/tests/negative/module-name-dotted-first/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "95276aad5a2f8e56451e0155187ce36290918ff47f8b6a315a4f65c3bfef9e71" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-last/project/lexlean.lock b/tests/negative/module-name-dotted-last/project/lexlean.lock index 0f30956ef6..4c8055ab6b 100644 --- a/tests/negative/module-name-dotted-last/project/lexlean.lock +++ b/tests/negative/module-name-dotted-last/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "931ec0afb0a76b983ac4c428c862444a84cf5503f5dd3674b7f95f86e20d955e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-lean-namespace/project/lexlean.lock b/tests/negative/module-name-lean-namespace/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/module-name-lean-namespace/project/lexlean.lock +++ b/tests/negative/module-name-lean-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-target-production/project/lexlean.lock b/tests/negative/module-prefix-target-production/project/lexlean.lock index 0184b4e943..492305e57b 100644 --- a/tests/negative/module-prefix-target-production/project/lexlean.lock +++ b/tests/negative/module-prefix-target-production/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "d4ba5893c2a056d009d9df7131d82f1a6f3a560659e43ded292d44b5d050ee2b" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock +++ b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-label-shared/project/lexlean.lock b/tests/negative/mutual-label-shared/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/mutual-label-shared/project/lexlean.lock +++ b/tests/negative/mutual-label-shared/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-complement/project/lexlean.lock b/tests/negative/nat-bitwise-complement/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/nat-bitwise-complement/project/lexlean.lock +++ b/tests/negative/nat-bitwise-complement/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock b/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock +++ b/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-production-root/project/lexlean.lock b/tests/negative/nat-bitwise-production-root/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/nat-bitwise-production-root/project/lexlean.lock +++ b/tests/negative/nat-bitwise-production-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock b/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock +++ b/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-ambiguity/project/lexlean.lock b/tests/negative/polymorphic-ambiguity/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/polymorphic-ambiguity/project/lexlean.lock +++ b/tests/negative/polymorphic-ambiguity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-recursion/project/lexlean.lock b/tests/negative/polymorphic-recursion/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/polymorphic-recursion/project/lexlean.lock +++ b/tests/negative/polymorphic-recursion/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/preservation-drift/project/lexlean.lock b/tests/negative/preservation-drift/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/preservation-drift/project/lexlean.lock +++ b/tests/negative/preservation-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-effect-mismatch/project/lexlean.lock b/tests/negative/production-effect-mismatch/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-effect-mismatch/project/lexlean.lock +++ b/tests/negative/production-effect-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-expectation-stale/project/lexlean.lock b/tests/negative/production-expectation-stale/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/production-expectation-stale/project/lexlean.lock +++ b/tests/negative/production-expectation-stale/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-formal-only-dependency/project/lexlean.lock b/tests/negative/production-formal-only-dependency/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-formal-only-dependency/project/lexlean.lock +++ b/tests/negative/production-formal-only-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-hidden-dependency/project/lexlean.lock b/tests/negative/production-hidden-dependency/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-hidden-dependency/project/lexlean.lock +++ b/tests/negative/production-hidden-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-higher-order-escape/project/lexlean.lock b/tests/negative/production-higher-order-escape/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-higher-order-escape/project/lexlean.lock +++ b/tests/negative/production-higher-order-escape/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-literal-width/project/lexlean.lock b/tests/negative/production-literal-width/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-literal-width/project/lexlean.lock +++ b/tests/negative/production-literal-width/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-named-type-boundary/project/lexlean.lock b/tests/negative/production-named-type-boundary/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-named-type-boundary/project/lexlean.lock +++ b/tests/negative/production-named-type-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-package-name-keyword/project/lexlean.lock b/tests/negative/production-package-name-keyword/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/production-package-name-keyword/project/lexlean.lock +++ b/tests/negative/production-package-name-keyword/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-phantom-type-parameter/project/lexlean.lock b/tests/negative/production-phantom-type-parameter/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-phantom-type-parameter/project/lexlean.lock +++ b/tests/negative/production-phantom-type-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-polymorphic-root/project/lexlean.lock b/tests/negative/production-polymorphic-root/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-polymorphic-root/project/lexlean.lock +++ b/tests/negative/production-polymorphic-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-request-malformed/project/lexlean.lock b/tests/negative/production-request-malformed/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/production-request-malformed/project/lexlean.lock +++ b/tests/negative/production-request-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-root-not-executable/project/lexlean.lock b/tests/negative/production-root-not-executable/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-root-not-executable/project/lexlean.lock +++ b/tests/negative/production-root-not-executable/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-root-unknown/project/lexlean.lock b/tests/negative/production-root-unknown/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/production-root-unknown/project/lexlean.lock +++ b/tests/negative/production-root-unknown/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock +++ b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-target-unregistered/project/lexlean.lock b/tests/negative/production-target-unregistered/project/lexlean.lock index b8f20c0fc1..278518efad 100644 --- a/tests/negative/production-target-unregistered/project/lexlean.lock +++ b/tests/negative/production-target-unregistered/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unbounded-type/project/lexlean.lock b/tests/negative/production-unbounded-type/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-unbounded-type/project/lexlean.lock +++ b/tests/negative/production-unbounded-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-universe-boundary/project/lexlean.lock b/tests/negative/production-universe-boundary/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-universe-boundary/project/lexlean.lock +++ b/tests/negative/production-universe-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unknown-target/project/lexlean.lock b/tests/negative/production-unknown-target/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/production-unknown-target/project/lexlean.lock +++ b/tests/negative/production-unknown-target/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-type/project/lexlean.lock b/tests/negative/reasoning-answer-type/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-answer-type/project/lexlean.lock +++ b/tests/negative/reasoning-answer-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-binder-reserved/project/lexlean.lock b/tests/negative/reasoning-binder-reserved/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-binder-reserved/project/lexlean.lock +++ b/tests/negative/reasoning-binder-reserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock +++ b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock +++ b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock +++ b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock index 54a275e0d4..daf4485b22 100644 --- a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock +++ b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "32962ccccc0e0504497383fdd12cf9f1e761305e58c22fa64cc3776c5fad8c16" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forged-trace/project/lexlean.lock b/tests/negative/reasoning-forged-trace/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-forged-trace/project/lexlean.lock +++ b/tests/negative/reasoning-forged-trace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-formal-rule/project/lexlean.lock b/tests/negative/reasoning-formal-rule/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-formal-rule/project/lexlean.lock +++ b/tests/negative/reasoning-formal-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-claims/project/lexlean.lock b/tests/negative/reasoning-generate-claims/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-generate-claims/project/lexlean.lock +++ b/tests/negative/reasoning-generate-claims/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock +++ b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generator-type/project/lexlean.lock b/tests/negative/reasoning-generator-type/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-generator-type/project/lexlean.lock +++ b/tests/negative/reasoning-generator-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-initial-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-interface-rebound/project/lexlean.lock b/tests/negative/reasoning-interface-rebound/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-interface-rebound/project/lexlean.lock +++ b/tests/negative/reasoning-interface-rebound/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock +++ b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-invariant-signature/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock +++ b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-no-rules/project/lexlean.lock b/tests/negative/reasoning-no-rules/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-no-rules/project/lexlean.lock +++ b/tests/negative/reasoning-no-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock +++ b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-type/project/lexlean.lock b/tests/negative/reasoning-observation-type/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-observation-type/project/lexlean.lock +++ b/tests/negative/reasoning-observation-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-opaque-member/project/lexlean.lock b/tests/negative/reasoning-opaque-member/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-opaque-member/project/lexlean.lock +++ b/tests/negative/reasoning-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-ranking-signature/project/lexlean.lock b/tests/negative/reasoning-ranking-signature/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-ranking-signature/project/lexlean.lock +++ b/tests/negative/reasoning-ranking-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock +++ b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-signature/project/lexlean.lock b/tests/negative/reasoning-relation-signature/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-relation-signature/project/lexlean.lock +++ b/tests/negative/reasoning-relation-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass/project/lexlean.lock b/tests/negative/reasoning-rule-bypass/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-bypass/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-specification-signature/project/lexlean.lock b/tests/negative/reasoning-specification-signature/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-specification-signature/project/lexlean.lock +++ b/tests/negative/reasoning-specification-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminating-search/project/lexlean.lock b/tests/negative/reasoning-terminating-search/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-terminating-search/project/lexlean.lock +++ b/tests/negative/reasoning-terminating-search/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-rule/project/lexlean.lock b/tests/negative/reasoning-unknown-rule/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-unknown-rule/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unverified-answer/project/lexlean.lock b/tests/negative/reasoning-unverified-answer/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-unverified-answer/project/lexlean.lock +++ b/tests/negative/reasoning-unverified-answer/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-signature/project/lexlean.lock b/tests/negative/reasoning-verifier-signature/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-verifier-signature/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-zero-frontier/project/lexlean.lock b/tests/negative/reasoning-zero-frontier/project/lexlean.lock index 7377befae0..5e2b02a814 100644 --- a/tests/negative/reasoning-zero-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-zero-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-cyclic-measure/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock +++ b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-false-evidence/project/lexlean.lock b/tests/negative/recursion-false-evidence/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-false-evidence/project/lexlean.lock +++ b/tests/negative/recursion-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-forged-evidence/project/lexlean.lock b/tests/negative/recursion-forged-evidence/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-forged-evidence/project/lexlean.lock +++ b/tests/negative/recursion-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-member-under-lambda/project/lexlean.lock b/tests/negative/recursion-member-under-lambda/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-member-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-member-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-case/project/lexlean.lock b/tests/negative/recursion-missing-case/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-missing-case/project/lexlean.lock +++ b/tests/negative/recursion-missing-case/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-evidence/project/lexlean.lock b/tests/negative/recursion-missing-evidence/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-missing-evidence/project/lexlean.lock +++ b/tests/negative/recursion-missing-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mixed-families/project/lexlean.lock b/tests/negative/recursion-mixed-families/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-mixed-families/project/lexlean.lock +++ b/tests/negative/recursion-mixed-families/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock +++ b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock +++ b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-mixed/project/lexlean.lock b/tests/negative/recursion-mutual-mixed/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-mutual-mixed/project/lexlean.lock +++ b/tests/negative/recursion-mutual-mixed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-nondecreasing/project/lexlean.lock b/tests/negative/recursion-nondecreasing/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-nondecreasing/project/lexlean.lock +++ b/tests/negative/recursion-nondecreasing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-under-lambda/project/lexlean.lock b/tests/negative/recursion-under-lambda/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-well-founded-reference/project/lexlean.lock b/tests/negative/recursion-well-founded-reference/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-well-founded-reference/project/lexlean.lock +++ b/tests/negative/recursion-well-founded-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-wrong-argument/project/lexlean.lock b/tests/negative/recursion-wrong-argument/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursion-wrong-argument/project/lexlean.lock +++ b/tests/negative/recursion-wrong-argument/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock +++ b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock +++ b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-structure/project/lexlean.lock b/tests/negative/recursive-structure/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-structure/project/lexlean.lock +++ b/tests/negative/recursive-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-arguments/project/lexlean.lock b/tests/negative/recursive-type-arguments/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-type-arguments/project/lexlean.lock +++ b/tests/negative/recursive-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-forward/project/lexlean.lock b/tests/negative/recursive-type-forward/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-type-forward/project/lexlean.lock +++ b/tests/negative/recursive-type-forward/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-nonuniform/project/lexlean.lock b/tests/negative/recursive-type-nonuniform/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-type-nonuniform/project/lexlean.lock +++ b/tests/negative/recursive-type-nonuniform/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-positivity/project/lexlean.lock b/tests/negative/recursive-type-positivity/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-type-positivity/project/lexlean.lock +++ b/tests/negative/recursive-type-positivity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-uninhabited/project/lexlean.lock b/tests/negative/recursive-type-uninhabited/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/recursive-type-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-type-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock +++ b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definition-absent/project/lexlean.lock b/tests/negative/term-cases-definition-absent/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/term-cases-definition-absent/project/lexlean.lock +++ b/tests/negative/term-cases-definition-absent/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definition-repeated/project/lexlean.lock b/tests/negative/term-cases-definition-repeated/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/term-cases-definition-repeated/project/lexlean.lock +++ b/tests/negative/term-cases-definition-repeated/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock b/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock +++ b/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-empty-definitions/project/lexlean.lock b/tests/negative/term-cases-empty-definitions/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/term-cases-empty-definitions/project/lexlean.lock +++ b/tests/negative/term-cases-empty-definitions/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-reserved-name/project/lexlean.lock b/tests/negative/term-cases-reserved-name/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/term-cases-reserved-name/project/lexlean.lock +++ b/tests/negative/term-cases-reserved-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock b/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock +++ b/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/text-window-zero-capacity/project/lexlean.lock b/tests/negative/text-window-zero-capacity/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/text-window-zero-capacity/project/lexlean.lock +++ b/tests/negative/text-window-zero-capacity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/tooling-module-in-user-project/project/lexlean.lock b/tests/negative/tooling-module-in-user-project/project/lexlean.lock index e38a659298..1c15732a9d 100644 --- a/tests/negative/tooling-module-in-user-project/project/lexlean.lock +++ b/tests/negative/tooling-module-in-user-project/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "238e7aca6dbdb072aca261449c9bd60440763fbf9d421fdde4d29f286ff968b4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-argument-universe/project/lexlean.lock b/tests/negative/type-argument-universe/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/type-argument-universe/project/lexlean.lock +++ b/tests/negative/type-argument-universe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-parameter-capture/project/lexlean.lock b/tests/negative/type-parameter-capture/project/lexlean.lock index 10f5a11bc1..4bc29873a2 100644 --- a/tests/negative/type-parameter-capture/project/lexlean.lock +++ b/tests/negative/type-parameter-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/preservation-certificates/lists/lexlean.lock b/tests/preservation-certificates/lists/lexlean.lock index 6152638199..f01479b57d 100644 --- a/tests/preservation-certificates/lists/lexlean.lock +++ b/tests/preservation-certificates/lists/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "2dc372130a18e781ddded01cec4b998ca72fc64e03821c32d166d926f1747167" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/rust-backend/loop-ends/lexlean.lock b/tests/rust-backend/loop-ends/lexlean.lock index 56e42eb09b..a9ff2eb1a7 100644 --- a/tests/rust-backend/loop-ends/lexlean.lock +++ b/tests/rust-backend/loop-ends/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "601e9f4a1824bb6aacf7c3c2243d4b33aaa315abdebd5ceaf920d178e196019e" +compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" project_config_sha256 = "3e4158ef82c9e0076571d311f038e86f002adf3e8285a7292c835b07f5a45c65" lean_toolchain = "leanprover/lean4:v4.32.1" From eadeff7cfe5c8e127b26543da04bfc2352d89047 Mon Sep 17 00:00:00 2001 From: Alexander Flom Date: Thu, 12 Nov 2026 15:01:07 +0000 Subject: [PATCH 4/6] Partition large preservation certificates into replayable units --- VERIFICATION.md | 16 +++ crates/lexlean/src/production/preserve.rs | 162 +++++++++++++++++++--- crates/lexlean/src/verify/mod.rs | 30 ++-- 3 files changed, 182 insertions(+), 26 deletions(-) diff --git a/VERIFICATION.md b/VERIFICATION.md index e2c2cb99b4..6746277d4d 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -39,6 +39,22 @@ Outside `vv`: ## Falsifiability records +### large certificate child budgets can fail + +Rule30's combined autonomous controller failed certificate-B elaboration with +`LLS8002`: `child_timeout_ms` was 600000 and the observed duration was 600003 ms. +A retained-artifact diagnostic checked all 745 declarations successfully; their +declaration checks alone took 676.891 seconds. Partitioning the identical commands +into 15 groups let every group elaborate and replay within the unchanged +600-second limit (all observed completion times were below 259 seconds). + +The partition regression preserves every command, its order, and the original +certificate record. Parts live outside every original certificate's module +prefix: `leanchecker` selects descendants as well as the named module, so nested +parts would be replayed together again. The final module imports the checked +chain for the unchanged axiom audit. This diagnostic is not a project +attestation; full verification still checks and replays every staged part. + ### extraction literal transport can fail `cargo test -p repo-conformance --lib extraction_literal_paths_survive_normalization` diff --git a/crates/lexlean/src/production/preserve.rs b/crates/lexlean/src/production/preserve.rs index 68dacfc30c..968a191d97 100644 --- a/crates/lexlean/src/production/preserve.rs +++ b/crates/lexlean/src/production/preserve.rs @@ -1277,6 +1277,88 @@ fn runtime_files<'a>( .collect()) } +/// Keep the audited certificate's commands intact, but split large modules +/// across Lean children. Controllers otherwise spend their child budget on +/// hundreds of independent function proofs. Every part is elaborated and +/// replayed; the original module imports the chain for the unchanged axiom audit. +fn certificate_files(certificate: &Certificate) -> Result, Diagnostic> { + certificate_files_with_limit(certificate, 4 * 1024 * 1024) +} + +fn certificate_files_with_limit( + certificate: &Certificate, + limit: usize, +) -> Result, Diagnostic> { + let original = || StagedFile { + path: module_path(&certificate.module), + module: certificate.module.clone(), + text: certificate.text.clone(), + source: certificate.source.clone(), + }; + if certificate.data.is_none() || certificate.text.len() <= limit { + return Ok(vec![original()]); + } + // audit_certificate has compared this text with the core renderer. These + // boundaries are complete renderer commands, never lines inside JSON data. + let marker = "\nrun_cmd Lean.Elab.Command.liftCoreM (LexLeanCore.Runtime.decodeAndAdd #["; + let footer = format!("\nend {}\n", certificate.module); + let body = certificate + .text + .strip_suffix(&footer) + .ok_or_else(|| internal("a native certificate lacks its rendered namespace terminator"))?; + let first = body + .find(marker) + .ok_or_else(|| internal("a native certificate lacks its rendered core commands"))?; + let (header, commands) = body.split_at(first); + let decoder = header + .find("namespace LexLeanCore.Runtime") + .ok_or_else(|| internal("a native certificate lacks its rendered core decoder"))?; + let common = &header[..decoder]; + let starts: Vec = commands.match_indices(marker).map(|(at, _)| at).collect(); + let mut groups = Vec::new(); + let mut start = 0; + for (index, at) in starts.iter().copied().enumerate() { + let end = starts.get(index + 1).copied().unwrap_or(commands.len()); + if at > start && end - start > limit { + groups.push(&commands[start..at]); + start = at; + } + } + groups.push(&commands[start..]); + if groups.len() == 1 { + return Ok(vec![original()]); + } + let mut files = Vec::new(); + let mut previous = None; + for (index, group) in groups.into_iter().enumerate() { + // leanchecker selects descendants, too. Keep parts outside every + // original certificate's prefix, including certificate A's prefix + // which contains B and E. Otherwise a wrapper replays all parts again + // concurrently after the whole workspace has been compiled. + let owner = certificate + .module + .strip_prefix("LexLeanPreserve.") + .ok_or_else(|| internal("a partitioned certificate is outside LexLeanPreserve"))?; + let module = format!("LexLeanPreserve.Parts.{owner}_Part{index}"); + let text = match &previous { + None => format!("{header}{group}{footer}"), + Some(import) => format!("import {import}\n{common}{group}{footer}"), + }; + files.push(StagedFile { + path: module_path(&module), + module: module.clone(), + text, + source: None, + }); + previous = Some(module); + } + let mut final_file = original(); + let previous = previous.ok_or_else(|| internal("empty certificate command groups"))?; + final_file.text = format!("import {previous}\n"); + files.push(final_file); + Ok(files) +} + /// Stage the workspace of a project's certificates. /// /// # Errors @@ -1339,6 +1421,7 @@ pub fn workspace( }); } environment.extend(user.iter().map(|(module, _)| module.clone())); + let mut certificate_modules = Vec::new(); for certificate in certificates { audit_certificate(certificate, &environment).map_err(|reason| { internal(format!( @@ -1353,19 +1436,13 @@ pub fn workspace( ))); } environment.insert(certificate.module.clone()); - files.push(StagedFile { - path: module_path(&certificate.module), - module: certificate.module.clone(), - text: certificate.text.clone(), - source: certificate.source.clone(), - }); + let parts = certificate_files(certificate)?; + certificate_modules.extend(parts.iter().map(|file| file.module.clone())); + files.extend(parts); } Ok(Workspace { files, - certificates: certificates - .iter() - .map(|certificate| certificate.module.clone()) - .collect(), + certificates: certificate_modules, audit: StagedFile { path: module_path(AUDIT_MODULE), module: AUDIT_MODULE.to_owned(), @@ -1618,12 +1695,7 @@ pub fn stage(modules: &[String], certificates: &[Certificate]) -> Result = (0..5).map(|index| format!( + "\nrun_cmd Lean.Elab.Command.liftCoreM (LexLeanCore.Runtime.decodeAndAdd #[\"{index}\"] \"payload\")\n" + )).collect(); + let certificate = super::Certificate { + module: module.to_owned(), + text: format!("{header}{}{footer}", commands.concat()), + theorem: format!("{module}.root"), + denote: String::new(), + imports: vec!["Lean".to_owned()], + data: Some(crate::ir::core::CoreModule { + spec: "lexlean/core-module/2".to_owned(), + imports: Vec::new(), + nodes: Vec::new(), + proof_nodes: Vec::new(), + declarations: Vec::new(), + }), + source: Some("original certificate record".to_owned()), + }; + let files = super::certificate_files_with_limit(&certificate, commands[0].len() * 2) + .expect("complete command boundaries"); + assert_eq!(files.len(), 4); + assert!(files[0].text.starts_with(&header)); + let mut recovered = String::new(); + for (index, file) in files[..3].iter().enumerate() { + assert!(!file.module.starts_with(&format!("{module}."))); + assert!(!file.module.starts_with("LexLeanPreserve.Cidentity.R14.")); + assert!(file.module.starts_with("LexLeanPreserve.Parts.")); + if index > 0 { + assert!(file + .text + .starts_with(&format!("import {}\n", files[index - 1].module))); + assert!(!file.text.contains("namespace LexLeanCore.Runtime")); + } + let start = file.text.find("\nrun_cmd").expect("commands"); + recovered.push_str( + file.text[start..] + .strip_suffix(&footer) + .expect("closed namespace"), + ); + assert!(file.source.is_none()); + } + assert_eq!(recovered, commands.concat()); + assert_eq!(files[3].module, module); + assert_eq!(files[3].text, format!("import {}\n", files[2].module)); + assert_eq!(files[3].source, certificate.source); + let unchanged = super::certificate_files_with_limit(&certificate, usize::MAX).unwrap(); + assert_eq!(unchanged.len(), 1); + assert_eq!(unchanged[0].text, certificate.text); + let mut damaged = certificate; + damaged.text.truncate(damaged.text.len() - footer.len()); + assert!(super::certificate_files_with_limit(&damaged, 1).is_err()); + } + /// A user's name spelled like a forbidden keyword is an identifier when /// the generator quotes it, as it does, and the audit still refuses the /// keyword itself, in a command, an attribute, or a binder. diff --git a/crates/lexlean/src/verify/mod.rs b/crates/lexlean/src/verify/mod.rs index 1efe001374..f22e5e1ff0 100644 --- a/crates/lexlean/src/verify/mod.rs +++ b/crates/lexlean/src/verify/mod.rs @@ -2378,14 +2378,16 @@ pub fn run_part( .cloned() .collect(); let is_b = |module: &str| { - rendered_certificates - .iter() - .any(|certificate| certificate.module == module) + rendered_certificates.iter().any(|certificate| { + certificate.module == module + || module.starts_with(&format!("{}_Part", certificate.module)) + }) }; let is_e = |module: &str| { - composed_certificates - .iter() - .any(|certificate| certificate.module == module) + composed_certificates.iter().any(|certificate| { + certificate.module == module + || module.starts_with(&format!("{}_Part", certificate.module)) + }) }; // Where a rejection lies: the declaration of the certificate Lean's // first error is in, and the root it certifies. @@ -2395,18 +2397,26 @@ pub fn run_part( .unwrap_or_default(); let root = certified .iter() - .find(|root| module.starts_with(&root.certificate.module)) + .find(|root| { + module == root.certificate.module + || module.starts_with(&format!("{}.", root.certificate.module)) + || module.starts_with(&format!("{}_Part", root.certificate.module)) + }) .map(|root| format!(" of root `{}`", root.root)) .unwrap_or_default(); format!("{declaration}{root}") }; let reject = |module: &str, output: &str, exit_code: i32, text: &str| { - let place = place(module, output, text); + let owner = module + .strip_prefix("LexLeanPreserve.Parts.") + .map(|suffix| format!("LexLeanPreserve.{suffix}")); + let owner = owner.as_deref().unwrap_or(module); + let place = place(owner, output, text); if let Some(exhausted) = resource_death(module, exit_code, output, text.len() as u64, &limits) { exhausted - } else if is_e(module) { + } else if is_e(owner) { Diagnostic::new( code!("LLV7016"), format!( @@ -2414,7 +2424,7 @@ pub fn run_part( first_error(output) ), ) - } else if is_b(module) { + } else if is_b(owner) { Diagnostic::new( code!("LLV7015"), format!( From 40200f4dd5294eedb259cb663d8b9a30698d3df1 Mon Sep 17 00:00:00 2001 From: Alexander Flom Date: Fri, 13 Nov 2026 01:47:49 +0000 Subject: [PATCH 5/6] Isolate absent inspection origins and pin clean compiler inputs --- SPEC.md | 6 +- VERIFICATION.md | 26 +++++++ bootstrap/lexlean.lock | 2 +- compiler/lexlean.lock | 2 +- crates/conformance/src/cases/verification.rs | 67 +++++++++++++++++++ crates/lexlean/src/api/inspection.rs | 6 ++ crates/lexlean/src/api/inspection_core.rs | 17 +++++ crates/lexlean/src/production/lcnf.rs | 21 +++++- examples/collections/lexlean.lock | 2 +- examples/fold-laws/lexlean.lock | 2 +- examples/helpdesk/lexlean.lock | 2 +- examples/higher-order/lexlean.lock | 2 +- examples/language-1.2/lexlean.lock | 2 +- examples/models/lexlean.lock | 2 +- examples/performance-corpus/lexlean.lock | 2 +- examples/production-coverage/lexlean.lock | 2 +- examples/production/lexlean.lock | 2 +- examples/reasoning/lexlean.lock | 2 +- examples/recursion/lexlean.lock | 2 +- examples/recursive-data/lexlean.lock | 2 +- features/suites/verification.feature | 1 + kappa/lexlean.lock | 2 +- language/lcnf-1.2/tooling/src/Extract.lex.tex | 2 +- spec/lexlean.lock | 2 +- spec/src/Chapter22.lex.tex | 6 +- std-models/lexlean.lock | 2 +- std-reasoning/lexlean.lock | 2 +- stdlib/lexlean.lock | 2 +- tests/fixtures/command-driver/lexlean.lock | 2 +- tests/fixtures/host-effects/lexlean.lock | 2 +- .../application-arity/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../binder-capture/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../cases-bool-induction/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../certificate-rejected/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../escaping-closure/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../extraction-rejected/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../graph-duplicate-edge/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lambda-capture-extra/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lambda-type-mismatch/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lowering-depth-limit/project/lexlean.lock | 2 +- .../lowering-size-limit/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-false-evidence/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-missing-entry/project/lexlean.lock | 2 +- .../model-opaque-member/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-vacuous-claim/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../mutual-label-shared/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../preservation-drift/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../reasoning-no-rules/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../recursive-structure/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lists/lexlean.lock | 2 +- tests/rust-backend/loop-ends/lexlean.lock | 2 +- 278 files changed, 412 insertions(+), 278 deletions(-) diff --git a/SPEC.md b/SPEC.md index 401f5e16fc..e0d1191311 100644 --- a/SPEC.md +++ b/SPEC.md @@ -9506,11 +9506,11 @@ Telemetry is write-only: no stage reads it, no ID or verified artifact contains `lexlean inspect` and the sibling `api::inspection` API inspect declarations in the pinned local Lean environment. Inspection is data retrieval, not verification: it runs no proof acceptance shortcut and publishes no verification attestation (`VR-28`). The caller supplies explicit import modules and declaration names; the compiler admits at most 64 declarations, a positive traversal budget no larger than 65536 nodes, a depth bound no larger than 128, and a report bound no larger than 8388608 bytes. Invalid requests fail before running the adapter. -The compiler renders its embedded LexLean tooling adapter through the typed tooling backend and checks the pinned toolchain and registered authority signatures before use. The adapter obtains each declaration's actual kernel type and universe parameters from the loaded environment. It preserves structural names, universes, binder visibility, lambdas, dependent functions, lets, literals and projections; metadata annotations may be omitted because they do not change the kernel type. It rejects free variables, expression metavariables and universe metavariables. A shared traversal budget covers repeated occurrences, names and universes before invoking serialization, so expanding a shared expression cannot bypass the bounds. Budget exhaustion refuses the inspection; it never substitutes a truncated type. +The compiler renders its embedded LexLean tooling adapter through the typed tooling backend and checks the pinned toolchain and registered authority signatures before use. For each declaration present in the loaded environment, the adapter obtains its actual kernel type and universe parameters. An absent declaration retains its requested structural name and position with empty parameters and a null type; its native-core view reports that the declaration was not found and supplies no goal arena. An absent name consumes the shared name-traversal budget and does not prevent inspection of other requested declarations. The adapter preserves structural names, universes, binder visibility, lambdas, dependent functions, lets, literals and projections; metadata annotations may be omitted because they do not change the kernel type. It rejects free variables, expression metavariables and universe metavariables. A shared traversal budget covers repeated occurrences, names and universes before invoking serialization, so expanding a shared expression cannot bypass the bounds. Budget exhaustion refuses the whole inspection; it never substitutes a truncated type or an absence row for an unresolved or over-budget type. -The result binds the admitted import and declaration request, compiler identity and actual tool identities to the bounded process record and inspected data. Only a normal successful owned process with the exact output schema produces an inspection result. A malformed, noisy, timed-out or interrupted adapter fails without accepted inspection output. The caller remains responsible for owning and pinning the imported library build; inspection data alone establishes neither that ownership nor a theorem's proof acceptance. +The result binds the admitted import and declaration request, compiler identity and actual tool identities to the bounded process record and inspected data. Requested declaration count, structural names and order remain exact, including absent-declaration rows; a null type with nonempty parameters is malformed. Only a normal successful owned process with the exact output schema produces an inspection result. A malformed, noisy, timed-out or interrupted adapter fails without accepted inspection output. The caller remains responsible for owning and pinning the imported library build; inspection data alone establishes neither that ownership nor a theorem's proof acceptance. -Each declaration also carries a native-core view when its names and expressions are representable by the native-core schema. That view preserves universe parameters, binder visibility, natural literals and scalar-valued string literals and uses only backward arena references. When a kernel projection has no reported elaborator projection label, or a structural name is outside the native-core name schema, the view explicitly reports why it is unrepresentable; the complete structural kernel type remains available. Neither form is a proof candidate or acceptance receipt. +Each present declaration also carries a native-core view when its names and expressions are representable by the native-core schema. That view preserves universe parameters, binder visibility, natural literals and scalar-valued string literals and uses only backward arena references. When a kernel projection has no reported elaborator projection label, or a structural name is outside the native-core name schema, the view explicitly reports why it is unrepresentable; the complete structural kernel type remains available. An absent declaration uses the same unrepresentable native status with an explicit missing-declaration reason, while its structural type is null. Neither form is a proof candidate or acceptance receipt. --- diff --git a/VERIFICATION.md b/VERIFICATION.md index 6746277d4d..b564700e16 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -39,6 +39,32 @@ Outside `vv`: ## Falsifiability records +### absent inspection origins remain unavailable + +The mixed `True`, absent-name, `Eq.refl` case in `conformance_vr_28` initially +failed with `lean.unknownIdentifier`: checked name quotation rejected the absent +name before the adapter could inspect it. The inspection driver now constructs +structural `Lean.Name` values. The same test passes with pinned Lean 4.32.1: +the two present rows have native goals, the absent row has a null type and an +explicit unrepresentable reason, and insufficient traversal fuel still refuses +the complete report. An absence row is never proof acceptance. + +### compiler identity requires a clean semantic input tree + +A clean CI build of revision `eadeff7cfe` reported language-1.2 identity +`91d8c0b208d5226c5cd8db1761372e17ccad485a604168a54a83455e4ad30ff7`, +while the earlier local compiler and locks reported +`2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750`. +The local embedded inventory included generated +`language/lcnf-1.2/tooling/lexlean.lock` and +`language/lcnf-1.2/tooling/.lexlean/.lock`. The build script intentionally embeds +every regular semantic input; ignored generated files in that tree therefore +change the identity. Build from a clean semantic tree and run tooling commands +in scratch copies. Before freezing the corrected compiler, compare its generated +embedded inventory and input bytes with the committed semantic files, regenerate +project locks using that compiler, and run `conformance_rp_10` to check the +embedded identity against the disk recomputation and project locks. + ### large certificate child budgets can fail Rule30's combined autonomous controller failed certificate-B elaboration with diff --git a/bootstrap/lexlean.lock b/bootstrap/lexlean.lock index 33670419b5..ec4a540ae3 100644 --- a/bootstrap/lexlean.lock +++ b/bootstrap/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "3bc57e64d5e1c92e28b3573210adde6adb01184c1b502f59c28485d0eaff1dca" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "0c4d63390a1e570e10cedd50676c168b7564dd04189879bd13e36176d58f22fb" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/compiler/lexlean.lock b/compiler/lexlean.lock index 3de43264ec..340ee7533f 100644 --- a/compiler/lexlean.lock +++ b/compiler/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "3bc57e64d5e1c92e28b3573210adde6adb01184c1b502f59c28485d0eaff1dca" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "ef58478b65de0ad784269ab3513059f5afbb7f461bda9476efce78344301755e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/crates/conformance/src/cases/verification.rs b/crates/conformance/src/cases/verification.rs index 58acbfea37..56ba89b82b 100644 --- a/crates/conformance/src/cases/verification.rs +++ b/crates/conformance/src/cases/verification.rs @@ -81,6 +81,73 @@ pub(crate) fn run(id: &str) { .as_array() .expect("universe parameters") .is_empty()); + let (exit, _, errors) = project.cli(&[ + "inspect", + "--import", + "Init", + "--declaration", + "True", + "--declaration", + "LexLeanInspectionMissing.absent", + "--declaration", + "Eq.refl", + "--max-nodes", + "4096", + "--max-depth", + "64", + "--out", + "mixed-inspection.json", + ]); + assert_eq!( + exit, 0, + "one absent name must not abort other rows: {errors}" + ); + let mixed: serde_json::Value = serde_json::from_slice( + &std::fs::read(project.root.join("mixed-inspection.json")).expect("mixed report"), + ) + .expect("mixed inspection JSON"); + let rows = mixed["declarations"].as_array().expect("declaration rows"); + assert_eq!(rows.len(), 3); + assert_eq!(rows[0]["name"], serde_json::json!({"str": [null, "True"]})); + assert_eq!(rows[0]["native"]["status"], "available"); + assert_eq!( + rows[1]["name"], + serde_json::json!({"str": [{"str": [null, "LexLeanInspectionMissing"]}, "absent"]}) + ); + assert_eq!(rows[1]["parameters"], serde_json::json!([])); + assert!(rows[1]["type"].is_null()); + assert_eq!(rows[1]["native"]["status"], "unrepresentable"); + assert_eq!( + rows[1]["native"]["reason"], + "declaration not found in the inspected environment" + ); + assert!(rows[1]["native"].get("nodes").is_none()); + assert_eq!( + rows[2]["name"], + serde_json::json!({"str": [{"str": [null, "Eq"]}, "refl"]}) + ); + assert_eq!(rows[2]["native"]["status"], "available"); + assert_eq!(mixed["process"]["exit_code"], 0); + assert_eq!( + mixed["request"]["declarations"], + serde_json::json!(["True", "LexLeanInspectionMissing.absent", "Eq.refl"]) + ); + assert!(mixed.get("attestation_id").is_none()); + let (exit, _, _) = project.cli(&[ + "inspect", + "--import", + "Init", + "--declaration", + "LexLeanInspectionMissing.absent", + "--max-nodes", + "1", + "--max-depth", + "1", + "--out", + "absent-over-budget.json", + ]); + assert_ne!(exit, 0, "absent names must still consume the shared budget"); + assert!(!project.root.join("absent-over-budget.json").exists()); let (exit, _, _) = project.cli(&[ "inspect", "--import", diff --git a/crates/lexlean/src/api/inspection.rs b/crates/lexlean/src/api/inspection.rs index d3469e2810..ab56cb5ef1 100644 --- a/crates/lexlean/src/api/inspection.rs +++ b/crates/lexlean/src/api/inspection.rs @@ -44,6 +44,7 @@ struct LeanIdentity { struct Declaration { name: serde_json::Value, parameters: Vec, + // Null is the owned adapter's explicit absent-declaration row, not a type. #[serde(rename = "type")] ty: serde_json::Value, } @@ -73,6 +74,7 @@ fn structural_name(name: &str) -> serde_json::Value { /// Inspect exact kernel types through the embedded LexLean-authored adapter. /// No caller-supplied type or receipt participates in the result. +/// An absent declaration retains its requested row with no type or native goal. /// /// # Errors /// Rejects invalid bounds/names, toolchain drift, failed or noisy processes, @@ -167,6 +169,10 @@ pub fn inspect(engine: &Engine, request: &InspectionRequest) -> Result, || raw.lean.version != "4.32.1" || raw.lean.githash != "f054605aea4b840552cca2e725580bffd1e1b704" || raw.declarations.len() != request.declarations.len() + || raw + .declarations + .iter() + .any(|row| row.ty.is_null() && !row.parameters.is_empty()) || raw .declarations .iter() diff --git a/crates/lexlean/src/api/inspection_core.rs b/crates/lexlean/src/api/inspection_core.rs index 5c69ec64b9..275f29c71a 100644 --- a/crates/lexlean/src/api/inspection_core.rs +++ b/crates/lexlean/src/api/inspection_core.rs @@ -180,6 +180,11 @@ fn expression(value: &Value, nodes: &mut Vec) -> Result } pub(super) fn convert(ty: &Value, parameters: &[Value]) -> NativeType { + if ty.is_null() && parameters.is_empty() { + return NativeType::Unrepresentable { + reason: "declaration not found in the inspected environment".to_owned(), + }; + } let converted = (|| { let levels = parameters.iter().map(name).collect::, _>>()?; let mut nodes = Vec::new(); @@ -201,6 +206,18 @@ mod tests { use super::*; use serde_json::json; + #[test] + fn absent_declaration_has_no_native_goal() { + let result = serde_json::to_value(convert(&Value::Null, &[])).unwrap(); + assert_eq!(result["status"], "unrepresentable"); + assert_eq!( + result["reason"], + "declaration not found in the inspected environment" + ); + assert!(result.get("nodes").is_none()); + assert!(result.get("root").is_none()); + } + #[test] fn structural_name_components_remain_distinct() { assert_eq!( diff --git a/crates/lexlean/src/production/lcnf.rs b/crates/lexlean/src/production/lcnf.rs index a75ce5fbf1..216dc7c507 100644 --- a/crates/lexlean/src/production/lcnf.rs +++ b/crates/lexlean/src/production/lcnf.rs @@ -239,8 +239,25 @@ pub fn inspection_driver( }, elements: names .iter() - .map(|name| ToolTerm::Name { - value: name.clone(), + .map(|name| { + // Checked name quotations reject absent declarations before inspection. + name.split('.').fold( + ToolTerm::Construct { + constructor: "Lean.Name.anonymous".to_owned(), + type_arguments: Vec::new(), + arguments: Vec::new(), + }, + |parent, component| ToolTerm::Construct { + constructor: "Lean.Name.str".to_owned(), + type_arguments: Vec::new(), + arguments: vec![ + parent, + ToolTerm::String { + value: component.to_owned(), + }, + ], + }, + ) }) .collect(), }, diff --git a/examples/collections/lexlean.lock b/examples/collections/lexlean.lock index c9888a876e..6b70150fb1 100644 --- a/examples/collections/lexlean.lock +++ b/examples/collections/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "902cce2e0ccf037e4769589b7b9af2aac26250c50181b306fecec9028e2a63ff" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/fold-laws/lexlean.lock b/examples/fold-laws/lexlean.lock index 0a6685470f..d7918ecb4c 100644 --- a/examples/fold-laws/lexlean.lock +++ b/examples/fold-laws/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "5d2c8a2881629ee86d82b9e70a1be6fff2518c562d5ca6f45dea96d41edbc005" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/helpdesk/lexlean.lock b/examples/helpdesk/lexlean.lock index b77ecd16c2..ae5d1a43e5 100644 --- a/examples/helpdesk/lexlean.lock +++ b/examples/helpdesk/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "30e9380b31a91b74c3c02f5882a9070290c6a5c41e1dd3bf56d9c617396343e7" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/higher-order/lexlean.lock b/examples/higher-order/lexlean.lock index e80ff73c9f..26a6968f19 100644 --- a/examples/higher-order/lexlean.lock +++ b/examples/higher-order/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "2854e1de7560697fdce6b84ea09e897fa3936fd6c0fbca153d62201ce8ed4d61" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/language-1.2/lexlean.lock b/examples/language-1.2/lexlean.lock index 9b7cd86258..d3a6820c44 100644 --- a/examples/language-1.2/lexlean.lock +++ b/examples/language-1.2/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "83557b5053642ede054857828d95f4c17d6d6e14fab13f017a7feb166bd89c0f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/models/lexlean.lock b/examples/models/lexlean.lock index d3109f637d..65b685db53 100644 --- a/examples/models/lexlean.lock +++ b/examples/models/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b79e1070aab27c02ec4396ee66aa4bad7b90f9bca923932529eb9eb26264761a" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/performance-corpus/lexlean.lock b/examples/performance-corpus/lexlean.lock index ef83871662..39b3336837 100644 --- a/examples/performance-corpus/lexlean.lock +++ b/examples/performance-corpus/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "f94da2d4131decea3a9f53124824e0d81f88c75fefbe62fa443d3203e84a9b39" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production-coverage/lexlean.lock b/examples/production-coverage/lexlean.lock index 7578bd3e3b..249825381e 100644 --- a/examples/production-coverage/lexlean.lock +++ b/examples/production-coverage/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "8c8f206d89e67b327167aecf57185e532cb99e5ebda5aa538d04fce39951f22e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production/lexlean.lock b/examples/production/lexlean.lock index 87bcc6c524..3cece3e15e 100644 --- a/examples/production/lexlean.lock +++ b/examples/production/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "f2cbda9bf591701cef68498eabd2f96cf838e61cca5c7193c83c78d7fce1560f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/reasoning/lexlean.lock b/examples/reasoning/lexlean.lock index ef0e121dda..17b8fa38f9 100644 --- a/examples/reasoning/lexlean.lock +++ b/examples/reasoning/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "254deddb728df2532affa57ca92fefae0324c34d616c713273d63bd4cccbb2bf" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursion/lexlean.lock b/examples/recursion/lexlean.lock index f243f3b524..8c84734388 100644 --- a/examples/recursion/lexlean.lock +++ b/examples/recursion/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "92ff94a2dc1a550b8d47ebdd8b8e9b9d89371435ef550e661022fe74cf51594d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursive-data/lexlean.lock b/examples/recursive-data/lexlean.lock index 75f3332cd4..8be4bcf862 100644 --- a/examples/recursive-data/lexlean.lock +++ b/examples/recursive-data/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "1642b5144f8137f7c2f980a40564f8bcd579515bbb15411ada96c9e513ba0499" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/features/suites/verification.feature b/features/suites/verification.feature index 476e4325c2..809d066aaa 100644 --- a/features/suites/verification.feature +++ b/features/suites/verification.feature @@ -7,6 +7,7 @@ Feature: verification Given the pinned local Lean environment and the embedded typed inspection adapter When declarations with universe parameters and implicit binders are inspected Then the report preserves their complete structural kernel types without a verification attestation + And an absent declaration retains its ordered row without a native goal while other declarations remain inspectable And exhausted node or depth budgets refuse inspection without truncated output And malformed requests and unresolved terms cannot produce accepted inspection data diff --git a/kappa/lexlean.lock b/kappa/lexlean.lock index 21ba7f734c..b840f6ff6b 100644 --- a/kappa/lexlean.lock +++ b/kappa/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b5a7664cf56fe322a652d657d726eaea2f825b6130260db1c8e7d6ed8961d4da" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/language/lcnf-1.2/tooling/src/Extract.lex.tex b/language/lcnf-1.2/tooling/src/Extract.lex.tex index ad512700b9..f696d2eb30 100644 --- a/language/lcnf-1.2/tooling/src/Extract.lex.tex +++ b/language/lcnf-1.2/tooling/src/Extract.lex.tex @@ -14864,7 +14864,7 @@ function{name: "LexLeanExtract.inspectBinderJson", type_parameters: [], parameters: [{name: "info", type: const{name: "Lean.BinderInfo", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "info"}, branches: [{constructor: "Lean.BinderInfo.default", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "default"}], type_arguments: []}}, {constructor: "Lean.BinderInfo.implicit", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "implicit"}], type_arguments: []}}, {constructor: "Lean.BinderInfo.strictImplicit", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "strictImplicit"}], type_arguments: []}}, {constructor: "Lean.BinderInfo.instImplicit", binders: [], body: call{function: "LexLeanExtract.str", arguments: [string{value: "instImplicit"}], type_arguments: []}}]}, partial: false, public: false}, function{name: "LexLeanExtract.inspectLiteralJson", type_parameters: [], parameters: [{name: "literal", type: const{name: "Lean.Literal", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "literal"}, branches: [{constructor: "Lean.Literal.natVal", binders: ["number"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "natVal"}, call{function: "ToString.toString", arguments: [var{name: "number"}], type_arguments: [const{name: "Nat", arguments: []}]}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Literal.strVal", binders: ["text"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "strVal"}, call{function: "LexLeanExtract.str", arguments: [var{name: "text"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}]}, partial: false, public: false}, function{name: "LexLeanExtract.inspectExprJson", type_parameters: [], parameters: [{name: "expr", type: const{name: "Lean.Expr", arguments: []}}], result: const{name: "String", arguments: []}, body: match{scrutinee: var{name: "expr"}, branches: [{constructor: "Lean.Expr.bvar", binders: ["index"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "bvar"}, call{function: "ToString.toString", arguments: [var{name: "index"}], type_arguments: [const{name: "Nat", arguments: []}]}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.fvar", binders: ["id"], body: string{value: "null"}}, {constructor: "Lean.Expr.mvar", binders: ["id"], body: string{value: "null"}}, {constructor: "Lean.Expr.sort", binders: ["level"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "sort"}, call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "level"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.const", binders: ["name", "levels"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "const"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "levels"}, call{function: "LexLeanExtract.arr", arguments: [call{function: "List.map", arguments: [lambda{parameters: [{name: "level", type: const{name: "Lean.Level", arguments: []}}], body: call{function: "LexLeanExtract.inspectLevelJson", arguments: [var{name: "level"}], type_arguments: []}}, var{name: "levels"}], type_arguments: [const{name: "Lean.Level", arguments: []}, const{name: "String", arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.app", binders: ["fn", "arg"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "app"}, call{function: "LexLeanExtract.arr", arguments: [list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "fn"}], type_arguments: []}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "arg"}], type_arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.lam", binders: ["name", "type", "body", "info"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "lam"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "body"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "bi"}, call{function: "LexLeanExtract.inspectBinderJson", arguments: [var{name: "info"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.forallE", binders: ["name", "type", "body", "info"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "forallE"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "body"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "bi"}, call{function: "LexLeanExtract.inspectBinderJson", arguments: [var{name: "info"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.letE", binders: ["name", "type", "value", "body", "nondep"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "letE"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "value"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "value"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "body"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "nondep"}, call{function: "LexLeanExtract.bool", arguments: [var{name: "nondep"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.lit", binders: ["literal"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "lit"}, call{function: "LexLeanExtract.inspectLiteralJson", arguments: [var{name: "literal"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}, {constructor: "Lean.Expr.mdata", binders: ["metadata", "body"], body: call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}}, {constructor: "Lean.Expr.proj", binders: ["name", "index", "body"], body: call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "proj"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "typeName"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "name"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "idx"}, call{function: "ToString.toString", arguments: [var{name: "index"}], type_arguments: [const{name: "Nat", arguments: []}]}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "struct"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "body"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}}]}, partial: true, public: false}, - function{name: "LexLeanExtract.inspectRows", type_parameters: [], parameters: [{name: "names", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}, {name: "rows", type: const{name: "List", arguments: [const{name: "String", arguments: []}]}}], result: const{name: "Lean.Core.CoreM", arguments: [const{name: "String", arguments: []}]}, body: match{scrutinee: var{name: "names"}, branches: [{constructor: "List.nil", binders: [], body: call{function: "Pure.pure", arguments: [call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "spec"}, call{function: "LexLeanExtract.str", arguments: [string{value: "lexlean/kernel-inspection/1"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "lean"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "version"}, call{function: "LexLeanExtract.str", arguments: [call{function: "Lean.versionString", arguments: [], type_arguments: []}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "githash"}, call{function: "LexLeanExtract.str", arguments: [call{function: "Lean.githash", arguments: [], type_arguments: []}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "declarations"}, call{function: "LexLeanExtract.arr", arguments: [var{name: "rows"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}]}}, {constructor: "List.cons", binders: ["head", "tail"], body: call{function: "Bind.bind", arguments: [call{function: "Lean.getConstInfo", arguments: [var{name: "head"}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}]}, lambda{parameters: [{name: "info", type: const{name: "Lean.ConstantInfo", arguments: []}}], body: let{binder: "params", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}, value: call{function: "Lean.ConstantInfo.levelParams", arguments: [var{name: "info"}], type_arguments: []}, body: let{binder: "type", type: const{name: "Lean.Expr", arguments: []}, value: call{function: "Lean.ConstantInfo.type", arguments: [var{name: "info"}], type_arguments: []}, body: let{binder: "remaining", type: const{name: "Nat", arguments: []}, value: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "type"}, call{function: "LexLeanExtract.inspectNames", arguments: [var{name: "params"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "head"}, var{name: "fuel"}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "remaining"}], type_arguments: []}, then_branch: call{function: "LexLeanExtract.inspectRows", arguments: [var{name: "tail"}, var{name: "remaining"}, var{name: "depth"}, call{function: "List.append", arguments: [var{name: "rows"}, list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "head"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "parameters"}, call{function: "LexLeanExtract.arr", arguments: [call{function: "List.map", arguments: [lambda{parameters: [{name: "param", type: const{name: "Lean.Name", arguments: []}}], body: call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "param"}], type_arguments: []}}, var{name: "params"}], type_arguments: [const{name: "Lean.Name", arguments: []}, const{name: "String", arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}]}], type_arguments: [const{name: "String", arguments: []}]}], type_arguments: []}, else_branch: call{function: "Lean.throwError", arguments: [call{function: "Lean.stringToMessageData", arguments: [string{value: "lexlean-inspection-refused: traversal budget exhausted or unresolved kernel term"}], type_arguments: []}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}]}}}}}}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "Lean.ConstantInfo", arguments: []}, const{name: "String", arguments: []}]}}]}, partial: true, public: false}, + function{name: "LexLeanExtract.inspectRows", type_parameters: [], parameters: [{name: "names", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}}, {name: "fuel", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}, {name: "rows", type: const{name: "List", arguments: [const{name: "String", arguments: []}]}}], result: const{name: "Lean.Core.CoreM", arguments: [const{name: "String", arguments: []}]}, body: match{scrutinee: var{name: "names"}, branches: [{constructor: "List.nil", binders: [], body: call{function: "Pure.pure", arguments: [call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "spec"}, call{function: "LexLeanExtract.str", arguments: [string{value: "lexlean/kernel-inspection/1"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "lean"}, call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "version"}, call{function: "LexLeanExtract.str", arguments: [call{function: "Lean.versionString", arguments: [], type_arguments: []}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "githash"}, call{function: "LexLeanExtract.str", arguments: [call{function: "Lean.githash", arguments: [], type_arguments: []}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "declarations"}, call{function: "LexLeanExtract.arr", arguments: [var{name: "rows"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}]}}, {constructor: "List.cons", binders: ["head", "tail"], body: call{function: "Bind.bind", arguments: [call{function: "Lean.MonadEnv.getEnv", arguments: [], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}]}, lambda{parameters: [{name: "env", type: const{name: "Lean.Environment", arguments: []}}], body: match{scrutinee: call{function: "Lean.Environment.find?", arguments: [var{name: "env"}, var{name: "head"}], type_arguments: []}, branches: [{constructor: "Option.none", binders: [], body: let{binder: "remaining", type: const{name: "Nat", arguments: []}, value: call{function: "LexLeanExtract.inspectName", arguments: [var{name: "head"}, var{name: "fuel"}, var{name: "depth"}], type_arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "remaining"}], type_arguments: []}, then_branch: call{function: "LexLeanExtract.inspectRows", arguments: [var{name: "tail"}, var{name: "remaining"}, var{name: "depth"}, call{function: "List.append", arguments: [var{name: "rows"}, list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "head"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "parameters"}, string{value: "[]"}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, string{value: "null"}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}]}], type_arguments: [const{name: "String", arguments: []}]}], type_arguments: []}, else_branch: call{function: "Lean.throwError", arguments: [call{function: "Lean.stringToMessageData", arguments: [string{value: "lexlean-inspection-refused: traversal budget exhausted or unresolved kernel term"}], type_arguments: []}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}]}}}}, {constructor: "Option.some", binders: ["info"], body: let{binder: "params", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}, value: call{function: "Lean.ConstantInfo.levelParams", arguments: [var{name: "info"}], type_arguments: []}, body: let{binder: "type", type: const{name: "Lean.Expr", arguments: []}, value: call{function: "Lean.ConstantInfo.type", arguments: [var{name: "info"}], type_arguments: []}, body: let{binder: "remaining", type: const{name: "Nat", arguments: []}, value: call{function: "LexLeanExtract.inspectExpr", arguments: [var{name: "type"}, call{function: "LexLeanExtract.inspectNames", arguments: [var{name: "params"}, call{function: "LexLeanExtract.inspectName", arguments: [var{name: "head"}, var{name: "fuel"}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}, var{name: "depth"}], type_arguments: []}, body: if{condition: call{function: "Nat.blt", arguments: [nat{value: "0"}, var{name: "remaining"}], type_arguments: []}, then_branch: call{function: "LexLeanExtract.inspectRows", arguments: [var{name: "tail"}, var{name: "remaining"}, var{name: "depth"}, call{function: "List.append", arguments: [var{name: "rows"}, list{element: const{name: "String", arguments: []}, elements: [call{function: "LexLeanExtract.obj", arguments: [list{element: const{name: "Prod", arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, elements: [construct{constructor: "Prod.mk", arguments: [string{value: "name"}, call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "head"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "parameters"}, call{function: "LexLeanExtract.arr", arguments: [call{function: "List.map", arguments: [lambda{parameters: [{name: "param", type: const{name: "Lean.Name", arguments: []}}], body: call{function: "LexLeanExtract.inspectNameJson", arguments: [var{name: "param"}], type_arguments: []}}, var{name: "params"}], type_arguments: [const{name: "Lean.Name", arguments: []}, const{name: "String", arguments: []}]}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}, construct{constructor: "Prod.mk", arguments: [string{value: "type"}, call{function: "LexLeanExtract.inspectExprJson", arguments: [var{name: "type"}], type_arguments: []}], type_arguments: [const{name: "String", arguments: []}, const{name: "String", arguments: []}]}]}], type_arguments: []}]}], type_arguments: [const{name: "String", arguments: []}]}], type_arguments: []}, else_branch: call{function: "Lean.throwError", arguments: [call{function: "Lean.stringToMessageData", arguments: [string{value: "lexlean-inspection-refused: traversal budget exhausted or unresolved kernel term"}], type_arguments: []}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}]}}}}}}]}}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "Lean.Environment", arguments: []}, const{name: "String", arguments: []}]}}]}, partial: true, public: false}, function{name: "LexLeanExtract.inspectMain", type_parameters: [], parameters: [{name: "names", type: const{name: "List", arguments: [const{name: "Lean.Name", arguments: []}]}}, {name: "nodes", type: const{name: "Nat", arguments: []}}, {name: "depth", type: const{name: "Nat", arguments: []}}], result: const{name: "Lean.Elab.Command.CommandElabM", arguments: [const{name: "Unit", arguments: []}]}, body: call{function: "Lean.Elab.Command.liftCoreM", arguments: [call{function: "Bind.bind", arguments: [call{function: "LexLeanExtract.inspectRows", arguments: [var{name: "names"}, call{function: "Nat.add", arguments: [var{name: "nodes"}, nat{value: "1"}], type_arguments: []}, var{name: "depth"}, list{element: const{name: "String", arguments: []}, elements: []}], type_arguments: []}, lambda{parameters: [{name: "text", type: const{name: "String", arguments: []}}], body: call{function: "MonadLiftT.monadLift", arguments: [call{function: "IO.println", arguments: [var{name: "text"}], type_arguments: [const{name: "String", arguments: []}]}], type_arguments: [const{name: "IO", arguments: []}, const{name: "Lean.Core.CoreM", arguments: []}, const{name: "Unit", arguments: []}]}}], type_arguments: [const{name: "Lean.Core.CoreM", arguments: []}, const{name: "String", arguments: []}, const{name: "Unit", arguments: []}]}], type_arguments: [const{name: "Unit", arguments: []}]}, partial: false, public: false} ], imports: [] diff --git a/spec/lexlean.lock b/spec/lexlean.lock index c2d47e5b34..3b50faba3c 100644 --- a/spec/lexlean.lock +++ b/spec/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "29ba9126f5a06fcb4eb426cf07b2fb0462a0adad864ffc2187a644076d840201" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/spec/src/Chapter22.lex.tex b/spec/src/Chapter22.lex.tex index 8e0363fa4d..bf0b6f0e62 100644 --- a/spec/src/Chapter22.lex.tex +++ b/spec/src/Chapter22.lex.tex @@ -1109,7 +1109,7 @@ result: DocRows::Item, body: constructor{ arguments: [ - (cons "The compiler renders its embedded LexLean tooling adapter through the typed tooling backend and checks the pinned toolchain and registered authority signatures before use. The adapter obtains each declaration's actual kernel type and universe parameters from the loaded environment. It preserves structural names, universes, binder visibility, lambdas, dependent functions, lets, literals and projections; metadata annotations may be omitted because they do not change the kernel type. It rejects free variables, expression metavariables and universe metavariables. A shared traversal budget covers repeated occurrences, names and universes before invoking serialization, so expanding a shared expression cannot bypass the bounds. Budget exhaustion refuses the inspection; it never substitutes a truncated type." (nil String)) + (cons "The compiler renders its embedded LexLean tooling adapter through the typed tooling backend and checks the pinned toolchain and registered authority signatures before use. For each declaration present in the loaded environment, the adapter obtains its actual kernel type and universe parameters. An absent declaration retains its requested structural name and position with empty parameters and a null type; its native-core view reports that the declaration was not found and supplies no goal arena. An absent name consumes the shared name-traversal budget and does not prevent inspection of other requested declarations. The adapter preserves structural names, universes, binder visibility, lambdas, dependent functions, lets, literals and projections; metadata annotations may be omitted because they do not change the kernel type. It rejects free variables, expression metavariables and universe metavariables. A shared traversal budget covers repeated occurrences, names and universes before invoking serialization, so expanding a shared expression cannot bypass the bounds. Budget exhaustion refuses the whole inspection; it never substitutes a truncated type or an absence row for an unresolved or over-budget type." (nil String)) ], constructor: DocRows::Item.para, type_arguments: [] @@ -1123,7 +1123,7 @@ result: DocRows::Item, body: constructor{ arguments: [ - (cons "The result binds the admitted import and declaration request, compiler identity and actual tool identities to the bounded process record and inspected data. Only a normal successful owned process with the exact output schema produces an inspection result. A malformed, noisy, timed-out or interrupted adapter fails without accepted inspection output. The caller remains responsible for owning and pinning the imported library build; inspection data alone establishes neither that ownership nor a theorem's proof acceptance." (nil String)) + (cons "The result binds the admitted import and declaration request, compiler identity and actual tool identities to the bounded process record and inspected data. Requested declaration count, structural names and order remain exact, including absent-declaration rows; a null type with nonempty parameters is malformed. Only a normal successful owned process with the exact output schema produces an inspection result. A malformed, noisy, timed-out or interrupted adapter fails without accepted inspection output. The caller remains responsible for owning and pinning the imported library build; inspection data alone establishes neither that ownership nor a theorem's proof acceptance." (nil String)) ], constructor: DocRows::Item.para, type_arguments: [] @@ -1137,7 +1137,7 @@ result: DocRows::Item, body: constructor{ arguments: [ - (cons "Each declaration also carries a native-core view when its names and expressions are representable by the native-core schema. That view preserves universe parameters, binder visibility, natural literals and scalar-valued string literals and uses only backward arena references. When a kernel projection has no reported elaborator projection label, or a structural name is outside the native-core name schema, the view explicitly reports why it is unrepresentable; the complete structural kernel type remains available. Neither form is a proof candidate or acceptance receipt." (nil String)) + (cons "Each present declaration also carries a native-core view when its names and expressions are representable by the native-core schema. That view preserves universe parameters, binder visibility, natural literals and scalar-valued string literals and uses only backward arena references. When a kernel projection has no reported elaborator projection label, or a structural name is outside the native-core name schema, the view explicitly reports why it is unrepresentable; the complete structural kernel type remains available. An absent declaration uses the same unrepresentable native status with an explicit missing-declaration reason, while its structural type is null. Neither form is a proof candidate or acceptance receipt." (nil String)) ], constructor: DocRows::Item.para, type_arguments: [] diff --git a/std-models/lexlean.lock b/std-models/lexlean.lock index 0ca7e8284b..81d73f40b9 100644 --- a/std-models/lexlean.lock +++ b/std-models/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b23bdec83131b3e4f0a45197f98f9b7144a208ff5a2692289262e5096a455001" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/std-reasoning/lexlean.lock b/std-reasoning/lexlean.lock index 7bc5542de6..f3945bf8a4 100644 --- a/std-reasoning/lexlean.lock +++ b/std-reasoning/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "76ead6f0bc516e1d9669cf1333e7b75d9e7c19c7f3f8aeb000ca36ad15d432bc" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/stdlib/lexlean.lock b/stdlib/lexlean.lock index 2036b2b4e5..3a69523db5 100644 --- a/stdlib/lexlean.lock +++ b/stdlib/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "4ec208494fa7641b35f82cda91b06851ca826caaefa4d0385110c8d8b2b65878" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/fixtures/command-driver/lexlean.lock b/tests/fixtures/command-driver/lexlean.lock index 5b8916bc7c..9ec38f27a0 100644 --- a/tests/fixtures/command-driver/lexlean.lock +++ b/tests/fixtures/command-driver/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "3bc57e64d5e1c92e28b3573210adde6adb01184c1b502f59c28485d0eaff1dca" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "c473b0fc61740f7a386ffe868abdb4782e32d0749ecfe7caf2642636d1a91551" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/fixtures/host-effects/lexlean.lock b/tests/fixtures/host-effects/lexlean.lock index 74dc9229bf..3eb53d765c 100644 --- a/tests/fixtures/host-effects/lexlean.lock +++ b/tests/fixtures/host-effects/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "3bc57e64d5e1c92e28b3573210adde6adb01184c1b502f59c28485d0eaff1dca" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "d644b662d060217370202451ab3393637dec3e45a71400741b97fd1bd8dd3ee2" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-arity/project/lexlean.lock b/tests/negative/application-arity/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/application-arity/project/lexlean.lock +++ b/tests/negative/application-arity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-non-function/project/lexlean.lock b/tests/negative/application-non-function/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/application-non-function/project/lexlean.lock +++ b/tests/negative/application-non-function/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-bool-literal-name/project/lexlean.lock b/tests/negative/binder-bool-literal-name/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/binder-bool-literal-name/project/lexlean.lock +++ b/tests/negative/binder-bool-literal-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-capture/project/lexlean.lock b/tests/negative/binder-capture/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/binder-capture/project/lexlean.lock +++ b/tests/negative/binder-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock index a96fdf1df6..ca9c9b3f63 100644 --- a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock +++ b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "81ee2a9ef8c129bd8d1d2c5a002526675b1f2cbabb784a33bbb447892bd48c9f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-branch-binder/project/lexlean.lock b/tests/negative/cases-bool-branch-binder/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/cases-bool-branch-binder/project/lexlean.lock +++ b/tests/negative/cases-bool-branch-binder/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-branch-repeated/project/lexlean.lock b/tests/negative/cases-bool-branch-repeated/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/cases-bool-branch-repeated/project/lexlean.lock +++ b/tests/negative/cases-bool-branch-repeated/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-induction/project/lexlean.lock b/tests/negative/cases-bool-induction/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/cases-bool-induction/project/lexlean.lock +++ b/tests/negative/cases-bool-induction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-missing-branch/project/lexlean.lock b/tests/negative/cases-bool-missing-branch/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/cases-bool-missing-branch/project/lexlean.lock +++ b/tests/negative/cases-bool-missing-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-b-rejected/project/lexlean.lock b/tests/negative/certificate-b-rejected/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/certificate-b-rejected/project/lexlean.lock +++ b/tests/negative/certificate-b-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-e-rejected/project/lexlean.lock b/tests/negative/certificate-e-rejected/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/certificate-e-rejected/project/lexlean.lock +++ b/tests/negative/certificate-e-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-generation-limit/project/lexlean.lock b/tests/negative/certificate-generation-limit/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/certificate-generation-limit/project/lexlean.lock +++ b/tests/negative/certificate-generation-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock +++ b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-rejected/project/lexlean.lock b/tests/negative/certificate-rejected/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/certificate-rejected/project/lexlean.lock +++ b/tests/negative/certificate-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-resource-exhausted/project/lexlean.lock b/tests/negative/certificate-resource-exhausted/project/lexlean.lock index d4021fa8c9..82bef96e8b 100644 --- a/tests/negative/certificate-resource-exhausted/project/lexlean.lock +++ b/tests/negative/certificate-resource-exhausted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "533c8a12cea89372dcb6f4707ed7e213695aac97bb956164fc7240cf3ef64a1c" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-size-limit/project/lexlean.lock b/tests/negative/certificate-size-limit/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/certificate-size-limit/project/lexlean.lock +++ b/tests/negative/certificate-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificates-total-limit/project/lexlean.lock b/tests/negative/certificates-total-limit/project/lexlean.lock index a7e1661416..66514582ed 100644 --- a/tests/negative/certificates-total-limit/project/lexlean.lock +++ b/tests/negative/certificates-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "19396dab32e876e6744d5feb41043ceae6961ae8b3e677fc770b3b09fcdbc8ad" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-duplicate-key/project/lexlean.lock b/tests/negative/collection-duplicate-key/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/collection-duplicate-key/project/lexlean.lock +++ b/tests/negative/collection-duplicate-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock +++ b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-literal-limit/project/lexlean.lock b/tests/negative/collection-literal-limit/project/lexlean.lock index 1fd4f648c2..95b94227f3 100644 --- a/tests/negative/collection-literal-limit/project/lexlean.lock +++ b/tests/negative/collection-literal-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "86eb9da7c6c50be25511dfe1cbf99f5e0ac82b411c2ed9b5b4e6c94924af2253" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-noncanonical-key/project/lexlean.lock b/tests/negative/collection-noncanonical-key/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/collection-noncanonical-key/project/lexlean.lock +++ b/tests/negative/collection-noncanonical-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-nonliteral-key/project/lexlean.lock b/tests/negative/collection-nonliteral-key/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/collection-nonliteral-key/project/lexlean.lock +++ b/tests/negative/collection-nonliteral-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-out-of-range-key/project/lexlean.lock b/tests/negative/collection-out-of-range-key/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/collection-out-of-range-key/project/lexlean.lock +++ b/tests/negative/collection-out-of-range-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unbounded-iteration/project/lexlean.lock b/tests/negative/collection-unbounded-iteration/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/collection-unbounded-iteration/project/lexlean.lock +++ b/tests/negative/collection-unbounded-iteration/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unordered-key/project/lexlean.lock b/tests/negative/collection-unordered-key/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/collection-unordered-key/project/lexlean.lock +++ b/tests/negative/collection-unordered-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cross-version-glossary/project/lexlean.lock b/tests/negative/cross-version-glossary/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/cross-version-glossary/project/lexlean.lock +++ b/tests/negative/cross-version-glossary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/declaration-lean-name/project/lexlean.lock b/tests/negative/declaration-lean-name/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/declaration-lean-name/project/lexlean.lock +++ b/tests/negative/declaration-lean-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-report-limit/project/lexlean.lock b/tests/negative/eligibility-report-limit/project/lexlean.lock index 3e479956fa..8c60370792 100644 --- a/tests/negative/eligibility-report-limit/project/lexlean.lock +++ b/tests/negative/eligibility-report-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock index 3e479956fa..8c60370792 100644 --- a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock +++ b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-in-data/project/lexlean.lock b/tests/negative/escaping-closure-in-data/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/escaping-closure-in-data/project/lexlean.lock +++ b/tests/negative/escaping-closure-in-data/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-parameter/project/lexlean.lock b/tests/negative/escaping-closure-parameter/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/escaping-closure-parameter/project/lexlean.lock +++ b/tests/negative/escaping-closure-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-structure/project/lexlean.lock b/tests/negative/escaping-closure-structure/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/escaping-closure-structure/project/lexlean.lock +++ b/tests/negative/escaping-closure-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure/project/lexlean.lock b/tests/negative/escaping-closure/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/escaping-closure/project/lexlean.lock +++ b/tests/negative/escaping-closure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/executable-calls-formal/project/lexlean.lock b/tests/negative/executable-calls-formal/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/executable-calls-formal/project/lexlean.lock +++ b/tests/negative/executable-calls-formal/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-authority-drift/project/lexlean.lock b/tests/negative/extraction-authority-drift/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/extraction-authority-drift/project/lexlean.lock +++ b/tests/negative/extraction-authority-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-rejected/project/lexlean.lock b/tests/negative/extraction-rejected/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/extraction-rejected/project/lexlean.lock +++ b/tests/negative/extraction-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-uncompiled-external/project/lexlean.lock b/tests/negative/extraction-uncompiled-external/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/extraction-uncompiled-external/project/lexlean.lock +++ b/tests/negative/extraction-uncompiled-external/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/gnaf-certificate-malformed/project/lexlean.lock b/tests/negative/gnaf-certificate-malformed/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/gnaf-certificate-malformed/project/lexlean.lock +++ b/tests/negative/gnaf-certificate-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/gnaf-request-malformed/project/lexlean.lock b/tests/negative/gnaf-request-malformed/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/gnaf-request-malformed/project/lexlean.lock +++ b/tests/negative/gnaf-request-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-duplicate-edge/project/lexlean.lock b/tests/negative/graph-duplicate-edge/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/graph-duplicate-edge/project/lexlean.lock +++ b/tests/negative/graph-duplicate-edge/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-invalid-reference/project/lexlean.lock b/tests/negative/graph-invalid-reference/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/graph-invalid-reference/project/lexlean.lock +++ b/tests/negative/graph-invalid-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-extra/project/lexlean.lock b/tests/negative/lambda-capture-extra/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/lambda-capture-extra/project/lexlean.lock +++ b/tests/negative/lambda-capture-extra/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-missing/project/lexlean.lock b/tests/negative/lambda-capture-missing/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/lambda-capture-missing/project/lexlean.lock +++ b/tests/negative/lambda-capture-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-type-mismatch/project/lexlean.lock b/tests/negative/lambda-type-mismatch/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/lambda-type-mismatch/project/lexlean.lock +++ b/tests/negative/lambda-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lock-schema-language-mismatch/project/lexlean.lock b/tests/negative/lock-schema-language-mismatch/project/lexlean.lock index 5f8474519f..731ae71673 100644 --- a/tests/negative/lock-schema-language-mismatch/project/lexlean.lock +++ b/tests/negative/lock-schema-language-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/1" language = "1.2" -compiler_semantics = "06c6ce1c1f570190e16711a48eb85939cc93665bd888c4095692dc0791638e4b" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lowering-depth-limit/project/lexlean.lock b/tests/negative/lowering-depth-limit/project/lexlean.lock index cb822624f9..24c0fa4562 100644 --- a/tests/negative/lowering-depth-limit/project/lexlean.lock +++ b/tests/negative/lowering-depth-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "0ef90b79ef115752acdab64e47ead3e354657b99e6ddcb26ec636f024e7ef5ee" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lowering-size-limit/project/lexlean.lock b/tests/negative/lowering-size-limit/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/lowering-size-limit/project/lexlean.lock +++ b/tests/negative/lowering-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/member-generated-name/project/lexlean.lock b/tests/negative/member-generated-name/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/member-generated-name/project/lexlean.lock +++ b/tests/negative/member-generated-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-decode-budget/project/lexlean.lock b/tests/negative/model-artifact-decode-budget/project/lexlean.lock index 8d7f284d8d..c98bc168f9 100644 --- a/tests/negative/model-artifact-decode-budget/project/lexlean.lock +++ b/tests/negative/model-artifact-decode-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "97224c1005c098cfb00c28986caa7733eb43fd183f038947ba92d676edede581" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock index d7a2c55b6d..5c180d705b 100644 --- a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock index f910fa5ccb..594b72089b 100644 --- a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock +++ b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "7407260b337f63f50bc003afdc8e09e578096041ae6365e5b1f39d0dc3d8e093" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock index d7a2c55b6d..5c180d705b 100644 --- a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-missing/project/lexlean.lock b/tests/negative/model-artifact-missing/project/lexlean.lock index d7a2c55b6d..5c180d705b 100644 --- a/tests/negative/model-artifact-missing/project/lexlean.lock +++ b/tests/negative/model-artifact-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-over-limit/project/lexlean.lock b/tests/negative/model-artifact-over-limit/project/lexlean.lock index 06d2edd123..e574b95297 100644 --- a/tests/negative/model-artifact-over-limit/project/lexlean.lock +++ b/tests/negative/model-artifact-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6b2d40a11356013ad4366b900361329faecae628242794cbc0d2ba8a54ff7d4c" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock index c5e2d841d1..09a2f43114 100644 --- a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock +++ b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "9f0dd9fc1743c1e5be95b546a6d77274f7fd5ffc95c0920b73cfe4e007b47fe0" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-role-violation/project/lexlean.lock b/tests/negative/model-artifact-role-violation/project/lexlean.lock index d7a2c55b6d..5c180d705b 100644 --- a/tests/negative/model-artifact-role-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-role-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-schema-violation/project/lexlean.lock b/tests/negative/model-artifact-schema-violation/project/lexlean.lock index d7a2c55b6d..5c180d705b 100644 --- a/tests/negative/model-artifact-schema-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-schema-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock index cba5b7b8be..c17473d2b2 100644 --- a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-symlink/project/lexlean.lock b/tests/negative/model-artifact-symlink/project/lexlean.lock index d7a2c55b6d..5c180d705b 100644 --- a/tests/negative/model-artifact-symlink/project/lexlean.lock +++ b/tests/negative/model-artifact-symlink/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-unconfigured/project/lexlean.lock b/tests/negative/model-artifact-unconfigured/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-artifact-unconfigured/project/lexlean.lock +++ b/tests/negative/model-artifact-unconfigured/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-check-without-validator/project/lexlean.lock b/tests/negative/model-check-without-validator/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-check-without-validator/project/lexlean.lock +++ b/tests/negative/model-check-without-validator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-forged-junction/project/lexlean.lock b/tests/negative/model-composition-forged-junction/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-composition-forged-junction/project/lexlean.lock +++ b/tests/negative/model-composition-forged-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-missing-junction/project/lexlean.lock b/tests/negative/model-composition-missing-junction/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-composition-missing-junction/project/lexlean.lock +++ b/tests/negative/model-composition-missing-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-type-mismatch/project/lexlean.lock b/tests/negative/model-composition-type-mismatch/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-composition-type-mismatch/project/lexlean.lock +++ b/tests/negative/model-composition-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock +++ b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-encoder-width-forged/project/lexlean.lock b/tests/negative/model-encoder-width-forged/project/lexlean.lock index cba5b7b8be..c17473d2b2 100644 --- a/tests/negative/model-encoder-width-forged/project/lexlean.lock +++ b/tests/negative/model-encoder-width-forged/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-false-evidence/project/lexlean.lock b/tests/negative/model-false-evidence/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-false-evidence/project/lexlean.lock +++ b/tests/negative/model-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-float-descriptor/project/lexlean.lock b/tests/negative/model-float-descriptor/project/lexlean.lock index d7a2c55b6d..5c180d705b 100644 --- a/tests/negative/model-float-descriptor/project/lexlean.lock +++ b/tests/negative/model-float-descriptor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-foreign-evidence/project/lexlean.lock b/tests/negative/model-foreign-evidence/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-foreign-evidence/project/lexlean.lock +++ b/tests/negative/model-foreign-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-forged-evidence/project/lexlean.lock b/tests/negative/model-forged-evidence/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-forged-evidence/project/lexlean.lock +++ b/tests/negative/model-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-missing-entry/project/lexlean.lock b/tests/negative/model-missing-entry/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-missing-entry/project/lexlean.lock +++ b/tests/negative/model-missing-entry/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-opaque-member/project/lexlean.lock b/tests/negative/model-opaque-member/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-opaque-member/project/lexlean.lock +++ b/tests/negative/model-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-predicate-signature/project/lexlean.lock b/tests/negative/model-predicate-signature/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-predicate-signature/project/lexlean.lock +++ b/tests/negative/model-predicate-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-realization-bypass/project/lexlean.lock b/tests/negative/model-realization-bypass/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-realization-bypass/project/lexlean.lock +++ b/tests/negative/model-realization-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unregistered-claim/project/lexlean.lock b/tests/negative/model-unregistered-claim/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-unregistered-claim/project/lexlean.lock +++ b/tests/negative/model-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-boundary/project/lexlean.lock b/tests/negative/model-unvalidated-boundary/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-unvalidated-boundary/project/lexlean.lock +++ b/tests/negative/model-unvalidated-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock +++ b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-vacuous-claim/project/lexlean.lock b/tests/negative/model-vacuous-claim/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-vacuous-claim/project/lexlean.lock +++ b/tests/negative/model-vacuous-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-validator-unsound-statement/project/lexlean.lock b/tests/negative/model-validator-unsound-statement/project/lexlean.lock index 67cf31952d..d2cb753cc5 100644 --- a/tests/negative/model-validator-unsound-statement/project/lexlean.lock +++ b/tests/negative/model-validator-unsound-statement/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-first/project/lexlean.lock b/tests/negative/module-name-dotted-first/project/lexlean.lock index 54adea95bd..9b976a1e85 100644 --- a/tests/negative/module-name-dotted-first/project/lexlean.lock +++ b/tests/negative/module-name-dotted-first/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "95276aad5a2f8e56451e0155187ce36290918ff47f8b6a315a4f65c3bfef9e71" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-last/project/lexlean.lock b/tests/negative/module-name-dotted-last/project/lexlean.lock index 4c8055ab6b..f116cbbd34 100644 --- a/tests/negative/module-name-dotted-last/project/lexlean.lock +++ b/tests/negative/module-name-dotted-last/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "931ec0afb0a76b983ac4c428c862444a84cf5503f5dd3674b7f95f86e20d955e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-lean-namespace/project/lexlean.lock b/tests/negative/module-name-lean-namespace/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/module-name-lean-namespace/project/lexlean.lock +++ b/tests/negative/module-name-lean-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-reserved/project/lexlean.lock b/tests/negative/module-prefix-reserved/project/lexlean.lock index f668896bdf..253165dab5 100644 --- a/tests/negative/module-prefix-reserved/project/lexlean.lock +++ b/tests/negative/module-prefix-reserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "f7e856979b6415eae79efb4ee8e1a5a5611e3cb1fc1c2553b78d9f08be5a55b7" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-shipped-root/project/lexlean.lock b/tests/negative/module-prefix-shipped-root/project/lexlean.lock index f668896bdf..253165dab5 100644 --- a/tests/negative/module-prefix-shipped-root/project/lexlean.lock +++ b/tests/negative/module-prefix-shipped-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "f7e856979b6415eae79efb4ee8e1a5a5611e3cb1fc1c2553b78d9f08be5a55b7" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-target-production/project/lexlean.lock b/tests/negative/module-prefix-target-production/project/lexlean.lock index 492305e57b..ac117cf52c 100644 --- a/tests/negative/module-prefix-target-production/project/lexlean.lock +++ b/tests/negative/module-prefix-target-production/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "d4ba5893c2a056d009d9df7131d82f1a6f3a560659e43ded292d44b5d050ee2b" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock +++ b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-label-shared/project/lexlean.lock b/tests/negative/mutual-label-shared/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/mutual-label-shared/project/lexlean.lock +++ b/tests/negative/mutual-label-shared/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-complement/project/lexlean.lock b/tests/negative/nat-bitwise-complement/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/nat-bitwise-complement/project/lexlean.lock +++ b/tests/negative/nat-bitwise-complement/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock b/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock +++ b/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-production-root/project/lexlean.lock b/tests/negative/nat-bitwise-production-root/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/nat-bitwise-production-root/project/lexlean.lock +++ b/tests/negative/nat-bitwise-production-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock b/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock +++ b/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-ambiguity/project/lexlean.lock b/tests/negative/polymorphic-ambiguity/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/polymorphic-ambiguity/project/lexlean.lock +++ b/tests/negative/polymorphic-ambiguity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-recursion/project/lexlean.lock b/tests/negative/polymorphic-recursion/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/polymorphic-recursion/project/lexlean.lock +++ b/tests/negative/polymorphic-recursion/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/preservation-drift/project/lexlean.lock b/tests/negative/preservation-drift/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/preservation-drift/project/lexlean.lock +++ b/tests/negative/preservation-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-effect-mismatch/project/lexlean.lock b/tests/negative/production-effect-mismatch/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-effect-mismatch/project/lexlean.lock +++ b/tests/negative/production-effect-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-expectation-stale/project/lexlean.lock b/tests/negative/production-expectation-stale/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/production-expectation-stale/project/lexlean.lock +++ b/tests/negative/production-expectation-stale/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-formal-only-dependency/project/lexlean.lock b/tests/negative/production-formal-only-dependency/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-formal-only-dependency/project/lexlean.lock +++ b/tests/negative/production-formal-only-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-hidden-dependency/project/lexlean.lock b/tests/negative/production-hidden-dependency/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-hidden-dependency/project/lexlean.lock +++ b/tests/negative/production-hidden-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-higher-order-escape/project/lexlean.lock b/tests/negative/production-higher-order-escape/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-higher-order-escape/project/lexlean.lock +++ b/tests/negative/production-higher-order-escape/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-literal-width/project/lexlean.lock b/tests/negative/production-literal-width/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-literal-width/project/lexlean.lock +++ b/tests/negative/production-literal-width/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-named-type-boundary/project/lexlean.lock b/tests/negative/production-named-type-boundary/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-named-type-boundary/project/lexlean.lock +++ b/tests/negative/production-named-type-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-package-name-keyword/project/lexlean.lock b/tests/negative/production-package-name-keyword/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/production-package-name-keyword/project/lexlean.lock +++ b/tests/negative/production-package-name-keyword/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-phantom-type-parameter/project/lexlean.lock b/tests/negative/production-phantom-type-parameter/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-phantom-type-parameter/project/lexlean.lock +++ b/tests/negative/production-phantom-type-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-polymorphic-root/project/lexlean.lock b/tests/negative/production-polymorphic-root/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-polymorphic-root/project/lexlean.lock +++ b/tests/negative/production-polymorphic-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-request-malformed/project/lexlean.lock b/tests/negative/production-request-malformed/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/production-request-malformed/project/lexlean.lock +++ b/tests/negative/production-request-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-root-not-executable/project/lexlean.lock b/tests/negative/production-root-not-executable/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-root-not-executable/project/lexlean.lock +++ b/tests/negative/production-root-not-executable/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-root-unknown/project/lexlean.lock b/tests/negative/production-root-unknown/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/production-root-unknown/project/lexlean.lock +++ b/tests/negative/production-root-unknown/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock +++ b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-target-unregistered/project/lexlean.lock b/tests/negative/production-target-unregistered/project/lexlean.lock index 278518efad..b7a47d0bdd 100644 --- a/tests/negative/production-target-unregistered/project/lexlean.lock +++ b/tests/negative/production-target-unregistered/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unbounded-type/project/lexlean.lock b/tests/negative/production-unbounded-type/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-unbounded-type/project/lexlean.lock +++ b/tests/negative/production-unbounded-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-universe-boundary/project/lexlean.lock b/tests/negative/production-universe-boundary/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-universe-boundary/project/lexlean.lock +++ b/tests/negative/production-universe-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unknown-target/project/lexlean.lock b/tests/negative/production-unknown-target/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/production-unknown-target/project/lexlean.lock +++ b/tests/negative/production-unknown-target/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-type/project/lexlean.lock b/tests/negative/reasoning-answer-type/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-answer-type/project/lexlean.lock +++ b/tests/negative/reasoning-answer-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-binder-reserved/project/lexlean.lock b/tests/negative/reasoning-binder-reserved/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-binder-reserved/project/lexlean.lock +++ b/tests/negative/reasoning-binder-reserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock +++ b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock +++ b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock +++ b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock index daf4485b22..6ca3acd91b 100644 --- a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock +++ b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "32962ccccc0e0504497383fdd12cf9f1e761305e58c22fa64cc3776c5fad8c16" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forged-trace/project/lexlean.lock b/tests/negative/reasoning-forged-trace/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-forged-trace/project/lexlean.lock +++ b/tests/negative/reasoning-forged-trace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-formal-rule/project/lexlean.lock b/tests/negative/reasoning-formal-rule/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-formal-rule/project/lexlean.lock +++ b/tests/negative/reasoning-formal-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-claims/project/lexlean.lock b/tests/negative/reasoning-generate-claims/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-generate-claims/project/lexlean.lock +++ b/tests/negative/reasoning-generate-claims/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock +++ b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generator-type/project/lexlean.lock b/tests/negative/reasoning-generator-type/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-generator-type/project/lexlean.lock +++ b/tests/negative/reasoning-generator-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-initial-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-interface-rebound/project/lexlean.lock b/tests/negative/reasoning-interface-rebound/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-interface-rebound/project/lexlean.lock +++ b/tests/negative/reasoning-interface-rebound/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock +++ b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-invariant-signature/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock +++ b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-no-rules/project/lexlean.lock b/tests/negative/reasoning-no-rules/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-no-rules/project/lexlean.lock +++ b/tests/negative/reasoning-no-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock +++ b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-type/project/lexlean.lock b/tests/negative/reasoning-observation-type/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-observation-type/project/lexlean.lock +++ b/tests/negative/reasoning-observation-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-opaque-member/project/lexlean.lock b/tests/negative/reasoning-opaque-member/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-opaque-member/project/lexlean.lock +++ b/tests/negative/reasoning-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-ranking-signature/project/lexlean.lock b/tests/negative/reasoning-ranking-signature/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-ranking-signature/project/lexlean.lock +++ b/tests/negative/reasoning-ranking-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock +++ b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-signature/project/lexlean.lock b/tests/negative/reasoning-relation-signature/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-relation-signature/project/lexlean.lock +++ b/tests/negative/reasoning-relation-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass/project/lexlean.lock b/tests/negative/reasoning-rule-bypass/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-bypass/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-specification-signature/project/lexlean.lock b/tests/negative/reasoning-specification-signature/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-specification-signature/project/lexlean.lock +++ b/tests/negative/reasoning-specification-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminating-search/project/lexlean.lock b/tests/negative/reasoning-terminating-search/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-terminating-search/project/lexlean.lock +++ b/tests/negative/reasoning-terminating-search/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-rule/project/lexlean.lock b/tests/negative/reasoning-unknown-rule/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-unknown-rule/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unverified-answer/project/lexlean.lock b/tests/negative/reasoning-unverified-answer/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-unverified-answer/project/lexlean.lock +++ b/tests/negative/reasoning-unverified-answer/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-signature/project/lexlean.lock b/tests/negative/reasoning-verifier-signature/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-verifier-signature/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-zero-frontier/project/lexlean.lock b/tests/negative/reasoning-zero-frontier/project/lexlean.lock index 5e2b02a814..2f726f6f6b 100644 --- a/tests/negative/reasoning-zero-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-zero-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-cyclic-measure/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock +++ b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-false-evidence/project/lexlean.lock b/tests/negative/recursion-false-evidence/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-false-evidence/project/lexlean.lock +++ b/tests/negative/recursion-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-forged-evidence/project/lexlean.lock b/tests/negative/recursion-forged-evidence/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-forged-evidence/project/lexlean.lock +++ b/tests/negative/recursion-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-member-under-lambda/project/lexlean.lock b/tests/negative/recursion-member-under-lambda/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-member-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-member-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-case/project/lexlean.lock b/tests/negative/recursion-missing-case/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-missing-case/project/lexlean.lock +++ b/tests/negative/recursion-missing-case/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-evidence/project/lexlean.lock b/tests/negative/recursion-missing-evidence/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-missing-evidence/project/lexlean.lock +++ b/tests/negative/recursion-missing-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mixed-families/project/lexlean.lock b/tests/negative/recursion-mixed-families/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-mixed-families/project/lexlean.lock +++ b/tests/negative/recursion-mixed-families/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock +++ b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock +++ b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-mixed/project/lexlean.lock b/tests/negative/recursion-mutual-mixed/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-mutual-mixed/project/lexlean.lock +++ b/tests/negative/recursion-mutual-mixed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-nondecreasing/project/lexlean.lock b/tests/negative/recursion-nondecreasing/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-nondecreasing/project/lexlean.lock +++ b/tests/negative/recursion-nondecreasing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-under-lambda/project/lexlean.lock b/tests/negative/recursion-under-lambda/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-well-founded-reference/project/lexlean.lock b/tests/negative/recursion-well-founded-reference/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-well-founded-reference/project/lexlean.lock +++ b/tests/negative/recursion-well-founded-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-wrong-argument/project/lexlean.lock b/tests/negative/recursion-wrong-argument/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursion-wrong-argument/project/lexlean.lock +++ b/tests/negative/recursion-wrong-argument/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock +++ b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock +++ b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-structure/project/lexlean.lock b/tests/negative/recursive-structure/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-structure/project/lexlean.lock +++ b/tests/negative/recursive-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-arguments/project/lexlean.lock b/tests/negative/recursive-type-arguments/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-type-arguments/project/lexlean.lock +++ b/tests/negative/recursive-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-forward/project/lexlean.lock b/tests/negative/recursive-type-forward/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-type-forward/project/lexlean.lock +++ b/tests/negative/recursive-type-forward/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-nonuniform/project/lexlean.lock b/tests/negative/recursive-type-nonuniform/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-type-nonuniform/project/lexlean.lock +++ b/tests/negative/recursive-type-nonuniform/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-positivity/project/lexlean.lock b/tests/negative/recursive-type-positivity/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-type-positivity/project/lexlean.lock +++ b/tests/negative/recursive-type-positivity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-uninhabited/project/lexlean.lock b/tests/negative/recursive-type-uninhabited/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/recursive-type-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-type-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock +++ b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definition-absent/project/lexlean.lock b/tests/negative/term-cases-definition-absent/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/term-cases-definition-absent/project/lexlean.lock +++ b/tests/negative/term-cases-definition-absent/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definition-repeated/project/lexlean.lock b/tests/negative/term-cases-definition-repeated/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/term-cases-definition-repeated/project/lexlean.lock +++ b/tests/negative/term-cases-definition-repeated/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock b/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock +++ b/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-empty-definitions/project/lexlean.lock b/tests/negative/term-cases-empty-definitions/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/term-cases-empty-definitions/project/lexlean.lock +++ b/tests/negative/term-cases-empty-definitions/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-reserved-name/project/lexlean.lock b/tests/negative/term-cases-reserved-name/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/term-cases-reserved-name/project/lexlean.lock +++ b/tests/negative/term-cases-reserved-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock b/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock +++ b/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/text-window-zero-capacity/project/lexlean.lock b/tests/negative/text-window-zero-capacity/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/text-window-zero-capacity/project/lexlean.lock +++ b/tests/negative/text-window-zero-capacity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/tooling-module-in-user-project/project/lexlean.lock b/tests/negative/tooling-module-in-user-project/project/lexlean.lock index 1c15732a9d..f1ef8c43b4 100644 --- a/tests/negative/tooling-module-in-user-project/project/lexlean.lock +++ b/tests/negative/tooling-module-in-user-project/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "238e7aca6dbdb072aca261449c9bd60440763fbf9d421fdde4d29f286ff968b4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-argument-universe/project/lexlean.lock b/tests/negative/type-argument-universe/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/type-argument-universe/project/lexlean.lock +++ b/tests/negative/type-argument-universe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-parameter-capture/project/lexlean.lock b/tests/negative/type-parameter-capture/project/lexlean.lock index 4bc29873a2..253165dab5 100644 --- a/tests/negative/type-parameter-capture/project/lexlean.lock +++ b/tests/negative/type-parameter-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/preservation-certificates/lists/lexlean.lock b/tests/preservation-certificates/lists/lexlean.lock index f01479b57d..541498706c 100644 --- a/tests/preservation-certificates/lists/lexlean.lock +++ b/tests/preservation-certificates/lists/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "2dc372130a18e781ddded01cec4b998ca72fc64e03821c32d166d926f1747167" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/rust-backend/loop-ends/lexlean.lock b/tests/rust-backend/loop-ends/lexlean.lock index a9ff2eb1a7..5a02cf68a6 100644 --- a/tests/rust-backend/loop-ends/lexlean.lock +++ b/tests/rust-backend/loop-ends/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "2e4c0ddd6084eba8fa99f04ab0235bfc5775dbc0455216b6ec51abe8ce8d9750" +compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" project_config_sha256 = "3e4158ef82c9e0076571d311f038e86f002adf3e8285a7292c835b07f5a45c65" lean_toolchain = "leanprover/lean4:v4.32.1" From 6a7668285b34ea99f8b32f5cf743b44b07a1c505 Mon Sep 17 00:00:00 2001 From: Alexander Flom Date: Fri, 13 Nov 2026 02:36:17 +0000 Subject: [PATCH 6/6] Admit closed UTF-8 proof bridges in language 1.2 --- CONFORMANCE.md | 1 + SPEC.md | 5 +- VERIFICATION.md | 13 +++ bootstrap/lexlean.lock | 2 +- compiler/lexlean.lock | 2 +- crates/conformance/src/cases/semantic_ir.rs | 2 + .../src/cases/semantic_ir/utf8_bridge.rs | 90 +++++++++++++++++++ crates/conformance/tests/conformance.rs | 5 ++ crates/lexlean/src/backend/semantic.rs | 24 ++++- crates/lexlean/src/ir/semantic.rs | 14 ++- examples/collections/lexlean.lock | 2 +- examples/fold-laws/lexlean.lock | 2 +- examples/helpdesk/lexlean.lock | 2 +- examples/higher-order/lexlean.lock | 2 +- examples/language-1.2/lexlean.lock | 2 +- examples/models/lexlean.lock | 2 +- examples/performance-corpus/lexlean.lock | 2 +- examples/production-coverage/lexlean.lock | 2 +- examples/production/lexlean.lock | 2 +- examples/reasoning/lexlean.lock | 2 +- examples/recursion/lexlean.lock | 2 +- examples/recursive-data/lexlean.lock | 2 +- features/suites/semantic-ir.feature | 8 ++ kappa/lexlean.lock | 2 +- language/semantics-1.2.toml | 4 +- model/ids.toml | 6 ++ spec/lexlean.lock | 2 +- spec/src/Chapter17.lex.tex | 2 +- spec/src/IdsSM.lex.tex | 7 ++ std-models/lexlean.lock | 2 +- std-reasoning/lexlean.lock | 2 +- stdlib/lexlean.lock | 2 +- tests/fixtures/command-driver/lexlean.lock | 2 +- tests/fixtures/host-effects/lexlean.lock | 2 +- .../application-arity/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../binder-capture/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../cases-bool-induction/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../certificate-rejected/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../escaping-closure/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../extraction-rejected/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../graph-duplicate-edge/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lambda-capture-extra/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lambda-type-mismatch/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lowering-depth-limit/project/lexlean.lock | 2 +- .../lowering-size-limit/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-false-evidence/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-missing-entry/project/lexlean.lock | 2 +- .../model-opaque-member/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../model-vacuous-claim/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../mutual-label-shared/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../preservation-drift/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../reasoning-no-rules/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../recursive-structure/project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../project/lexlean.lock | 2 +- .../lists/lexlean.lock | 2 +- tests/rust-backend/loop-ends/lexlean.lock | 2 +- 282 files changed, 440 insertions(+), 279 deletions(-) create mode 100644 crates/conformance/src/cases/semantic_ir/utf8_bridge.rs diff --git a/CONFORMANCE.md b/CONFORMANCE.md index b6fa6387f8..e6ae98e911 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -626,6 +626,7 @@ the error registry does not sanction (R5, `ERRORS.md`). | `SM-35` | `build` | A language-1.2 theorem may be proved by `term_cases`, a split on the value of a document term: the proof names a term and a nonempty, strictly sorted, duplicate-free list of prior document definitions, the term's type is an inductive type of the document, and the backend lowers the proof to a split of the goal on every constructor of that type with the hypothesis that equates the term to the constructor, then `simp only` over the named definitions, that hypothesis, the reduction of a conditional on a decided condition, the refutation of an equation between two different constructors, the injectivity equation of every constructor with a field of `Option`, `Result`, `List`, and each inductive type the module declares, and the fixed rules that close an implication from `False` or of a proposition by itself and drop `True` from a conjunction, with closed propositions decided, which uses exactly the axioms the theorem's policy states, so a theorem whose cases need constructor disjointness or injectivity verifies and a false one is rejected by Lean; the schema, the linker, the notation, the Lean backend, the canonical LaTeX, and the formatter accept it, and a use in language 1.1, a term whose type is not an inductive type of the document, an empty list, an unsorted or repeated name, a name that is not a prior definition, and a theorem parameter that takes the hypothesis's name are each refused. | | `SM-36` | `build` | A language-1.2 `cases` proof may split a local of type `Bool` into its two constructors: the proof names the local and gives a branch for `false` and one for `true`, each with no binders, the backend lowers it to `cases` on the local with those two alternatives, the theorem verifies with exactly the axioms its policy states, and the schema, the linker, the notation, the formatter, and the canonical LaTeX accept it; a use in language 1.1, a missing branch, a repeated branch, a branch with a binder, and an `induction` on a Boolean are each refused. | | `SM-38` | `build` | A language-1.2 definition may apply bit_and, bit_or and bit_xor to two Nat operands and shift_left and shift_right to a Nat operand and a Nat amount, each with result Nat and no Option, and the backend lowers them to Nat.land, Nat.lor, Nat.xor, Nat.shiftLeft and Nat.shiftRight, so that reflexivity evaluates them inside a verified module; the registered laws nat_bit_and, nat_bit_or, nat_bit_xor, nat_bit_shift_left, nat_bit_shift_right, nat_or_xor_and, nat_witt_step and nat_bit_ext state the bit read of each under an exact axiom policy, and a theorem that applies one verifies while a false bit equation is rejected; a use in language 1.1, bit_not of a Nat, a Nat operand mixed with an integer of another type, and a production root over a Nat form are each refused. | +| `SM-39` | `build` | Language 1.2 simplify proofs may name exactly LexLeanRuntime.utf8Encode and String.toUTF8_eq_toByteArray as UTF-8 bridges; these names resolve to fixed global declarations and select simp only followed by reflexivity on remaining goals, preserving historical simplify lowering, while literal UTF-8 equalities verify with exact axioms and false equalities, language 1.1 uses, foreign helpers, and malformed name lists are refused. | ## stdlib diff --git a/SPEC.md b/SPEC.md index e0d1191311..69979f9d85 100644 --- a/SPEC.md +++ b/SPEC.md @@ -2699,7 +2699,7 @@ or document-inductive local; their constructor set and pattern-binder arities are checked exactly before rendering. Induction may carry a strictly sorted, unique list of other in-scope theorem parameters to generalize; the scrutinee cannot be generalized. Every simplification name resolves -to one of those closed choices. An axiom-free `boolean_reflection` proof is +to one of those closed choices. Language 1.2 additionally admits exactly the global names `LexLeanRuntime.utf8Encode` and `String.toUTF8_eq_toByteArray` in a simplify list. A proof naming either UTF-8 bridge lowers to `simp only` over the named definitions followed by `rfl` on every remaining goal; these helpers are emitted with the root namespace so document qualification cannot capture them. This fixed recipe lets the kernel reduce literal byte-array projections after the pinned String representation theorem rewrites the non-exposed UTF-8 operation. It adds no arbitrary helper, tactic payload, or proof sequence syntax. Language 1.1 rejects both names, and simplify proofs without them keep their existing lowering. An axiom-free `boolean_reflection` proof is available only in two validated generic shapes: structural `List Nat` recursion that reflects `Nat.beq` or `Nat.blt` into an independently recursive proposition, and a finite structure @@ -11057,6 +11057,7 @@ Every row below is normative, has honesty level `build`, and is projected byte-f | `SM-35` | `semantic-ir` | A language-1.2 theorem may be proved by `term_cases`, a split on the value of a document term: the proof names a term and a nonempty, strictly sorted, duplicate-free list of prior document definitions, the term's type is an inductive type of the document, and the backend lowers the proof to a split of the goal on every constructor of that type with the hypothesis that equates the term to the constructor, then `simp only` over the named definitions, that hypothesis, the reduction of a conditional on a decided condition, the refutation of an equation between two different constructors, the injectivity equation of every constructor with a field of `Option`, `Result`, `List`, and each inductive type the module declares, and the fixed rules that close an implication from `False` or of a proposition by itself and drop `True` from a conjunction, with closed propositions decided, which uses exactly the axioms the theorem's policy states, so a theorem whose cases need constructor disjointness or injectivity verifies and a false one is rejected by Lean; the schema, the linker, the notation, the Lean backend, the canonical LaTeX, and the formatter accept it, and a use in language 1.1, a term whose type is not an inductive type of the document, an empty list, an unsorted or repeated name, a name that is not a prior definition, and a theorem parameter that takes the hypothesis's name are each refused. | §17.10 | | `SM-36` | `semantic-ir` | A language-1.2 `cases` proof may split a local of type `Bool` into its two constructors: the proof names the local and gives a branch for `false` and one for `true`, each with no binders, the backend lowers it to `cases` on the local with those two alternatives, the theorem verifies with exactly the axioms its policy states, and the schema, the linker, the notation, the formatter, and the canonical LaTeX accept it; a use in language 1.1, a missing branch, a repeated branch, a branch with a binder, and an `induction` on a Boolean are each refused. | §17.10 | | `SM-38` | `semantic-ir` | A language-1.2 definition may apply bit_and, bit_or and bit_xor to two Nat operands and shift_left and shift_right to a Nat operand and a Nat amount, each with result Nat and no Option, and the backend lowers them to Nat.land, Nat.lor, Nat.xor, Nat.shiftLeft and Nat.shiftRight, so that reflexivity evaluates them inside a verified module; the registered laws nat_bit_and, nat_bit_or, nat_bit_xor, nat_bit_shift_left, nat_bit_shift_right, nat_or_xor_and, nat_witt_step and nat_bit_ext state the bit read of each under an exact axiom policy, and a theorem that applies one verifies while a false bit equation is rejected; a use in language 1.1, bit_not of a Nat, a Nat operand mixed with an integer of another type, and a production root over a Nat form are each refused. | §17.11, §17.12 | +| `SM-39` | `semantic-ir` | Language 1.2 simplify proofs may name exactly LexLeanRuntime.utf8Encode and String.toUTF8_eq_toByteArray as UTF-8 bridges; these names resolve to fixed global declarations and select simp only followed by reflexivity on remaining goals, preserving historical simplify lowering, while literal UTF-8 equalities verify with exact axioms and false equalities, language 1.1 uses, foreign helpers, and malformed name lists are refused. | §17.10 | | `DF-01` | `declarations` | A valid type-definition sentence emits one nonrecursive sort-valued Lean def linked to its document entry. | §15.7, §18.6 | | `DF-02` | `declarations` | A valid term-definition sentence emits one nonrecursive explicitly typed Lean def. | §15.7, §18.6 | | `DF-03` | `declarations` | A valid predicate-definition sentence emits one nonrecursive Prop-valued Lean def. | §15.7, §18.6 | @@ -11424,7 +11425,7 @@ Every row below is normative, has honesty level `build`, and is projected byte-f | `NS-06` | `normative-source` | The hand-edited normative inputs of the repository are the `.lex.tex` modules of the specification project: `model/` holds only the projected files and the copies an authority row vendors, every Markdown file at the root is a projection or is on the closed list of hand-written documents, the projections carry the notice that names their source, and no hand-written document restates a registered statement, a plant of each being refused naming R1. | §27.2, §27.5, §27.10 | | `NS-07` | `normative-source` | `cargo xtask spec` changes the chapter modules of the specification project by item: it replaces a block, inserts one after a block, and ports the hunks of a merged SPEC.md that lie outside derived regions, each through the authoring SDK, and it writes nothing unless the regenerated SPEC.md equals the intended text outside derived regions, refusing a first line that matches no block or two and a hunk that spans two blocks. | §24.8, §27.5 | -**Total required capability IDs:** 487. +**Total required capability IDs:** 488. No row may be downgraded to `some-true` or `open`. Upstream Lean facts are ledger/authority rows, not substitutions for these build behaviors. diff --git a/VERIFICATION.md b/VERIFICATION.md index b564700e16..d07ab25351 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -39,6 +39,19 @@ Outside `vv`: ## Falsifiability records +### UTF-8 proof bridges remain closed + +Compiler `40200f4dd5` rejected a semantic theorem equating +`utf8_encode "problem1"` with its literal bytes: the linker reported +`LLT4001` for the unavailable `LexLeanRuntime.utf8Encode` simplification name. +Pinned Lean 4.32.1 required its explicit String representation theorem and +reflexivity after simplification to discharge the same literal equality. +`conformance_sm_39` exercises the fixed language-1.2 recipe on empty, ASCII, +and multibyte strings, rejects a false byte equality through verification, +and refuses foreign helper names, malformed lists, and language-1.1 uses. +The recipe names only the two admitted global helpers and does not expose +general tactic sequencing or change historical simplify output. + ### absent inspection origins remain unavailable The mixed `True`, absent-name, `Eq.refl` case in `conformance_vr_28` initially diff --git a/bootstrap/lexlean.lock b/bootstrap/lexlean.lock index ec4a540ae3..6895f792f0 100644 --- a/bootstrap/lexlean.lock +++ b/bootstrap/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "0c4d63390a1e570e10cedd50676c168b7564dd04189879bd13e36176d58f22fb" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/compiler/lexlean.lock b/compiler/lexlean.lock index 340ee7533f..a80944dafe 100644 --- a/compiler/lexlean.lock +++ b/compiler/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "ef58478b65de0ad784269ab3513059f5afbb7f461bda9476efce78344301755e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/crates/conformance/src/cases/semantic_ir.rs b/crates/conformance/src/cases/semantic_ir.rs index a466aab976..5302d612ac 100644 --- a/crates/conformance/src/cases/semantic_ir.rs +++ b/crates/conformance/src/cases/semantic_ir.rs @@ -12,6 +12,7 @@ mod bytes; mod names; mod nat_bitwise; mod strings; +mod utf8_bridge; mod widen; /// Closed recursive decisions must use Lean's sharing kernel evaluator. @@ -2646,6 +2647,7 @@ pub(crate) fn run(id: &str) { "SM-36" => boolean::run(), // §17.11, §17.12: bitwise primitives and shifts on unbounded Nat. "SM-38" => nat_bitwise::run(), + "SM-39" => utf8_bridge::run(), // §17.10: a theorem proved by a split on the value of a document // term. "SM-35" => { diff --git a/crates/conformance/src/cases/semantic_ir/utf8_bridge.rs b/crates/conformance/src/cases/semantic_ir/utf8_bridge.rs new file mode 100644 index 0000000000..2485d62347 --- /dev/null +++ b/crates/conformance/src/cases/semantic_ir/utf8_bridge.rs @@ -0,0 +1,90 @@ +//! SM-39: fixed UTF-8 simplification bridges, without open proof syntax. + +use crate::support::{self, P}; + +const BRIDGES: &str = "LexLeanRuntime.utf8Encode, String.toUTF8_eq_toByteArray"; + +fn source(bridges: &str, wrong: bool) -> String { + let mut declarations = String::new(); + for (index, (text, bytes)) in [ + ("", ""), + ("problem1", "70726f626c656d31"), + ("é😀", "c3a9f09f9880"), + ] + .into_iter() + .enumerate() + { + let literal = serde_json::to_string(text).expect("string literal"); + let bytes = if wrong && index == 1 { "00" } else { bytes }; + declarations.push_str(&format!( + "theorem{{name: literal{index}, parameters: [], statement: ((prim utf8_encode {literal} : Bytes) = 0x{bytes}), proof: simplify{{definitions: [{bridges}]}}, axioms: []}}\n" + )); + } + format!( + "\\begin{{lexlean}}{{Main}}\n\\useglossary{{lexlean.std.nat@1.2.0}}\n\\title{{Natural number addition}}\n\\begin{{semanticmodule}}\n{declarations}definition{{name: natural, parameters: [], result: Nat, body: 0}}\ntheorem{{name: naturalSame, parameters: [], statement: ((natural) = 0), proof: simplify{{definitions: [natural]}}, axioms: [propext]}}\n\\end{{semanticmodule}}\n\\end{{lexlean}}\n" + ) +} + +fn project(text: &str, language: &str) -> P { + let project = P::example(); + project.edit( + "lexlean.toml", + "language = \"1.0\"", + &format!("language = \"{language}\""), + ); + project.write("src/Main.lex.tex", text); + project.relock(); + project +} + +pub fn run() { + let accepted = project(&source(BRIDGES, false), "1.2"); + accepted.check_ok(); + let (exit, _, errors) = accepted.cli(&["fmt"]); + assert_eq!(exit, 0, "{errors}"); + accepted.fmt_check_ok(); + let formatted = accepted.read("src/Main.lex.tex"); + let built = accepted.build_ok(); + let lean = std::fs::read_to_string( + accepted + .build_dir(&built.build_id.expect("build identity")) + .join("modules/LexLeanExample/Main.lean"), + ) + .expect("generated module"); + assert_eq!(lean.matches("simp only [_root_.LexLeanRuntime.utf8Encode, _root_.String.toUTF8_eq_toByteArray] <;> rfl").count(), 3); + assert!( + lean.contains("simp only [natural]\n"), + "historical simplify changed: {lean}" + ); + support::verify_ok_backed("SM-39", &accepted); + + for names in [ + "String.toUTF8", + "LexLeanRuntime.utf8Encode, String.toUTF8_eq_toByteArray, String.toUTF8_eq_toByteArray", + "String.toUTF8_eq_toByteArray, LexLeanRuntime.utf8Encode", + "", + ] { + let refused = project(&source(names, false), "1.2"); + let error = refused.check_err(); + support::expect_code(&error, "LLT4001"); + } + let old = project( + &formatted + .replace("@1.2.0", "@1.1.0") + .replace("lexlean/semantic-module/2", "lexlean/semantic-module/1"), + "1.1", + ); + support::expect_code(&old.check_err(), "LLT4001"); + + for name in ["LexLeanRuntime.utf8Encode", "String.toUTF8_eq_toByteArray"] { + let shadow = source(BRIDGES, false).replace("name: natural,", &format!("name: {name},")); + let error = project(&shadow, "1.2").check_err(); + assert!(format!("{error:?}").contains("reserved"), "{error:?}"); + } + + let false_equality = project(&source(BRIDGES, true), "1.2"); + false_equality.check_ok(); + if support::lean_backed("SM-39") { + false_equality.verify_fails_with("LLV7002"); + } +} diff --git a/crates/conformance/tests/conformance.rs b/crates/conformance/tests/conformance.rs index decd9b8337..93135d022c 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -605,6 +605,11 @@ fn conformance_sm_38() { repo_conformance::cases::run("SM-38"); } +#[test] +fn conformance_sm_39() { + repo_conformance::cases::run("SM-39"); +} + #[test] fn conformance_sm_32() { repo_conformance::cases::run("SM-32"); diff --git a/crates/lexlean/src/backend/semantic.rs b/crates/lexlean/src/backend/semantic.rs index 7e48063fbe..8ea1b76818 100644 --- a/crates/lexlean/src/backend/semantic.rs +++ b/crates/lexlean/src/backend/semantic.rs @@ -21,6 +21,7 @@ mod reasoning; struct Render<'a> { prefix: &'a str, + language_1_2: bool, /// The Lean module each imported module's key names; a module not in it /// lies under `prefix` (§10.5). lean_imports: &'a std::collections::BTreeMap, @@ -747,6 +748,7 @@ impl Render<'_> { fn cross_check(&self, check: &CrossCheck, module: &str) -> String { let qualified = Render { prefix: self.prefix, + language_1_2: self.language_1_2, lean_imports: self.lean_imports, hypotheses: std::collections::BTreeMap::new(), document: false, @@ -1243,12 +1245,23 @@ impl Render<'_> { linear_arithmetic(&pad, &unfolded) } SemanticProof::Simplify { definitions } => format!( - "{pad}simp only [{}]\n", + "{pad}simp only [{}]{}\n", definitions .iter() - .map(|member| self.member(member)) + .map(|member| { + if self.language_1_2 && crate::ir::semantic::is_utf8_simplify_bridge(member) { + format!("_root_.{}", identifier(&member.name)) + } else { + self.member(member) + } + }) .collect::>() - .join(", ") + .join(", "), + if self.language_1_2 && definitions.iter().any(crate::ir::semantic::is_utf8_simplify_bridge) { + " <;> rfl" + } else { + "" + } ), SemanticProof::Constructor { branches } => { let mut out = format!("{pad}constructor\n"); @@ -1549,6 +1562,7 @@ fn well_founded_definition( })?; let render = Render { prefix: base.prefix, + language_1_2: base.language_1_2, lean_imports: base.lean_imports, hypotheses: plan .addresses @@ -1973,6 +1987,7 @@ pub fn render_lean( .collect(); let base_render = Render { prefix: module_prefix, + language_1_2: module.spec == "lexlean/semantic-module/2", lean_imports: &document.import_lean, hypotheses: std::collections::BTreeMap::new(), document: false, @@ -1984,6 +1999,7 @@ pub fn render_lean( // reference it makes is written qualified (§17.12, models). let model_render = Render { prefix: module_prefix, + language_1_2: module.spec == "lexlean/semantic-module/2", lean_imports: &document.import_lean, hypotheses: std::collections::BTreeMap::new(), document: false, @@ -3141,6 +3157,7 @@ pub fn render_latex( ) -> Result { let render = Render { prefix: module_prefix, + language_1_2: module.spec == "lexlean/semantic-module/2", lean_imports: &checked.document.import_lean, hypotheses: std::collections::BTreeMap::new(), document: true, @@ -3380,6 +3397,7 @@ mod byte_literal_tests { let imports = std::collections::BTreeMap::new(); Render { prefix: "ByteFixture", + language_1_2: false, lean_imports: &imports, hypotheses: std::collections::BTreeMap::new(), document, diff --git a/crates/lexlean/src/ir/semantic.rs b/crates/lexlean/src/ir/semantic.rs index c47564d9be..37d227e1a4 100644 --- a/crates/lexlean/src/ir/semantic.rs +++ b/crates/lexlean/src/ir/semantic.rs @@ -4061,6 +4061,15 @@ fn check_member(member: &MemberRef, env: &Environment<'_>) -> Result<(), String> Ok(()) } +/// The fixed UTF-8 proof bridges admitted by language 1.2 (§17.10). +pub(crate) fn is_utf8_simplify_bridge(member: &MemberRef) -> bool { + member.module.is_none() + && matches!( + member.name.as_str(), + "LexLeanRuntime.utf8Encode" | "String.toUTF8_eq_toByteArray" + ) +} + fn check_type(ty: &SemanticType, env: &Environment<'_>) -> Result<(), String> { match ty { SemanticType::Type @@ -8529,11 +8538,12 @@ fn check_proof( let mut previous = None; for definition in definitions { check_member(definition, env)?; - let builtin_bridge = definition.module.is_none() + let builtin_bridge = (definition.module.is_none() && matches!( definition.name.as_str(), "Bool.and_eq_true" | "Nat.beq_eq" | "Nat.blt_eq" - ); + )) + || (env.language_1_2 && is_utf8_simplify_bridge(definition)); let local_hypothesis = definition.module.is_none() && locals.get(&definition.name) == Some(&SemanticType::Prop); if function_info(definition, env).is_none() diff --git a/examples/collections/lexlean.lock b/examples/collections/lexlean.lock index 6b70150fb1..6ea19dd2d0 100644 --- a/examples/collections/lexlean.lock +++ b/examples/collections/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "902cce2e0ccf037e4769589b7b9af2aac26250c50181b306fecec9028e2a63ff" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/fold-laws/lexlean.lock b/examples/fold-laws/lexlean.lock index d7918ecb4c..926abd3146 100644 --- a/examples/fold-laws/lexlean.lock +++ b/examples/fold-laws/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "5d2c8a2881629ee86d82b9e70a1be6fff2518c562d5ca6f45dea96d41edbc005" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/helpdesk/lexlean.lock b/examples/helpdesk/lexlean.lock index ae5d1a43e5..e52cf58af6 100644 --- a/examples/helpdesk/lexlean.lock +++ b/examples/helpdesk/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "30e9380b31a91b74c3c02f5882a9070290c6a5c41e1dd3bf56d9c617396343e7" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/higher-order/lexlean.lock b/examples/higher-order/lexlean.lock index 26a6968f19..a79aa35ae6 100644 --- a/examples/higher-order/lexlean.lock +++ b/examples/higher-order/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "2854e1de7560697fdce6b84ea09e897fa3936fd6c0fbca153d62201ce8ed4d61" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/language-1.2/lexlean.lock b/examples/language-1.2/lexlean.lock index d3a6820c44..08a4bd077b 100644 --- a/examples/language-1.2/lexlean.lock +++ b/examples/language-1.2/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "83557b5053642ede054857828d95f4c17d6d6e14fab13f017a7feb166bd89c0f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/models/lexlean.lock b/examples/models/lexlean.lock index 65b685db53..089e476c96 100644 --- a/examples/models/lexlean.lock +++ b/examples/models/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b79e1070aab27c02ec4396ee66aa4bad7b90f9bca923932529eb9eb26264761a" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/performance-corpus/lexlean.lock b/examples/performance-corpus/lexlean.lock index 39b3336837..f87c9edbe7 100644 --- a/examples/performance-corpus/lexlean.lock +++ b/examples/performance-corpus/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "f94da2d4131decea3a9f53124824e0d81f88c75fefbe62fa443d3203e84a9b39" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production-coverage/lexlean.lock b/examples/production-coverage/lexlean.lock index 249825381e..64f432b0a2 100644 --- a/examples/production-coverage/lexlean.lock +++ b/examples/production-coverage/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "8c8f206d89e67b327167aecf57185e532cb99e5ebda5aa538d04fce39951f22e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/production/lexlean.lock b/examples/production/lexlean.lock index 3cece3e15e..f71ddfae89 100644 --- a/examples/production/lexlean.lock +++ b/examples/production/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "f2cbda9bf591701cef68498eabd2f96cf838e61cca5c7193c83c78d7fce1560f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/reasoning/lexlean.lock b/examples/reasoning/lexlean.lock index 17b8fa38f9..77bd511bcb 100644 --- a/examples/reasoning/lexlean.lock +++ b/examples/reasoning/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "254deddb728df2532affa57ca92fefae0324c34d616c713273d63bd4cccbb2bf" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursion/lexlean.lock b/examples/recursion/lexlean.lock index 8c84734388..0a4ed52433 100644 --- a/examples/recursion/lexlean.lock +++ b/examples/recursion/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "92ff94a2dc1a550b8d47ebdd8b8e9b9d89371435ef550e661022fe74cf51594d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/examples/recursive-data/lexlean.lock b/examples/recursive-data/lexlean.lock index 8be4bcf862..e2cc637cb1 100644 --- a/examples/recursive-data/lexlean.lock +++ b/examples/recursive-data/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "1642b5144f8137f7c2f980a40564f8bcd579515bbb15411ada96c9e513ba0499" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/features/suites/semantic-ir.feature b/features/suites/semantic-ir.feature index a10080c945..c11d819932 100644 --- a/features/suites/semantic-ir.feature +++ b/features/suites/semantic-ir.feature @@ -2,6 +2,14 @@ Feature: semantic-ir Compiler phases, closed IR variants, conservative elaboration, and content identity (§17, §21). + @SM-39 @build + Scenario: Language 1.2 simplify proofs may name exactly LexLeanRuntime.utf8Encode and String.toUTF8_eq_toByteArray as UTF-8 bridges; these names resolve to fixed global declarations and select simp only followed by reflexivity on remaining goals, preserving historical simplify lowering, while literal UTF-8 equalities verify with exact axioms and false equalities, language 1.1 uses, foreign helpers, and malformed name lists are refused. + Given semantic UTF-8 equalities for empty, ASCII and multibyte strings with the two fixed bridge names + When the project is linked, formatted, built and verified with pinned Lean + Then the bridge proofs use fixed global names and kernel-checked simplification followed by reflexivity + And a false equality fails verification while unavailable helpers and malformed name lists fail linking + And language 1.1 rejects the bridges and historical simplify proofs retain their generated text + @SM-01 @build Scenario: Compiler phases execute in the required order and no backend receives an unlinked or ambiguous program. Given the example project with a tab and the unknown word `banana` both inserted into the theorem statement diff --git a/kappa/lexlean.lock b/kappa/lexlean.lock index b840f6ff6b..c11b188c3b 100644 --- a/kappa/lexlean.lock +++ b/kappa/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b5a7664cf56fe322a652d657d726eaea2f825b6130260db1c8e7d6ed8961d4da" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/language/semantics-1.2.toml b/language/semantics-1.2.toml index 52899296e3..1310c63381 100644 --- a/language/semantics-1.2.toml +++ b/language/semantics-1.2.toml @@ -10,8 +10,8 @@ rust_backend = "4" rust_runtime_core = "f3c11eef9db0785d5d20c987c971a7b4fc5f6d187f60082f8982d3d33dd76408" rust_renderer = "a24f0546f398576cd7bf755dd5953be17db6f418cae95ae4bf40e7c1b5a53be8" rust_runtime_std = "72477f9e44fe54531b9c68f2b547db7300563373df9d8d29fa5632b8a9d7c14c" -semantic_ir = "15" +semantic_ir = "16" semantic_snapshot = "2" -proof_lowering = "3" +proof_lowering = "4" axiom_parser = "lean-4.32.1/2" canonical_json = "1" diff --git a/model/ids.toml b/model/ids.toml index eceb6c334c..a0e5825a98 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -736,6 +736,12 @@ level = "build" suite = "semantic-ir" statement = "A language-1.2 definition may apply bit_and, bit_or and bit_xor to two Nat operands and shift_left and shift_right to a Nat operand and a Nat amount, each with result Nat and no Option, and the backend lowers them to Nat.land, Nat.lor, Nat.xor, Nat.shiftLeft and Nat.shiftRight, so that reflexivity evaluates them inside a verified module; the registered laws nat_bit_and, nat_bit_or, nat_bit_xor, nat_bit_shift_left, nat_bit_shift_right, nat_or_xor_and, nat_witt_step and nat_bit_ext state the bit read of each under an exact axiom policy, and a theorem that applies one verifies while a false bit equation is rejected; a use in language 1.1, bit_not of a Nat, a Nat operand mixed with an integer of another type, and a production root over a Nat form are each refused." +[[id]] +id = "SM-39" +level = "build" +suite = "semantic-ir" +statement = "Language 1.2 simplify proofs may name exactly LexLeanRuntime.utf8Encode and String.toUTF8_eq_toByteArray as UTF-8 bridges; these names resolve to fixed global declarations and select simp only followed by reflexivity on remaining goals, preserving historical simplify lowering, while literal UTF-8 equalities verify with exact axioms and false equalities, language 1.1 uses, foreign helpers, and malformed name lists are refused." + [[id]] id = "DF-01" level = "build" diff --git a/spec/lexlean.lock b/spec/lexlean.lock index 3b50faba3c..be81242b80 100644 --- a/spec/lexlean.lock +++ b/spec/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "29ba9126f5a06fcb4eb426cf07b2fb0462a0adad864ffc2187a644076d840201" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/spec/src/Chapter17.lex.tex b/spec/src/Chapter17.lex.tex index 1bea7a5cf9..d58bde2045 100644 --- a/spec/src/Chapter17.lex.tex +++ b/spec/src/Chapter17.lex.tex @@ -798,7 +798,7 @@ result: DocRows::Item, body: constructor{ arguments: [ - (cons "The closed proof variants are reflexivity, decidable Boolean bridging," (cons "`simp only` over a nonempty sorted unique set of document definitions," (cons "induction hypotheses, and the fixed `Bool.and_eq_true`, `Nat.beq_eq`, or" (cons "`Nat.blt_eq` Boolean-to-proposition bridge lemmas; constructor" (cons "congruence, cases, and structural induction. Each has one fixed proof-term or" (cons "tactic lowering and one canonical LaTeX description; users cannot supply a" (cons "tactic name or argument string. Cases and induction require a `Nat`, `List`," (cons "or document-inductive local; their constructor set and pattern-binder arities" (cons "are checked exactly before rendering. Induction may carry a strictly sorted," (cons "unique list of other in-scope theorem parameters to generalize; the scrutinee" (cons "cannot be generalized. Every simplification name resolves" (cons "to one of those closed choices. An axiom-free `boolean_reflection` proof is" (cons "available only in two validated" (cons "generic shapes: structural `List Nat` recursion that reflects `Nat.beq` or" (cons "`Nat.blt` into an independently recursive proposition, and a finite structure" (cons "whose complete ordered `Nat` field set is reflected from right-associated" (cons "Boolean conjunction into propositional conjunction. The proof payload names" (cons "the prior Boolean and proposition definitions and the in-scope locals; record" (cons "expected values are canonical Nat literals. The backend emits fixed natural" (cons "deduction using primitive Nat direction lemmas and locally proved Boolean" (cons "conjunction/reflexivity bridges. It does not invoke `propext` or a general" (cons "tactic." (cons "An `apply` proof names one prior theorem and supplies exactly its ordered," (cons "type-checked semantic arguments; it lowers to one `exact` application and" (cons "cannot carry a proof-term or tactic string." (nil String)))))))))))))))))))))))))) + (cons "The closed proof variants are reflexivity, decidable Boolean bridging," (cons "`simp only` over a nonempty sorted unique set of document definitions," (cons "induction hypotheses, and the fixed `Bool.and_eq_true`, `Nat.beq_eq`, or" (cons "`Nat.blt_eq` Boolean-to-proposition bridge lemmas; constructor" (cons "congruence, cases, and structural induction. Each has one fixed proof-term or" (cons "tactic lowering and one canonical LaTeX description; users cannot supply a" (cons "tactic name or argument string. Cases and induction require a `Nat`, `List`," (cons "or document-inductive local; their constructor set and pattern-binder arities" (cons "are checked exactly before rendering. Induction may carry a strictly sorted," (cons "unique list of other in-scope theorem parameters to generalize; the scrutinee" (cons "cannot be generalized. Every simplification name resolves" (cons "to one of those closed choices. Language 1.2 additionally admits exactly the global names `LexLeanRuntime.utf8Encode` and `String.toUTF8_eq_toByteArray` in a simplify list. A proof naming either UTF-8 bridge lowers to `simp only` over the named definitions followed by `rfl` on every remaining goal; these helpers are emitted with the root namespace so document qualification cannot capture them. This fixed recipe lets the kernel reduce literal byte-array projections after the pinned String representation theorem rewrites the non-exposed UTF-8 operation. It adds no arbitrary helper, tactic payload, or proof sequence syntax. Language 1.1 rejects both names, and simplify proofs without them keep their existing lowering. An axiom-free `boolean_reflection` proof is" (cons "available only in two validated" (cons "generic shapes: structural `List Nat` recursion that reflects `Nat.beq` or" (cons "`Nat.blt` into an independently recursive proposition, and a finite structure" (cons "whose complete ordered `Nat` field set is reflected from right-associated" (cons "Boolean conjunction into propositional conjunction. The proof payload names" (cons "the prior Boolean and proposition definitions and the in-scope locals; record" (cons "expected values are canonical Nat literals. The backend emits fixed natural" (cons "deduction using primitive Nat direction lemmas and locally proved Boolean" (cons "conjunction/reflexivity bridges. It does not invoke `propext` or a general" (cons "tactic." (cons "An `apply` proof names one prior theorem and supplies exactly its ordered," (cons "type-checked semantic arguments; it lowers to one `exact` application and" (cons "cannot carry a proof-term or tactic string." (nil String)))))))))))))))))))))))))) ], constructor: DocRows::Item.para, type_arguments: [] diff --git a/spec/src/IdsSM.lex.tex b/spec/src/IdsSM.lex.tex index 1d6e9284e8..224938d4a3 100644 --- a/spec/src/IdsSM.lex.tex +++ b/spec/src/IdsSM.lex.tex @@ -299,5 +299,12 @@ body: (record Rows::IdRow {id := "SM-38", level := "build", suite := "semantic-ir", statement := "A language-1.2 definition may apply bit_and, bit_or and bit_xor to two Nat operands and shift_left and shift_right to a Nat operand and a Nat amount, each with result Nat and no Option, and the backend lowers them to Nat.land, Nat.lor, Nat.xor, Nat.shiftLeft and Nat.shiftRight, so that reflexivity evaluates them inside a verified module; the registered laws nat_bit_and, nat_bit_or, nat_bit_xor, nat_bit_shift_left, nat_bit_shift_right, nat_or_xor_and, nat_witt_step and nat_bit_ext state the bit read of each under an exact axiom policy, and a theorem that applies one verifies while a false bit equation is rejected; a use in language 1.1, bit_not of a Nat, a Nat operand mixed with an integer of another type, and a production root over a Nat form are each refused.", sections := "§17.11, §17.12"}), executable: true } +definition{ + name: sm39, + parameters: [], + result: Rows::IdRow, + body: (record Rows::IdRow {id := "SM-39", level := "build", suite := "semantic-ir", statement := "Language 1.2 simplify proofs may name exactly LexLeanRuntime.utf8Encode and String.toUTF8_eq_toByteArray as UTF-8 bridges; these names resolve to fixed global declarations and select simp only followed by reflexivity on remaining goals, preserving historical simplify lowering, while literal UTF-8 equalities verify with exact axioms and false equalities, language 1.1 uses, foreign helpers, and malformed name lists are refused.", sections := "§17.10"}), + executable: true +} \end{semanticmodule} \end{lexlean} diff --git a/std-models/lexlean.lock b/std-models/lexlean.lock index 81d73f40b9..da208ec208 100644 --- a/std-models/lexlean.lock +++ b/std-models/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b23bdec83131b3e4f0a45197f98f9b7144a208ff5a2692289262e5096a455001" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/std-reasoning/lexlean.lock b/std-reasoning/lexlean.lock index f3945bf8a4..d76699b8a8 100644 --- a/std-reasoning/lexlean.lock +++ b/std-reasoning/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "76ead6f0bc516e1d9669cf1333e7b75d9e7c19c7f3f8aeb000ca36ad15d432bc" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/stdlib/lexlean.lock b/stdlib/lexlean.lock index 3a69523db5..0e1bdf934d 100644 --- a/stdlib/lexlean.lock +++ b/stdlib/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "4ec208494fa7641b35f82cda91b06851ca826caaefa4d0385110c8d8b2b65878" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/fixtures/command-driver/lexlean.lock b/tests/fixtures/command-driver/lexlean.lock index 9ec38f27a0..bf75acb430 100644 --- a/tests/fixtures/command-driver/lexlean.lock +++ b/tests/fixtures/command-driver/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "c473b0fc61740f7a386ffe868abdb4782e32d0749ecfe7caf2642636d1a91551" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/fixtures/host-effects/lexlean.lock b/tests/fixtures/host-effects/lexlean.lock index 3eb53d765c..6b9fe880d8 100644 --- a/tests/fixtures/host-effects/lexlean.lock +++ b/tests/fixtures/host-effects/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "d644b662d060217370202451ab3393637dec3e45a71400741b97fd1bd8dd3ee2" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-arity/project/lexlean.lock b/tests/negative/application-arity/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/application-arity/project/lexlean.lock +++ b/tests/negative/application-arity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/application-non-function/project/lexlean.lock b/tests/negative/application-non-function/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/application-non-function/project/lexlean.lock +++ b/tests/negative/application-non-function/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-bool-literal-name/project/lexlean.lock b/tests/negative/binder-bool-literal-name/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/binder-bool-literal-name/project/lexlean.lock +++ b/tests/negative/binder-bool-literal-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-capture/project/lexlean.lock b/tests/negative/binder-capture/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/binder-capture/project/lexlean.lock +++ b/tests/negative/binder-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock index ca9c9b3f63..1eb0f7a7ed 100644 --- a/tests/negative/binder-pattern-constructor-name/project/lexlean.lock +++ b/tests/negative/binder-pattern-constructor-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "81ee2a9ef8c129bd8d1d2c5a002526675b1f2cbabb784a33bbb447892bd48c9f" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-branch-binder/project/lexlean.lock b/tests/negative/cases-bool-branch-binder/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/cases-bool-branch-binder/project/lexlean.lock +++ b/tests/negative/cases-bool-branch-binder/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-branch-repeated/project/lexlean.lock b/tests/negative/cases-bool-branch-repeated/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/cases-bool-branch-repeated/project/lexlean.lock +++ b/tests/negative/cases-bool-branch-repeated/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-induction/project/lexlean.lock b/tests/negative/cases-bool-induction/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/cases-bool-induction/project/lexlean.lock +++ b/tests/negative/cases-bool-induction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cases-bool-missing-branch/project/lexlean.lock b/tests/negative/cases-bool-missing-branch/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/cases-bool-missing-branch/project/lexlean.lock +++ b/tests/negative/cases-bool-missing-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-b-rejected/project/lexlean.lock b/tests/negative/certificate-b-rejected/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/certificate-b-rejected/project/lexlean.lock +++ b/tests/negative/certificate-b-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-e-rejected/project/lexlean.lock b/tests/negative/certificate-e-rejected/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/certificate-e-rejected/project/lexlean.lock +++ b/tests/negative/certificate-e-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-generation-limit/project/lexlean.lock b/tests/negative/certificate-generation-limit/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/certificate-generation-limit/project/lexlean.lock +++ b/tests/negative/certificate-generation-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock +++ b/tests/negative/certificate-heartbeat-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-rejected/project/lexlean.lock b/tests/negative/certificate-rejected/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/certificate-rejected/project/lexlean.lock +++ b/tests/negative/certificate-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-resource-exhausted/project/lexlean.lock b/tests/negative/certificate-resource-exhausted/project/lexlean.lock index 82bef96e8b..14518a0017 100644 --- a/tests/negative/certificate-resource-exhausted/project/lexlean.lock +++ b/tests/negative/certificate-resource-exhausted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "533c8a12cea89372dcb6f4707ed7e213695aac97bb956164fc7240cf3ef64a1c" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificate-size-limit/project/lexlean.lock b/tests/negative/certificate-size-limit/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/certificate-size-limit/project/lexlean.lock +++ b/tests/negative/certificate-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/certificates-total-limit/project/lexlean.lock b/tests/negative/certificates-total-limit/project/lexlean.lock index 66514582ed..0aa67cdbd2 100644 --- a/tests/negative/certificates-total-limit/project/lexlean.lock +++ b/tests/negative/certificates-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "19396dab32e876e6744d5feb41043ceae6961ae8b3e677fc770b3b09fcdbc8ad" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-duplicate-key/project/lexlean.lock b/tests/negative/collection-duplicate-key/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/collection-duplicate-key/project/lexlean.lock +++ b/tests/negative/collection-duplicate-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/collection-fold-type-mismatch/project/lexlean.lock +++ b/tests/negative/collection-fold-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-literal-limit/project/lexlean.lock b/tests/negative/collection-literal-limit/project/lexlean.lock index 95b94227f3..4fb64c1205 100644 --- a/tests/negative/collection-literal-limit/project/lexlean.lock +++ b/tests/negative/collection-literal-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "86eb9da7c6c50be25511dfe1cbf99f5e0ac82b411c2ed9b5b4e6c94924af2253" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-noncanonical-key/project/lexlean.lock b/tests/negative/collection-noncanonical-key/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/collection-noncanonical-key/project/lexlean.lock +++ b/tests/negative/collection-noncanonical-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-nonliteral-key/project/lexlean.lock b/tests/negative/collection-nonliteral-key/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/collection-nonliteral-key/project/lexlean.lock +++ b/tests/negative/collection-nonliteral-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-out-of-range-key/project/lexlean.lock b/tests/negative/collection-out-of-range-key/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/collection-out-of-range-key/project/lexlean.lock +++ b/tests/negative/collection-out-of-range-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unbounded-iteration/project/lexlean.lock b/tests/negative/collection-unbounded-iteration/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/collection-unbounded-iteration/project/lexlean.lock +++ b/tests/negative/collection-unbounded-iteration/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/collection-unordered-key/project/lexlean.lock b/tests/negative/collection-unordered-key/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/collection-unordered-key/project/lexlean.lock +++ b/tests/negative/collection-unordered-key/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/cross-version-glossary/project/lexlean.lock b/tests/negative/cross-version-glossary/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/cross-version-glossary/project/lexlean.lock +++ b/tests/negative/cross-version-glossary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/declaration-lean-name/project/lexlean.lock b/tests/negative/declaration-lean-name/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/declaration-lean-name/project/lexlean.lock +++ b/tests/negative/declaration-lean-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-report-limit/project/lexlean.lock b/tests/negative/eligibility-report-limit/project/lexlean.lock index 8c60370792..d6163b8370 100644 --- a/tests/negative/eligibility-report-limit/project/lexlean.lock +++ b/tests/negative/eligibility-report-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock index 8c60370792..d6163b8370 100644 --- a/tests/negative/eligibility-reports-total-limit/project/lexlean.lock +++ b/tests/negative/eligibility-reports-total-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "4ee6bfc173aeabc83ab13796f4cb664adf8561fcffafa32bc39ba3006e24eda9" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-in-data/project/lexlean.lock b/tests/negative/escaping-closure-in-data/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/escaping-closure-in-data/project/lexlean.lock +++ b/tests/negative/escaping-closure-in-data/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-parameter/project/lexlean.lock b/tests/negative/escaping-closure-parameter/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/escaping-closure-parameter/project/lexlean.lock +++ b/tests/negative/escaping-closure-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure-structure/project/lexlean.lock b/tests/negative/escaping-closure-structure/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/escaping-closure-structure/project/lexlean.lock +++ b/tests/negative/escaping-closure-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/escaping-closure/project/lexlean.lock b/tests/negative/escaping-closure/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/escaping-closure/project/lexlean.lock +++ b/tests/negative/escaping-closure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/executable-calls-formal/project/lexlean.lock b/tests/negative/executable-calls-formal/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/executable-calls-formal/project/lexlean.lock +++ b/tests/negative/executable-calls-formal/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-authority-drift/project/lexlean.lock b/tests/negative/extraction-authority-drift/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/extraction-authority-drift/project/lexlean.lock +++ b/tests/negative/extraction-authority-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-rejected/project/lexlean.lock b/tests/negative/extraction-rejected/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/extraction-rejected/project/lexlean.lock +++ b/tests/negative/extraction-rejected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/extraction-uncompiled-external/project/lexlean.lock b/tests/negative/extraction-uncompiled-external/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/extraction-uncompiled-external/project/lexlean.lock +++ b/tests/negative/extraction-uncompiled-external/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/gnaf-certificate-malformed/project/lexlean.lock b/tests/negative/gnaf-certificate-malformed/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/gnaf-certificate-malformed/project/lexlean.lock +++ b/tests/negative/gnaf-certificate-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/gnaf-request-malformed/project/lexlean.lock b/tests/negative/gnaf-request-malformed/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/gnaf-request-malformed/project/lexlean.lock +++ b/tests/negative/gnaf-request-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-duplicate-edge/project/lexlean.lock b/tests/negative/graph-duplicate-edge/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/graph-duplicate-edge/project/lexlean.lock +++ b/tests/negative/graph-duplicate-edge/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/graph-invalid-reference/project/lexlean.lock b/tests/negative/graph-invalid-reference/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/graph-invalid-reference/project/lexlean.lock +++ b/tests/negative/graph-invalid-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-extra/project/lexlean.lock b/tests/negative/lambda-capture-extra/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/lambda-capture-extra/project/lexlean.lock +++ b/tests/negative/lambda-capture-extra/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-capture-missing/project/lexlean.lock b/tests/negative/lambda-capture-missing/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/lambda-capture-missing/project/lexlean.lock +++ b/tests/negative/lambda-capture-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lambda-type-mismatch/project/lexlean.lock b/tests/negative/lambda-type-mismatch/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/lambda-type-mismatch/project/lexlean.lock +++ b/tests/negative/lambda-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lock-schema-language-mismatch/project/lexlean.lock b/tests/negative/lock-schema-language-mismatch/project/lexlean.lock index 731ae71673..5a920dfe58 100644 --- a/tests/negative/lock-schema-language-mismatch/project/lexlean.lock +++ b/tests/negative/lock-schema-language-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/1" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lowering-depth-limit/project/lexlean.lock b/tests/negative/lowering-depth-limit/project/lexlean.lock index 24c0fa4562..7927fe9a35 100644 --- a/tests/negative/lowering-depth-limit/project/lexlean.lock +++ b/tests/negative/lowering-depth-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "0ef90b79ef115752acdab64e47ead3e354657b99e6ddcb26ec636f024e7ef5ee" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/lowering-size-limit/project/lexlean.lock b/tests/negative/lowering-size-limit/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/lowering-size-limit/project/lexlean.lock +++ b/tests/negative/lowering-size-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/member-generated-name/project/lexlean.lock b/tests/negative/member-generated-name/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/member-generated-name/project/lexlean.lock +++ b/tests/negative/member-generated-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-decode-budget/project/lexlean.lock b/tests/negative/model-artifact-decode-budget/project/lexlean.lock index c98bc168f9..3aa80f7a93 100644 --- a/tests/negative/model-artifact-decode-budget/project/lexlean.lock +++ b/tests/negative/model-artifact-decode-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "97224c1005c098cfb00c28986caa7733eb43fd183f038947ba92d676edede581" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock index 5c180d705b..c8a12fd66c 100644 --- a/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-digest-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock index 594b72089b..09c84182bb 100644 --- a/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock +++ b/tests/negative/model-artifact-invalid-utf8/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "7407260b337f63f50bc003afdc8e09e578096041ae6365e5b1f39d0dc3d8e093" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock index 5c180d705b..c8a12fd66c 100644 --- a/tests/negative/model-artifact-length-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-length-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-missing/project/lexlean.lock b/tests/negative/model-artifact-missing/project/lexlean.lock index 5c180d705b..c8a12fd66c 100644 --- a/tests/negative/model-artifact-missing/project/lexlean.lock +++ b/tests/negative/model-artifact-missing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-over-limit/project/lexlean.lock b/tests/negative/model-artifact-over-limit/project/lexlean.lock index e574b95297..01e9162e1d 100644 --- a/tests/negative/model-artifact-over-limit/project/lexlean.lock +++ b/tests/negative/model-artifact-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6b2d40a11356013ad4366b900361329faecae628242794cbc0d2ba8a54ff7d4c" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock index 09a2f43114..b0ed6710c9 100644 --- a/tests/negative/model-artifact-rank-overflow/project/lexlean.lock +++ b/tests/negative/model-artifact-rank-overflow/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "9f0dd9fc1743c1e5be95b546a6d77274f7fd5ffc95c0920b73cfe4e007b47fe0" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-role-violation/project/lexlean.lock b/tests/negative/model-artifact-role-violation/project/lexlean.lock index 5c180d705b..c8a12fd66c 100644 --- a/tests/negative/model-artifact-role-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-role-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-schema-violation/project/lexlean.lock b/tests/negative/model-artifact-schema-violation/project/lexlean.lock index 5c180d705b..c8a12fd66c 100644 --- a/tests/negative/model-artifact-schema-violation/project/lexlean.lock +++ b/tests/negative/model-artifact-schema-violation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock index c17473d2b2..0c0d5d906b 100644 --- a/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock +++ b/tests/negative/model-artifact-shape-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-symlink/project/lexlean.lock b/tests/negative/model-artifact-symlink/project/lexlean.lock index 5c180d705b..c8a12fd66c 100644 --- a/tests/negative/model-artifact-symlink/project/lexlean.lock +++ b/tests/negative/model-artifact-symlink/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-artifact-unconfigured/project/lexlean.lock b/tests/negative/model-artifact-unconfigured/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-artifact-unconfigured/project/lexlean.lock +++ b/tests/negative/model-artifact-unconfigured/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-check-without-validator/project/lexlean.lock b/tests/negative/model-check-without-validator/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-check-without-validator/project/lexlean.lock +++ b/tests/negative/model-check-without-validator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-forged-junction/project/lexlean.lock b/tests/negative/model-composition-forged-junction/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-composition-forged-junction/project/lexlean.lock +++ b/tests/negative/model-composition-forged-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-missing-junction/project/lexlean.lock b/tests/negative/model-composition-missing-junction/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-composition-missing-junction/project/lexlean.lock +++ b/tests/negative/model-composition-missing-junction/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-composition-type-mismatch/project/lexlean.lock b/tests/negative/model-composition-type-mismatch/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-composition-type-mismatch/project/lexlean.lock +++ b/tests/negative/model-composition-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-contract-realization-mismatch/project/lexlean.lock +++ b/tests/negative/model-contract-realization-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-encoder-width-forged/project/lexlean.lock b/tests/negative/model-encoder-width-forged/project/lexlean.lock index c17473d2b2..0c0d5d906b 100644 --- a/tests/negative/model-encoder-width-forged/project/lexlean.lock +++ b/tests/negative/model-encoder-width-forged/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "797fc89000759a8c6c5448f9e54c39a3aec904374930f6a1eff32e33044037dd" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-false-evidence/project/lexlean.lock b/tests/negative/model-false-evidence/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-false-evidence/project/lexlean.lock +++ b/tests/negative/model-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-float-descriptor/project/lexlean.lock b/tests/negative/model-float-descriptor/project/lexlean.lock index 5c180d705b..c8a12fd66c 100644 --- a/tests/negative/model-float-descriptor/project/lexlean.lock +++ b/tests/negative/model-float-descriptor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "b54079b5034756fab196e0130add7e969e214992398790a256fbcb3d866fdab4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-foreign-evidence/project/lexlean.lock b/tests/negative/model-foreign-evidence/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-foreign-evidence/project/lexlean.lock +++ b/tests/negative/model-foreign-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-forged-evidence/project/lexlean.lock b/tests/negative/model-forged-evidence/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-forged-evidence/project/lexlean.lock +++ b/tests/negative/model-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-missing-entry/project/lexlean.lock b/tests/negative/model-missing-entry/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-missing-entry/project/lexlean.lock +++ b/tests/negative/model-missing-entry/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-opaque-member/project/lexlean.lock b/tests/negative/model-opaque-member/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-opaque-member/project/lexlean.lock +++ b/tests/negative/model-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-predicate-signature/project/lexlean.lock b/tests/negative/model-predicate-signature/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-predicate-signature/project/lexlean.lock +++ b/tests/negative/model-predicate-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-realization-bypass/project/lexlean.lock b/tests/negative/model-realization-bypass/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-realization-bypass/project/lexlean.lock +++ b/tests/negative/model-realization-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unregistered-claim/project/lexlean.lock b/tests/negative/model-unregistered-claim/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-unregistered-claim/project/lexlean.lock +++ b/tests/negative/model-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-boundary/project/lexlean.lock b/tests/negative/model-unvalidated-boundary/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-unvalidated-boundary/project/lexlean.lock +++ b/tests/negative/model-unvalidated-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-unvalidated-postcondition/project/lexlean.lock +++ b/tests/negative/model-unvalidated-postcondition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-vacuous-claim/project/lexlean.lock b/tests/negative/model-vacuous-claim/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-vacuous-claim/project/lexlean.lock +++ b/tests/negative/model-vacuous-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/model-validator-unsound-statement/project/lexlean.lock b/tests/negative/model-validator-unsound-statement/project/lexlean.lock index d2cb753cc5..a45f4babef 100644 --- a/tests/negative/model-validator-unsound-statement/project/lexlean.lock +++ b/tests/negative/model-validator-unsound-statement/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "65c0ab6015ada3b098320b5f26ffc6f4a2ceb464a9641e6532a1493110a3c566" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-first/project/lexlean.lock b/tests/negative/module-name-dotted-first/project/lexlean.lock index 9b976a1e85..73d9c24be4 100644 --- a/tests/negative/module-name-dotted-first/project/lexlean.lock +++ b/tests/negative/module-name-dotted-first/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "95276aad5a2f8e56451e0155187ce36290918ff47f8b6a315a4f65c3bfef9e71" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-dotted-last/project/lexlean.lock b/tests/negative/module-name-dotted-last/project/lexlean.lock index f116cbbd34..043f630311 100644 --- a/tests/negative/module-name-dotted-last/project/lexlean.lock +++ b/tests/negative/module-name-dotted-last/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "931ec0afb0a76b983ac4c428c862444a84cf5503f5dd3674b7f95f86e20d955e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-name-lean-namespace/project/lexlean.lock b/tests/negative/module-name-lean-namespace/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/module-name-lean-namespace/project/lexlean.lock +++ b/tests/negative/module-name-lean-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-reserved/project/lexlean.lock b/tests/negative/module-prefix-reserved/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/module-prefix-reserved/project/lexlean.lock +++ b/tests/negative/module-prefix-reserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-shipped-root/project/lexlean.lock b/tests/negative/module-prefix-shipped-root/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/module-prefix-shipped-root/project/lexlean.lock +++ b/tests/negative/module-prefix-shipped-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/module-prefix-target-production/project/lexlean.lock b/tests/negative/module-prefix-target-production/project/lexlean.lock index ac117cf52c..29501a6811 100644 --- a/tests/negative/module-prefix-target-production/project/lexlean.lock +++ b/tests/negative/module-prefix-target-production/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "d4ba5893c2a056d009d9df7131d82f1a6f3a560659e43ded292d44b5d050ee2b" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/mutual-group-noncontiguous/project/lexlean.lock +++ b/tests/negative/mutual-group-noncontiguous/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/mutual-label-shared/project/lexlean.lock b/tests/negative/mutual-label-shared/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/mutual-label-shared/project/lexlean.lock +++ b/tests/negative/mutual-label-shared/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-complement/project/lexlean.lock b/tests/negative/nat-bitwise-complement/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/nat-bitwise-complement/project/lexlean.lock +++ b/tests/negative/nat-bitwise-complement/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock b/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock +++ b/tests/negative/nat-bitwise-mixed-operands/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-production-root/project/lexlean.lock b/tests/negative/nat-bitwise-production-root/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/nat-bitwise-production-root/project/lexlean.lock +++ b/tests/negative/nat-bitwise-production-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock b/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock +++ b/tests/negative/nat-bitwise-shift-amount/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-ambiguity/project/lexlean.lock b/tests/negative/polymorphic-ambiguity/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/polymorphic-ambiguity/project/lexlean.lock +++ b/tests/negative/polymorphic-ambiguity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/polymorphic-recursion/project/lexlean.lock b/tests/negative/polymorphic-recursion/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/polymorphic-recursion/project/lexlean.lock +++ b/tests/negative/polymorphic-recursion/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/preservation-drift/project/lexlean.lock b/tests/negative/preservation-drift/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/preservation-drift/project/lexlean.lock +++ b/tests/negative/preservation-drift/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-effect-mismatch/project/lexlean.lock b/tests/negative/production-effect-mismatch/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-effect-mismatch/project/lexlean.lock +++ b/tests/negative/production-effect-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-expectation-stale/project/lexlean.lock b/tests/negative/production-expectation-stale/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/production-expectation-stale/project/lexlean.lock +++ b/tests/negative/production-expectation-stale/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-formal-only-dependency/project/lexlean.lock b/tests/negative/production-formal-only-dependency/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-formal-only-dependency/project/lexlean.lock +++ b/tests/negative/production-formal-only-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-hidden-dependency/project/lexlean.lock b/tests/negative/production-hidden-dependency/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-hidden-dependency/project/lexlean.lock +++ b/tests/negative/production-hidden-dependency/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-higher-order-escape/project/lexlean.lock b/tests/negative/production-higher-order-escape/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-higher-order-escape/project/lexlean.lock +++ b/tests/negative/production-higher-order-escape/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-literal-width/project/lexlean.lock b/tests/negative/production-literal-width/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-literal-width/project/lexlean.lock +++ b/tests/negative/production-literal-width/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-named-type-boundary/project/lexlean.lock b/tests/negative/production-named-type-boundary/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-named-type-boundary/project/lexlean.lock +++ b/tests/negative/production-named-type-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-package-name-keyword/project/lexlean.lock b/tests/negative/production-package-name-keyword/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/production-package-name-keyword/project/lexlean.lock +++ b/tests/negative/production-package-name-keyword/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-phantom-type-parameter/project/lexlean.lock b/tests/negative/production-phantom-type-parameter/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-phantom-type-parameter/project/lexlean.lock +++ b/tests/negative/production-phantom-type-parameter/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-polymorphic-root/project/lexlean.lock b/tests/negative/production-polymorphic-root/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-polymorphic-root/project/lexlean.lock +++ b/tests/negative/production-polymorphic-root/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-request-malformed/project/lexlean.lock b/tests/negative/production-request-malformed/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/production-request-malformed/project/lexlean.lock +++ b/tests/negative/production-request-malformed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-root-not-executable/project/lexlean.lock b/tests/negative/production-root-not-executable/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-root-not-executable/project/lexlean.lock +++ b/tests/negative/production-root-not-executable/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-root-unknown/project/lexlean.lock b/tests/negative/production-root-unknown/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/production-root-unknown/project/lexlean.lock +++ b/tests/negative/production-root-unknown/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-runtime-incompatible-type/project/lexlean.lock +++ b/tests/negative/production-runtime-incompatible-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-target-unregistered/project/lexlean.lock b/tests/negative/production-target-unregistered/project/lexlean.lock index b7a47d0bdd..b1e487b19d 100644 --- a/tests/negative/production-target-unregistered/project/lexlean.lock +++ b/tests/negative/production-target-unregistered/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6f85e3c598ebbd2209c3ad5533caeb0ac2558d009e9863ec732435267e89972e" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unbounded-type/project/lexlean.lock b/tests/negative/production-unbounded-type/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-unbounded-type/project/lexlean.lock +++ b/tests/negative/production-unbounded-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-universe-boundary/project/lexlean.lock b/tests/negative/production-universe-boundary/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-universe-boundary/project/lexlean.lock +++ b/tests/negative/production-universe-boundary/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/production-unknown-target/project/lexlean.lock b/tests/negative/production-unknown-target/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/production-unknown-target/project/lexlean.lock +++ b/tests/negative/production-unknown-target/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-accept-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-answer-correct-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-answer-invariant-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-answer-type/project/lexlean.lock b/tests/negative/reasoning-answer-type/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-answer-type/project/lexlean.lock +++ b/tests/negative/reasoning-answer-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-binder-reserved/project/lexlean.lock b/tests/negative/reasoning-binder-reserved/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-binder-reserved/project/lexlean.lock +++ b/tests/negative/reasoning-binder-reserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-budget-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-budget-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-claims-duplicate/project/lexlean.lock +++ b/tests/negative/reasoning-claims-duplicate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-claims-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-claims-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock +++ b/tests/negative/reasoning-conclude-bypass-observation/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock +++ b/tests/negative/reasoning-deduplicate-unordered-state/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-duplicate-rule/project/lexlean.lock +++ b/tests/negative/reasoning-duplicate-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock index 6ca3acd91b..68cd2df5e4 100644 --- a/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock +++ b/tests/negative/reasoning-elaboration-over-limit/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "32962ccccc0e0504497383fdd12cf9f1e761305e58c22fa64cc3776c5fad8c16" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-reasoner/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-extract-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-false-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-invariant-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock +++ b/tests/negative/reasoning-false-observation-answer-correct/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forged-trace/project/lexlean.lock b/tests/negative/reasoning-forged-trace/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-forged-trace/project/lexlean.lock +++ b/tests/negative/reasoning-forged-trace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-formal-rule/project/lexlean.lock b/tests/negative/reasoning-formal-rule/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-formal-rule/project/lexlean.lock +++ b/tests/negative/reasoning-formal-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-forward-without-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-frontier-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-bound-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock +++ b/tests/negative/reasoning-fuel-not-nat/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-claims/project/lexlean.lock b/tests/negative/reasoning-generate-claims/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-generate-claims/project/lexlean.lock +++ b/tests/negative/reasoning-generate-claims/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-generate-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-generate-with-logic/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-generate-with-rules/project/lexlean.lock +++ b/tests/negative/reasoning-generate-with-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-generate-without-budget/project/lexlean.lock +++ b/tests/negative/reasoning-generate-without-budget/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-generator-type/project/lexlean.lock b/tests/negative/reasoning-generator-type/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-generator-type/project/lexlean.lock +++ b/tests/negative/reasoning-generator-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-inconsistent-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-initial-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-initial-without-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock +++ b/tests/negative/reasoning-insufficient-fuel/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-interface-rebound/project/lexlean.lock b/tests/negative/reasoning-interface-rebound/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-interface-rebound/project/lexlean.lock +++ b/tests/negative/reasoning-interface-rebound/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock +++ b/tests/negative/reasoning-invalid-rule-application/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-invariant-signature/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock +++ b/tests/negative/reasoning-invariant-unpreserved/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock +++ b/tests/negative/reasoning-logic-type-parameters/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-no-rules/project/lexlean.lock b/tests/negative/reasoning-no-rules/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-no-rules/project/lexlean.lock +++ b/tests/negative/reasoning-no-rules/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock +++ b/tests/negative/reasoning-nonterminating-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-initial-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock +++ b/tests/negative/reasoning-observation-invariant-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-observation-preserved-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-type/project/lexlean.lock b/tests/negative/reasoning-observation-type/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-observation-type/project/lexlean.lock +++ b/tests/negative/reasoning-observation-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-observation-unsorted/project/lexlean.lock +++ b/tests/negative/reasoning-observation-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-opaque-member/project/lexlean.lock b/tests/negative/reasoning-opaque-member/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-opaque-member/project/lexlean.lock +++ b/tests/negative/reasoning-opaque-member/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-progress-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-ranking-signature/project/lexlean.lock b/tests/negative/reasoning-ranking-signature/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-ranking-signature/project/lexlean.lock +++ b/tests/negative/reasoning-ranking-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-reasoner-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-relation-not-definition/project/lexlean.lock +++ b/tests/negative/reasoning-relation-not-definition/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-relation-signature/project/lexlean.lock b/tests/negative/reasoning-relation-signature/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-relation-signature/project/lexlean.lock +++ b/tests/negative/reasoning-relation-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock +++ b/tests/negative/reasoning-reserved-declaration-namespace/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-alias/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-branch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-generator/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-guard/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-iterate/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-observe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass-ref/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-bypass/project/lexlean.lock b/tests/negative/reasoning-rule-bypass/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-bypass/project/lexlean.lock +++ b/tests/negative/reasoning-rule-bypass/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-candidates-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-conclusion-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-foreign-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-guard-type/project/lexlean.lock +++ b/tests/negative/reasoning-rule-guard-type/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-progress-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-rule-soundness-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock +++ b/tests/negative/reasoning-rule-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rule-unknown-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-rules-without-logic/project/lexlean.lock +++ b/tests/negative/reasoning-rules-without-logic/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-accept-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock +++ b/tests/negative/reasoning-search-step-bypass-invariant/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-search-without-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-search-without-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-specification-signature/project/lexlean.lock b/tests/negative/reasoning-specification-signature/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-specification-signature/project/lexlean.lock +++ b/tests/negative/reasoning-specification-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-initial/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-progress/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock +++ b/tests/negative/reasoning-terminates-without-ranking/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-terminating-search/project/lexlean.lock b/tests/negative/reasoning-terminating-search/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-terminating-search/project/lexlean.lock +++ b/tests/negative/reasoning-terminating-search/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-rule/project/lexlean.lock b/tests/negative/reasoning-unknown-rule/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-unknown-rule/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-rule/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-unknown-verifier/project/lexlean.lock +++ b/tests/negative/reasoning-unknown-verifier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-unregistered-claim/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-claim/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock +++ b/tests/negative/reasoning-unregistered-strategy/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-unverified-answer/project/lexlean.lock b/tests/negative/reasoning-unverified-answer/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-unverified-answer/project/lexlean.lock +++ b/tests/negative/reasoning-unverified-answer/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-formal-check/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-verifier-inexact/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-inexact/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-signature/project/lexlean.lock b/tests/negative/reasoning-verifier-signature/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-verifier-signature/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-signature/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-subject-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock +++ b/tests/negative/reasoning-verifier-type-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/reasoning-zero-frontier/project/lexlean.lock b/tests/negative/reasoning-zero-frontier/project/lexlean.lock index 2f726f6f6b..0470b1cb9a 100644 --- a/tests/negative/reasoning-zero-frontier/project/lexlean.lock +++ b/tests/negative/reasoning-zero-frontier/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "24f5f4a1f57fe4c2752462146b8ec7e3366004cd8e459a2ad079867ba9f67827" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-cyclic-measure/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-evidence-omits-match/project/lexlean.lock +++ b/tests/negative/recursion-evidence-omits-match/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-false-evidence/project/lexlean.lock b/tests/negative/recursion-false-evidence/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-false-evidence/project/lexlean.lock +++ b/tests/negative/recursion-false-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-forged-evidence/project/lexlean.lock b/tests/negative/recursion-forged-evidence/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-forged-evidence/project/lexlean.lock +++ b/tests/negative/recursion-forged-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-member-under-lambda/project/lexlean.lock b/tests/negative/recursion-member-under-lambda/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-member-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-member-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-case/project/lexlean.lock b/tests/negative/recursion-missing-case/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-missing-case/project/lexlean.lock +++ b/tests/negative/recursion-missing-case/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-missing-evidence/project/lexlean.lock b/tests/negative/recursion-missing-evidence/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-missing-evidence/project/lexlean.lock +++ b/tests/negative/recursion-missing-evidence/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mixed-families/project/lexlean.lock b/tests/negative/recursion-mixed-families/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-mixed-families/project/lexlean.lock +++ b/tests/negative/recursion-mixed-families/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock +++ b/tests/negative/recursion-mutual-cyclic-measure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-mutual-disconnected/project/lexlean.lock +++ b/tests/negative/recursion-mutual-disconnected/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock +++ b/tests/negative/recursion-mutual-member-without-call/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-mutual-mixed/project/lexlean.lock b/tests/negative/recursion-mutual-mixed/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-mutual-mixed/project/lexlean.lock +++ b/tests/negative/recursion-mutual-mixed/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-nondecreasing/project/lexlean.lock b/tests/negative/recursion-nondecreasing/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-nondecreasing/project/lexlean.lock +++ b/tests/negative/recursion-nondecreasing/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-under-lambda/project/lexlean.lock b/tests/negative/recursion-under-lambda/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-under-lambda/project/lexlean.lock +++ b/tests/negative/recursion-under-lambda/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-well-founded-reference/project/lexlean.lock b/tests/negative/recursion-well-founded-reference/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-well-founded-reference/project/lexlean.lock +++ b/tests/negative/recursion-well-founded-reference/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursion-wrong-argument/project/lexlean.lock b/tests/negative/recursion-wrong-argument/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursion-wrong-argument/project/lexlean.lock +++ b/tests/negative/recursion-wrong-argument/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-constructor-mismatch/project/lexlean.lock +++ b/tests/negative/recursive-constructor-mismatch/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock +++ b/tests/negative/recursive-match-foreign-constructor/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-mutual-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-structure/project/lexlean.lock b/tests/negative/recursive-structure/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-structure/project/lexlean.lock +++ b/tests/negative/recursive-structure/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-arguments/project/lexlean.lock b/tests/negative/recursive-type-arguments/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-type-arguments/project/lexlean.lock +++ b/tests/negative/recursive-type-arguments/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-forward/project/lexlean.lock b/tests/negative/recursive-type-forward/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-type-forward/project/lexlean.lock +++ b/tests/negative/recursive-type-forward/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-nonuniform/project/lexlean.lock b/tests/negative/recursive-type-nonuniform/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-type-nonuniform/project/lexlean.lock +++ b/tests/negative/recursive-type-nonuniform/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-positivity/project/lexlean.lock b/tests/negative/recursive-type-positivity/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-type-positivity/project/lexlean.lock +++ b/tests/negative/recursive-type-positivity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/recursive-type-uninhabited/project/lexlean.lock b/tests/negative/recursive-type-uninhabited/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/recursive-type-uninhabited/project/lexlean.lock +++ b/tests/negative/recursive-type-uninhabited/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock +++ b/tests/negative/semantic-module-v1-under-1.2/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definition-absent/project/lexlean.lock b/tests/negative/term-cases-definition-absent/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/term-cases-definition-absent/project/lexlean.lock +++ b/tests/negative/term-cases-definition-absent/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definition-repeated/project/lexlean.lock b/tests/negative/term-cases-definition-repeated/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/term-cases-definition-repeated/project/lexlean.lock +++ b/tests/negative/term-cases-definition-repeated/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock b/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock +++ b/tests/negative/term-cases-definitions-unsorted/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-empty-definitions/project/lexlean.lock b/tests/negative/term-cases-empty-definitions/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/term-cases-empty-definitions/project/lexlean.lock +++ b/tests/negative/term-cases-empty-definitions/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-reserved-name/project/lexlean.lock b/tests/negative/term-cases-reserved-name/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/term-cases-reserved-name/project/lexlean.lock +++ b/tests/negative/term-cases-reserved-name/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock b/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock +++ b/tests/negative/term-cases-scrutinee-not-inductive/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/text-window-zero-capacity/project/lexlean.lock b/tests/negative/text-window-zero-capacity/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/text-window-zero-capacity/project/lexlean.lock +++ b/tests/negative/text-window-zero-capacity/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/tooling-module-in-user-project/project/lexlean.lock b/tests/negative/tooling-module-in-user-project/project/lexlean.lock index f1ef8c43b4..4affe7c08a 100644 --- a/tests/negative/tooling-module-in-user-project/project/lexlean.lock +++ b/tests/negative/tooling-module-in-user-project/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "238e7aca6dbdb072aca261449c9bd60440763fbf9d421fdde4d29f286ff968b4" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-argument-universe/project/lexlean.lock b/tests/negative/type-argument-universe/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/type-argument-universe/project/lexlean.lock +++ b/tests/negative/type-argument-universe/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/negative/type-parameter-capture/project/lexlean.lock b/tests/negative/type-parameter-capture/project/lexlean.lock index 253165dab5..c1e86c9f22 100644 --- a/tests/negative/type-parameter-capture/project/lexlean.lock +++ b/tests/negative/type-parameter-capture/project/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "6bb823538ff0c18b80a9851c1cc936cf70dc31ce0625cb1a2211c1f30d91411d" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/preservation-certificates/lists/lexlean.lock b/tests/preservation-certificates/lists/lexlean.lock index 541498706c..48fbcd54e2 100644 --- a/tests/preservation-certificates/lists/lexlean.lock +++ b/tests/preservation-certificates/lists/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "2dc372130a18e781ddded01cec4b998ca72fc64e03821c32d166d926f1747167" lean_toolchain = "leanprover/lean4:v4.32.1" diff --git a/tests/rust-backend/loop-ends/lexlean.lock b/tests/rust-backend/loop-ends/lexlean.lock index 5a02cf68a6..872cb7b9c9 100644 --- a/tests/rust-backend/loop-ends/lexlean.lock +++ b/tests/rust-backend/loop-ends/lexlean.lock @@ -1,6 +1,6 @@ spec = "lexlean/lock/2" language = "1.2" -compiler_semantics = "563ff282b750749a19fd51549635b325296039014cdcb02de0e829a4a7af05c7" +compiler_semantics = "79cf6fea059902c0b9f46736a3543edf29a059fdd3cc47690012b223126fc0ae" project_config_sha256 = "3e4158ef82c9e0076571d311f038e86f002adf3e8285a7292c835b07f5a45c65" lean_toolchain = "leanprover/lean4:v4.32.1"