diff --git a/CONFORMANCE.md b/CONFORMANCE.md index 12a429980a..098d0832db 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -358,6 +358,7 @@ the error registry does not sanction (R5, `ERRORS.md`). | `GL-16` | `build` | Package and entry bytes participate in lock and semantic closure hashes exactly as specified. | | `GL-17` | `build` | Language 1.2 resolves the exact 1.2 builtin package closure and enforces 1.2 lexicon semantics. | | `GL-18` | `build` | Cross-version package, lexicon, and lock combinations fail closed before backend execution. | +| `GL-22` | `build` | Document denotations over exported semantic-module inductive and structure types, definitions, and theorems resolve through explicit module imports with their exact canonical signatures and generated Lean names; unavailable declarations and mismatching signatures are refused before verification. | ## models diff --git a/README.md b/README.md index 155906ef1d..3a8611f6b2 100644 --- a/README.md +++ b/README.md @@ -96,7 +96,7 @@ Use it for safety critical code, audited or regulated artifacts, documents whose | Exact repository identity, layout, generated documents, release gate reading its criterion from the specification, total classification of every closed enum by every consumer, the devcontainer pinned to the toolchains, and a check-only build without the production data | `RP-01`..`RP-19` | `build` | | Closed project configuration, canonical lock file, and offline dependency policy | `CF-01`..`CF-18` | `build` | | Total lexical closure: every accepted atom is covered by exactly one declared origin | `LX-01`..`LX-14` | `build` | -| Versioned lexicon packages with closed schemas, denotations, and renderer tokens | `GL-01`..`GL-18` | `build` | +| Versioned lexicon packages with closed schemas, denotations, and renderer tokens | `GL-01`..`GL-22` | `build` | | Fixed structural, mathematical, and proposition grammar with closed ambiguity handling | `GR-01`..`GR-16` | `build` | | Typed closed IR with canonical serialization, native core modules (and the second schema of them that lossless migration of the proof library needs), portable language-1.1 application data and operations, versioned language-1.2 semantic modules, products, first-class functions, and widening conversions, ordered collections and graphs, semantic snapshots, alpha identities, recursion evidence, a split on a document term or a Boolean in a proof, bitwise and shift primitives over `Nat`, content identities, and declaration and statement IDs | `SM-01`, `SM-02`, `SM-03`, `SM-04`, `SM-05`, `SM-06`, `SM-07`, `SM-08`, `SM-09`, `SM-10`, `SM-11`, `SM-12`, `SM-13`, `SM-14`, `SM-15`, `SM-16`, `SM-17`, `SM-18`, `SM-19`, `SM-20`, `SM-21`, `SM-22`, `SM-23`, `SM-24`, `SM-25`, `SM-26`, `SM-27`, `SM-28`, `SM-29`, `SM-30`, `SM-31`, `SM-32`, `SM-33`, `SM-34`, `SM-35`, `SM-36`, `SM-37`, `SM-38`, `SM-42` | `build` | | Document and generic semantic declarations with exact self-application, type checking, structural recursion, recursive and mutual language-1.2 data, generic and executable higher-order definitions, mutual and well-founded recursion with semantic evidence, explicit state threading, and acyclicity rules | `DF-01`..`DF-19` | `build` | @@ -147,7 +147,7 @@ just vv just release ``` -All 521 registered conformance IDs are implemented. `just vv` runs the complete normative acceptance gate (SPEC.md §9.2). `just release` runs `vv` and the §30 criterion; it is refused until 1.0.0. +All 522 registered conformance IDs are implemented. `just vv` runs the complete normative acceptance gate (SPEC.md §9.2). `just release` runs `vv` and the §30 criterion; it is refused until 1.0.0. The [`lean4-prod`](https://github.com/UOR-Foundation/lean4-prod) differential is validation evidence only. A missing oracle fails on Linux x86 64 and prints `NOT VALIDATED` elsewhere. Releases live on `release/vX.Y`, and a tag before 1.0.0 does not claim the §30 criterion. diff --git a/SPEC.md b/SPEC.md index e04c606ba3..5d04ee7d2c 100644 --- a/SPEC.md +++ b/SPEC.md @@ -2359,6 +2359,8 @@ Document-entry signatures are compared against declaration statements using cano Document declarations are available only after their source position. Module imports expose all exported declarations of the imported module. +An imported semantic module exposes its inductive and structure types, definitions, and theorems to document denotations after that module links successfully. The actual declaration's complete explicit type-parameter and value-parameter telescope, result type or proposition, category, and generated Lean name determine the reference; a glossary signature cannot replace them. The signature must have an exact representation in the existing canonical LSE. If it does not, linking refuses the prose use and names the unsupported signature construct. Unused semantic declarations are unaffected. Classes, instances, and model-, reasoning- or text-generated declarations are not implicitly exposed by this document bridge; a refusal identifies the declaration kind. This does not change their semantic-module availability or generated Lean declarations. + ### 17.8 Name generation - Full module: `.`. @@ -12036,6 +12038,7 @@ Every row below is normative, has honesty level `build`, and is projected byte-f | `GL-16` | `lexicon` | Package and entry bytes participate in lock and semantic closure hashes exactly as specified. | §11, §21 | | `GL-17` | `lexicon` | Language 1.2 resolves the exact 1.2 builtin package closure and enforces 1.2 lexicon semantics. | §13.1, §13.11 | | `GL-18` | `lexicon` | Cross-version package, lexicon, and lock combinations fail closed before backend execution. | §10.1, §13.11 | +| `GL-22` | `lexicon` | Document denotations over exported semantic-module inductive and structure types, definitions, and theorems resolve through explicit module imports with their exact canonical signatures and generated Lean names; unavailable declarations and mismatching signatures are refused before verification. | §13.6, §17.7 | | `GR-01` | `grammar` | A source module parses only under the exact structural grammar and environment set. | §15.1, §15.2 | | `GR-02` | `grammar` | Glossary imports, module imports, title, and blocks obey exact header order and cardinality. | §15.1 | | `GR-03` | `grammar` | Sections nest within the configured scope limit and section parameters introduce explicit inherited context. | §15.1, §15.4 | @@ -12489,7 +12492,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:** 521. +**Total required capability IDs:** 522. 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 7af8d4e005..eff182366c 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -21685,3 +21685,97 @@ test result: FAILED. 0 passed; 2 failed `RP-19` failed at the first language-1.2 lock, whose `compiler_semantics` line carried the planted digit while the default build's carried the tree's. With each plant removed, `conformance_rp_10` and `conformance_rp_19` pass. + +## GL-22 semantic declaration publication can fail (#316) + +The initial registered Color candidate failed `conformance_gl_22` at its first +positive `P::check_ok`: `LLT4001`, “no type-noun interpretation survives”, at +`src/Main.lex.tex:9:11`. This initial R3 observation preceded the typed semantic +bridge. Its original output and independent causal review remain retained; +later fixture-parser, diagnostic-expectation and configuration failures also +remain evidence, not passing-baseline results. + +On 2026-11-10, the repaired source candidate +`b2575046686bf7c7b9260e580976d34b7f9f2643` passed the full named case once with +`conformance_gl_22 --exact --test-threads=1 --nocapture`, native Linux x86-64, +pinned Lean 4.32.1 and verifier width 1: one passed, none failed or ignored, +483 filtered out, exit 0 in 10.332162 seconds. The case checked typed semantic +inductive/structure/definition/theorem exports, scoped signatures and Let +comparison, direct imports and aliases, overload selection and prose ordering. +It completed twenty labeled static-negative controls and the separate native +false-predicate-body refusal `LLV7002`. + +The shared positive native verification completed before assertions that six +named declarations had exactly empty observed axiom sets: Main's `color_refl`, +`point_refl`, `function_use`, `generic_use`, `predicate_and_proof_use`, and +`Colors.redRefl`, all under `LanguageTwelve`. This is completed native harness +and assertion evidence. The temporary raw attestations were read by the case +and dropped with its fixtures; no durable raw-attestation archive is claimed. +The accepted frozen positive executable SHA-256 is +`ec45814e10afb90253b8392840c5dab09f0e6d04ea5e4e698de6d7bd0771e1d3`. + +A distinct compiler defect then omitted exactly the successful publication of +`Colors::Color` from the semantic export table in `link.rs`; every fixture and +assertion and every other source path stayed unchanged. One selected mutant +conformance build was necessary because the positive executable statically +contains the accepted compiler. Its actual graph, selected roots, 905 embedded +inputs and error inputs were reviewed; no additional probe or baseline build +or run was used. The separately frozen mutant executable SHA-256 is +`059281fa336ed768d2a8c5e7a8bf7cdb3dc38dbac76a79fcf5512666ef48ea76`. + +The exact same named case failed once with that mutant, exit 101 in 1.366889 +seconds. Its first positive check at `support.rs:871` reported `LLT4001` at +Main's original Color binder, line 9, column 11: + +```text +no type-noun interpretation survives: document declaration `Colors::Color` is not available here +``` + +That first check precedes all native verification calls; the durable diagnostic +and unchanged source order establish this refusal before Lean. Exit 101 alone +is not the witness. This compiler-publication omission is distinct from the +case's false-proposition input mutation. + +The planted defect was removed under the same whole-phase lock by restoring +the exact accepted `link.rs` Git preimage (SHA-256 +`e4d4daf98209abe3b5acdefaf5a05f42b94c8d25e56e756666a86ff4504b6789`). +The full 10,878-entry accepted source inventory, Git metadata and protected +witnesses passed restoration guards and independent review. The selected +mutable target libraries and harness remain explicitly marked mutant/stale; +restoring source does not restore their compiled bytes. Positive and mutant +frozen executables, diagnostics, ledgers and independent reviews remain +retained. No accepted baseline rebuild or rerun followed restoration. + +The retained result/review pairs are initial R3 `4468cc9f`/`9e8bface`, full +positive `13beb4e5`/`05f61e9e`, mutant build `b62a14fd`/`e0cc8614`, and omission +witness plus restoration `f8dda89f`/`2d1b5869`; the external evidence ledger +records their complete hashes. These establish the bounded GL-22 regression +and its compiler-omission falsifiability. They do not establish product +regeneration, a final-head full acceptance gate, merge, publication or issue +closure. Those decisions require the actual final composition and ownership, +including the separately owned #405 forward integration; no old workflow job +count or earlier prepared head substitutes for that acceptance. + +Merged onto `release/v0.5` at `6c36829120` (after the #405 forward merge), the +case passes on the merge: `conformance_gl_22` ran with one passed, none failed +(521 filtered out) in 44.94 s, pinned Lean 4.32.1. The merge needed one change +to the source of that candidate: the `match` of `term_kind` in +`crates/lexlean/src/elaborate/semantic.rs` ended in a wildcard arm, which +`audit-classifications` (RP-15) refuses; it now names every `SemanticTerm` +variant. + +Planted on that merge: the comparison of the glossary signature with the +semantic declaration's type in `validate_semantic_signature` +(`crates/lexlean/src/elaborate/expressions.rs`) disabled by prefixing its +condition with `false &&`. Command: `cargo test -p repo-conformance --test +conformance -- conformance_gl_22`. Expected: the entry whose implicit mode +disagrees with `Colors::generic` is no longer refused. + +```text +GL22 negative implicit-mode: expect LLT4001 +thread 'conformance_gl_22' panicked at crates/conformance/src/support.rs:895:14: +check fails +test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 521 filtered out +``` + +Removed: the edit was restored and the case passes. diff --git a/crates/conformance/src/cases/lexicon.rs b/crates/conformance/src/cases/lexicon.rs index a98264911f..97aca7efee 100644 --- a/crates/conformance/src/cases/lexicon.rs +++ b/crates/conformance/src/cases/lexicon.rs @@ -2,6 +2,8 @@ use lexlean::LockRequest; +mod semantic_document; + use crate::support::{self, P}; /// Lock a mutated project, expecting the given diagnostic code. @@ -1606,6 +1608,7 @@ math = "(seq (operator-name gsucc) (paren (slot 0)))" } } } + "GL-22" => semantic_document::run(), other => panic!("no lexicon case is wired for {other}"), } } diff --git a/crates/conformance/src/cases/lexicon/semantic_document.rs b/crates/conformance/src/cases/lexicon/semantic_document.rs new file mode 100644 index 0000000000..54925859b5 --- /dev/null +++ b/crates/conformance/src/cases/lexicon/semantic_document.rs @@ -0,0 +1,746 @@ +//! GL-22: typed semantic exports are consumed by the ordinary prose pipeline. +use crate::support::{self, P}; + +const COLOR: &str = "(const repro.words::color)"; +const DOMAIN: &str = r"\begin{lexlean}{Colors} +\useglossary{lexlean.std.nat@1.2.0} +\useglossary{languagetwelve.titles@1.0.0} +\title{Typed let terms} +\begin{semanticmodule} +inductive{name: Color, type_parameters: [], parameters: [], constructors: [{name: red, fields: []}, {name: green, fields: []}]} +structure{name: Point, type_parameters: [], parameters: [], fields: [{name: shade, type: Color}]} +definition{name: redValue, parameters: [], result: Color, body: (ctor Color.red)} +definition{name: natValue, parameters: [], result: Nat, body: 0} +definition{name: identityColor, parameters: [c : Color], result: Color, body: c} +definition{name: generic, type_parameters: [A], parameters: [x : 'A], result: 'A, body: x} +definition{name: isRed, parameters: [c : Color], result: Prop, body: (c = (redValue))} +definition{name: booleanRed, parameters: [c : Color], result: Bool, body: true} +definition{name: branching, parameters: [c : Color], result: Color, body: (match c | Color.red => (ctor Color.red) | Color.green => (ctor Color.green))} +class{name: ColorClass, type_parameters: [], parameters: [], fields: [{name: shade, type: Color}]} +theorem{name: nonLse, parameters: [], statement: ((match (ctor Color.red) | Color.red => 0 | Color.green => 0) = 0), proof: reflexivity{}, axioms: []} +theorem{name: letHeader, parameters: [], statement: (let number : Nat := 0; (number = number)), proof: reflexivity{}, axioms: []} +theorem{name: redRefl, parameters: [], statement: (isRed (redValue)), proof: reflexivity{}, axioms: []} +\end{semanticmodule} +\end{lexlean} +"; +const MAIN: &str = r"\begin{lexlean}{Main} +\useglossary{lexlean.std.nat@1.2.0} +\useglossary{languagetwelve.titles@1.0.0} +\useglossary{repro.words@1.0.0} +\importmodule{Colors} +\title{Typed let terms} +\begin{theorem}{color-refl} +\noaxioms +For every color \(c\), \(c = c\). +\begin{proof} +Close the goal by reflexivity. +\end{proof} +\end{theorem} +\begin{theorem}{point-refl} +\noaxioms +For every point \(p\), \(p = p\). +\begin{proof} +Close the goal by reflexivity. +\end{proof} +\end{theorem} +\begin{theorem}{function-use} +\noaxioms +\(identitycolor(redvalue) = identitycolor(redvalue)\). +\begin{proof} +Close the goal by reflexivity. +\end{proof} +\end{theorem} +\begin{theorem}{generic-use} +\noaxioms +\(generic(ℕ, 0) = generic(ℕ, 0)\). +\begin{proof} +Close the goal by reflexivity. +\end{proof} +\end{theorem} +\begin{theorem}{predicate-and-proof-use} +\noaxioms +\(redvalue\) is red. +\begin{proof} +Close the goal with \(redrefl\). +\end{proof} +\end{theorem} +\end{lexlean} +"; + +fn entry( + id: &str, + category: &str, + signature: &str, + component: &str, + surface: &str, + arity: usize, +) -> String { + let text = matches!(category, "type-noun" | "adjective-predicate"); + let channel = if text { "text" } else { "math" }; + let frame = if category == "adjective-predicate" { + "adjective" + } else if arity == 0 { + "atom" + } else { + "call" + }; + let features = if category == "type-noun" { + r#"["article-a", "lower-case", "singular"]"# + } else { + "[]" + }; + let render = if text { + String::new() + } else if arity == 0 { + format!("\n[render]\nmath = \"(operator-name {surface})\"\n") + } else { + let arguments = (0..arity) + .map(|index| format!("(slot {index})")) + .collect::>() + .join(" (token comma) "); + format!( + "\n[render]\nmath = \"(seq (operator-name {surface}) (paren (seq {arguments})))\"\n" + ) + }; + format!( + r#"spec = "lexlean/entry/1" +id = "{id}" +category = "{category}" +signature = "{signature}" +surface_arity = {arity} +frame = "{frame}" +[denotation] +kind = "document" +module = "Colors" +component = "{component}" +[[form]] +id = "{id}" +channel = "{channel}" +surface = "{surface}" +canonical_source = true +features = {features} +{render}"# + ) +} + +fn fixture() -> P { + let project = P::language_1_2_example(); + let rows = [ + ( + "color", + entry("color", "type-noun", "(sort (type 0))", "Color", "color", 0), + ), + ( + "point", + entry("point", "type-noun", "(sort (type 0))", "Point", "point", 0), + ), + ( + "red", + entry("red", "term-constant", COLOR, "redValue", "redvalue", 0), + ), + ( + "identity", + entry( + "identity", + "function", + &format!("(pi ((explicit c {COLOR})) {COLOR})"), + "identityColor", + "identitycolor", + 1, + ), + ), + ( + "generic", + entry( + "generic", + "function", + "(pi ((explicit T (sort (type 0))) (explicit v (local T))) (local T))", + "generic", + "generic", + 2, + ), + ), + ( + "isred", + entry( + "isred", + "adjective-predicate", + &format!("(pi ((explicit c {COLOR})) (sort prop))"), + "isRed", + "red", + 1, + ), + ), + ( + "letproof", + entry("letproof", "proof-constant", "(let renamed (const lexlean.std.nat::nat) (nat 0) (app (const lexlean.core::eq) (local renamed) (local renamed)))", "letHeader", "letproof", 0), + ), + ( + "redrefl", + entry( + "redrefl", + "proof-constant", + "(app (const repro.words::isred) (const repro.words::red))", + "redRefl", + "redrefl", + 0, + ), + ), + ]; + let files = rows + .iter() + .map(|(name, data)| (format!("{name}.toml"), data)) + .collect::>(); + let refs = files + .iter() + .map(|(name, data)| (name.as_str(), data.as_str())) + .collect::>(); + project.add_package( + "glossary/repro.words", + "repro.words", + &["lexlean.core@1.2.0", "lexlean.std.nat@1.2.0"], + &refs, + ); + project.edit( + "glossary/repro.words/lexicon.toml", + "language = \"1.0\"", + "language = \"1.2\"", + ); + project.write_raw("src/Colors.lex.tex", DOMAIN); + project.write_raw("src/Main.lex.tex", MAIN); + project.relock(); + project +} + +fn no_publication(project: &P) { + for path in [".lexlean/build", ".lexlean/verified"] { + assert!( + !project.root.join(path).exists(), + "a linking refusal published {path}" + ); + } +} + +fn rejected_check(project: &P, case: &str, code: &str) -> lexlean::LexLeanError { + eprintln!("GL22 negative {case}: expect {code}"); + let error = project.check_fails_with(code); + eprintln!("GL22 negative {case}: observed {code}"); + error +} + +fn rejected_entry(file: &str, from: &str, to: &str, code: &str) { + let project = fixture(); + project.edit( + &format!("glossary/repro.words/entries/{file}.toml"), + from, + to, + ); + project.relock(); + rejected_check(&project, &format!("entry/{file}: {from:?} -> {to:?}"), code); + no_publication(&project); +} + +pub(super) fn run() { + // This first prose declaration is the original independently observed + // Color failure; the remaining declarations extend that same real fixture. + let project = fixture(); + project.check_ok(); + let checked = support::checked_project(&project); + let_header_comparison(&checked); + let linked = checked.linked_json().to_canonical_string(); + let lean = support::lean_text(&support::rendered(&project), "Main"); + for component in [ + "Color", + "Point", + "redValue", + "identityColor", + "generic", + "isRed", + "redRefl", + ] { + let actual = format!("LanguageTwelve.Colors.{component}"); + assert!( + linked.contains(&actual), + "checked DocumentDeclRef keeps {actual}" + ); + assert!( + lean.contains(&actual), + "Lean uses the actual semantic declaration {actual}" + ); + } + assert!(!lean.contains("LanguageTwelve.Colors.color_refl")); + + // All positive declarations share one tiny real Lean/kernel/axiom run. + if let Some(verified) = support::verify_ok_backed("GL-22", &project) { + let directory = project + .root + .join(".lexlean/verified") + .join(verified.attestation_id.to_hex()); + let attestation: serde_json::Value = serde_json::from_slice( + &std::fs::read(directory.join("attestation.json")).expect("attestation bytes"), + ) + .expect("attestation JSON"); + let declarations = attestation["declarations"] + .as_array() + .expect("audited declarations"); + for name in [ + "LanguageTwelve.Main.color_refl", + "LanguageTwelve.Main.point_refl", + "LanguageTwelve.Main.function_use", + "LanguageTwelve.Main.generic_use", + "LanguageTwelve.Main.predicate_and_proof_use", + "LanguageTwelve.Colors.redRefl", + ] { + let row = declarations + .iter() + .find(|row| row["name"] == name) + .unwrap_or_else(|| panic!("{name} is audited")); + assert_eq!( + row["observed"], + serde_json::json!([]), + "{name} has the exact empty observed axiom set" + ); + } + // False propositions remain rejected after the bridge exists. + project.write_raw( + "src/Colors.lex.tex", + &DOMAIN.replace( + "result: Prop, body: (c = (redValue))", + "result: Prop, body: (c = (ctor Color.green))", + ), + ); + project.relock(); + eprintln!("GL22 negative false-predicate-body: expect LLV7002"); + project.verify_fails_with("LLV7002"); + eprintln!("GL22 negative false-predicate-body: observed LLV7002"); + } + + // Parameter spellings are alpha-equivalent, but mode, scope and sort + // remain exact. Semantic type parameters are explicit and monomorphic. + // Keep the altered entry locally well formed so the mode mismatch is + // rejected by the semantic bridge, not package arity/render validation. + let wrong_mode = fixture(); + wrong_mode.write_raw( + "glossary/repro.words/entries/generic.toml", + &entry( + "generic", + "function", + "(pi ((implicit T (sort (type 0))) (explicit v (local T))) (local T))", + "generic", + "generic", + 1, + ), + ); + wrong_mode.write_raw( + "src/Main.lex.tex", + &MAIN.replace("generic(ℕ, 0)", "generic(redvalue)"), + ); + wrong_mode.relock(); + let error = rejected_check(&wrong_mode, "implicit-mode", "LLT4001"); + assert!(error.diagnostics.iter().any(|diagnostic| diagnostic + .message + .contains("actual scoped semantic declaration") + && diagnostic.message.contains("Colors::generic"))); + no_publication(&wrong_mode); + rejected_entry("generic", "(sort (type 0))", "(sort (type 1))", "LLT4001"); + + // Renaming a claimed universe cannot manufacture a semantic universe + // parameter: these declarations quantify explicit monomorphic types. + for universe in ["u", "renamed"] { + let phantom = fixture(); + let path = "glossary/repro.words/entries/generic.toml"; + let entry = phantom + .read_raw(path) + .replace( + "surface_arity = 2", + &format!("universes = [\"{universe}\"]\nsurface_arity = 2"), + ) + .replace("(sort (type 0))", &format!("(sort (type {universe}))")); + phantom.write_raw(path, &entry); + phantom.relock(); + rejected_check(&phantom, &format!("phantom-universe/{universe}"), "LLT4001"); + no_publication(&phantom); + } + + let unsupported = fixture(); + unsupported.write_raw( + "src/Main.lex.tex", + &MAIN.replace( + "Close the goal with \\(redrefl\\).", + "Close the goal with \\(\\reference{Colors::nonLse}\\).", + ), + ); + unsupported.relock(); + let error = rejected_check(&unsupported, "unsupported-match-header", "LLT4001"); + assert!(error.diagnostics.iter().any(|diagnostic| diagnostic + .message + .contains("no exact prose LSE representation") + && diagnostic.message.contains("match"))); + no_publication(&unsupported); + let unsupported_kind = fixture(); + unsupported_kind.edit( + "glossary/repro.words/entries/red.toml", + "component = \"redValue\"", + "component = \"ColorClass\"", + ); + unsupported_kind.relock(); + let error = rejected_check(&unsupported_kind, "unsupported-class-kind", "LLT4001"); + assert!(error + .diagnostics + .iter() + .any(|diagnostic| diagnostic.message.contains("class"))); + no_publication(&unsupported_kind); + + rejected_entry("color", "(sort (type 0))", "(sort (type 1))", "LLT4001"); + // An independent entry avoids invalidating redRefl's own LSE + // dependency on the correctly typed redValue glossary entry. + let wrong_result = fixture(); + wrong_result.write_raw( + "glossary/repro.words/entries/wrongresult.toml", + &entry( + "wrongresult", + "term-constant", + COLOR, + "natValue", + "wrongresult", + 0, + ), + ); + wrong_result.write_raw( + "src/Main.lex.tex", + &MAIN.replace("identitycolor(redvalue)", "wrongresult"), + ); + wrong_result.relock(); + let error = rejected_check(&wrong_result, "wrong-result-natValue", "LLT4001"); + assert!(error.diagnostics.iter().any(|diagnostic| diagnostic + .message + .contains("actual scoped semantic declaration") + && diagnostic.message.contains("Colors::natValue"))); + no_publication(&wrong_result); + rejected_entry( + "identity", + &format!("(explicit c {COLOR})"), + "(explicit c (const lexlean.std.nat::nat))", + "LLT4001", + ); + rejected_entry( + "identity", + &format!(")) {COLOR})"), + ")) (const lexlean.std.nat::nat))", + "LLT4001", + ); + rejected_entry( + "isred", + "component = \"isRed\"", + "component = \"booleanRed\"", + "LLT4001", + ); + rejected_entry("redrefl", "(app (const repro.words::isred) (const repro.words::red))", "(app (const lexlean.core::eq) (const lexlean.std.nat::zero) (const lexlean.std.nat::zero))", "LLT4001"); + rejected_entry( + "red", + "component = \"redValue\"", + "component = \"redRefl\"", + "LLT4001", + ); + rejected_entry( + "redrefl", + "component = \"redRefl\"", + "component = \"Color\"", + "LLT4001", + ); + + // Direct references carry independently derived types too: no glossary + // signature can turn a semantic type into a proof. Use a closed core + // equality goal: an opaque document predicate intentionally defers + // non-certain proof mismatches to native Lean. A certain mismatch keeps + // the original expected-type diagnostic, LLT4001. + let wrong_reference = fixture(); + wrong_reference.write_raw( + "src/Main.lex.tex", + &MAIN + .replace("\\(redvalue\\) is red.", "\\(redvalue = redvalue\\).") + .replace( + "Close the goal with \\(redrefl\\).", + "Close the goal with \\(\\reference{Colors::Color}\\).", + ), + ); + wrong_reference.relock(); + rejected_check( + &wrong_reference, + "type-reference-as-closed-equality-proof", + "LLT4001", + ); + no_publication(&wrong_reference); + + for (import, component) in [(false, "redValue"), (true, "missing")] { + let unavailable = fixture(); + let source = MAIN.replace( + "identitycolor(redvalue)", + &format!("\\reference{{Colors::{component}}}"), + ); + unavailable.write_raw( + "src/Main.lex.tex", + &if import { + source + } else { + source.replace("\\importmodule{Colors}\n", "") + }, + ); + unavailable.relock(); + // Type-noun checking comes first when the import is absent. + rejected_check( + &unavailable, + &format!("unavailable/import={import}/{component}"), + if import { "LLR3005" } else { "LLT4001" }, + ); + no_publication(&unavailable); + } + + // Isolate constant availability from the first Color type-noun: this + // consumer has no imported semantic types that could mask the refusal. + let unimported_constant = fixture(); + unimported_constant.write_raw( + "src/Main.lex.tex", + r"\begin{lexlean}{Main} +\useglossary{lexlean.std.nat@1.2.0} +\useglossary{languagetwelve.titles@1.0.0} +\title{Typed let terms} +\begin{theorem}{unimported-value} +\noaxioms +\(\reference{Colors::natValue} = \reference{Colors::natValue}\). +\begin{proof} +Close the goal by reflexivity. +\end{proof} +\end{theorem} +\end{lexlean} +", + ); + unimported_constant.relock(); + rejected_check(&unimported_constant, "unimported-constant", "LLR3005"); + no_publication(&unimported_constant); + + // An import's imports do not leak their semantic declarations. + let transitive = fixture(); + transitive.write_raw( + "src/Hidden.lex.tex", + &DOMAIN.replace("{Colors}", "{Hidden}"), + ); + transitive.write_raw( + "src/Colors.lex.tex", + &DOMAIN.replace("\\title", "\\importmodule{Hidden}\n\\title"), + ); + transitive.write_raw( + "src/Main.lex.tex", + &MAIN.replace("identitycolor(redvalue)", "\\reference{Hidden::redValue}"), + ); + transitive.relock(); + rejected_check(&transitive, "transitive-constant", "LLR3005"); + no_publication(&transitive); + + // Same-surface overloads stay separate until exact argument types select. + let overloaded = fixture(); + let other = entry( + "other", + "term-constant", + "(const lexlean.std.nat::nat)", + "natValue", + "redvalue", + 0, + ); + overloaded.add_package( + "glossary/repro.zother", + "repro.zother", + &["lexlean.core@1.2.0", "lexlean.std.nat@1.2.0"], + &[("other.toml", &other)], + ); + overloaded.edit( + "glossary/repro.zother/lexicon.toml", + "language = \"1.0\"", + "language = \"1.2\"", + ); + overloaded.write_raw( + "src/Main.lex.tex", + &MAIN.replace( + "\\importmodule", + "\\useglossary{repro.zother@1.0.0}\n\\importmodule", + ), + ); + overloaded.relock(); + let text = support::lean_text(&support::rendered(&overloaded), "Main"); + assert!(text.contains("LanguageTwelve.Colors.redValue")); + assert!(!text.contains("LanguageTwelve.Colors.natValue")); + + prose_order_and_package_names(); +} + +fn prose_order_and_package_names() { + // Keep existing prose source-position visibility exactly as before. + let prose = support::defs_project(); + prose.check_ok(); + let source = prose.read_raw("src/Main.lex.tex"); + let anchor = source + .find("\\begin{termdefinition}") + .expect("a prose definition"); + let early = "\\begin{theorem}{too-early}\n\\noaxioms\n\\(\\reference{Main::double} = \\reference{Main::double}\\).\n\\begin{proof}\nClose the goal by reflexivity.\n\\end{proof}\n\\end{theorem}\n"; + prose.write_raw( + "src/Main.lex.tex", + &format!("{}{early}{}", &source[..anchor], &source[anchor..]), + ); + prose.relock(); + rejected_check(&prose, "prose-before-definition", "LLR3005"); + no_publication(&prose); + + // Package sibling imports use the source-visible key `Shapes`, while + // their reference and Lean constant retain `PkgLib.Shapes.quad`. + let app = P::package_workspace("app"); + let path = app.workspace_dir().join("lib/src/Util.lex.tex"); + std::fs::write( + path.as_std_path(), + r"\begin{lexlean}{Util} +\useglossary{lexlean.std.nat@1.2.0} +\importmodule{Shapes} +\title{Natural number addition} +\begin{theorem}{alias-use} +\noaxioms +For every natural number \(n\), \(\reference{Shapes::quad}(n) = \reference{Shapes::quad}(n)\). +\begin{proof} +Close the goal by reflexivity. +\end{proof} +\end{theorem} +\end{lexlean} +", + ) + .expect("write package consumer"); + app.write_raw( + "src/Main.lex.tex", + r"\begin{lexlean}{Main} +\useglossary{lexlean.std.nat@1.2.0} +\importmodule{PkgLib.Util} +\title{Natural number addition} +\begin{theorem}{import-use} +\noaxioms +For every natural number \(n\), \(n = n\). +\begin{proof} +Close the goal by reflexivity. +\end{proof} +\end{theorem} +\end{lexlean} +", + ); + app.relock(); + let checked = support::checked_project(&app); + let json = checked.linked_json().to_canonical_string(); + assert!(json.contains("PkgLib.Shapes.quad")); + assert!( + support::lean_text(&support::rendered(&app), "PkgLib.Util").contains("PkgLib.Shapes.quad") + ); +} + +// This regression runs in the same GL22 harness: an actual semantic Let +// header must compare with an independently converted alpha-renamed LSE. +// Wrong binder types, out-of-scope values and unequal bodies never match. +fn let_header_comparison(checked: &lexlean::link::CheckedProject) { + use lexlean::elaborate::expressions::{entry_signature_term, unify_closed}; + use lexlean::elaborate::resolve::LocalAlloc; + use lexlean::elaborate::{DeclTable, Shared}; + use lexlean::ir::term::{LocalId, Term, Universe}; + use lexlean::lexicon::lse::QualifiedId; + let module = &checked.modules["Colors"].document; + let exports = lexlean::elaborate::semantic::exports( + "Colors", + &module.lean_module, + module.semantic.as_ref().expect("semantic domain"), + &module.import_lean, + ); + let decls = DeclTable { + rows: Vec::new(), + semantic: exports, + }; + let main = &checked.modules["Main"]; + let shared = Shared { + path: &main.document.source_path, + atoms: &main.atoms, + closure: &checked.closure, + visible: &main.visible, + decls: &decls, + module: "Main", + module_prefix: "LanguageTwelve", + }; + let mut alloc = LocalAlloc::default(); + let (_, claimed) = entry_signature_term( + &shared, + &mut alloc, + &QualifiedId::parse("repro.words::letproof").expect("entry id"), + ) + .expect("alpha-equivalent actual Let header accepted"); + let actual = decls + .semantic_get("Colors", "letHeader") + .expect("linked header") + .ty(&checked.closure, &mut alloc) + .expect("exact actual type"); + assert!(unify_closed(&actual, &claimed)); + let Term::Let { + binder, + value, + body, + } = &claimed + else { + panic!("actual header is a Let") + }; + let mut wrong_type = (**binder).clone(); + wrong_type.ty = Term::Sort(Universe::Num(1)); + assert!(!unify_closed( + &actual, + &Term::Let { + binder: Box::new(wrong_type), + value: value.clone(), + body: body.clone() + } + )); + assert!( + !unify_closed( + &actual, + &Term::Let { + binder: binder.clone(), + value: Box::new(Term::Local(binder.id)), + body: body.clone() + } + ), + "let binder is not in scope in its value" + ); + let mut wrong_value = (**value).clone(); + let Term::NatLiteral { decimal, .. } = &mut wrong_value else { + panic!("Nat literal value") + }; + *decimal = "1".to_owned(); + assert!(!unify_closed( + &actual, + &Term::Let { + binder: binder.clone(), + value: Box::new(wrong_value), + body: body.clone() + } + )); + assert!( + !unify_closed( + &actual, + &Term::Let { + binder: binder.clone(), + value: value.clone(), + body: Box::new(Term::Local(LocalId(u64::MAX))) + } + ), + "free body name cannot be captured" + ); + // Scope-aware comparison also recurses through a containing lambda. + let lambda = |body| Term::Lambda { + binders: vec![lexlean::ir::term::Binder { + id: LocalId(u64::MAX - 1), + mode: lexlean::ir::term::BinderMode::Explicit, + ty: Term::Sort(Universe::Num(1)), + spelling: "outside".to_owned(), + }], + body: Box::new(body), + }; + assert!(unify_closed(&lambda(actual), &lambda(claimed))); +} diff --git a/crates/conformance/tests/conformance.rs b/crates/conformance/tests/conformance.rs index bee52af13d..91b6bdad85 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -2609,3 +2609,8 @@ fn conformance_ns_07() { fn conformance_sl_12() { repo_conformance::cases::run("SL-12"); } + +#[test] +fn conformance_gl_22() { + repo_conformance::cases::run("GL-22"); +} diff --git a/crates/lexlean/src/elaborate/expressions.rs b/crates/lexlean/src/elaborate/expressions.rs index 7caa018d56..9a79809d1f 100644 --- a/crates/lexlean/src/elaborate/expressions.rs +++ b/crates/lexlean/src/elaborate/expressions.rs @@ -583,6 +583,7 @@ fn unify(a: &Term, b: &Term, metas: &mut Metas) -> bool { // introduced them (`the successor of n` and `succ(n)` are both // `Nat.succ`). let same_constant = match (gx, gy) { + (GlobalRef::Document(x), GlobalRef::Document(y)) => x.lean_name == y.lean_name, (GlobalRef::External(x), GlobalRef::External(y)) => { x.lean_module == y.lean_module && x.lean_name == y.lean_name } @@ -653,6 +654,27 @@ fn unify(a: &Term, b: &Term, metas: &mut Metas) -> bool { let vy_renamed = subst(vy, &rename); unify(vx, &vy_renamed, metas) } + ( + Term::Let { + binder: bx, + value: vx, + body: body_x, + }, + Term::Let { + binder: by, + value: vy, + body: body_y, + }, + ) => { + // A let's binder scopes only its body, never its type or value. + // Compare those outside the renaming, then alpha-rename the + // body's unique local identity without performing any reduction. + if bx.mode != by.mode || !unify(&bx.ty, &by.ty, metas) || !unify(vx, vy, metas) { + return false; + } + let rename = BTreeMap::from([(by.id, Term::Local(bx.id))]); + unify(body_x, &subst(body_y, &rename), metas) + } ( Term::NatLiteral { decimal: dx, @@ -771,12 +793,18 @@ impl LseWalk<'_, '_, '_> { /// The signature type of a constant, converted afresh, for typing the /// arguments it is applied to; `None` when unavailable or when the /// constant's own signature is being converted. - fn constant_type(&mut self, id: &QualifiedId) -> Option { + fn constant_type(&mut self, id: &QualifiedId) -> Result, LseError> { if self.visiting.contains(id) { - return None; + return Ok(None); } - let entry = self.shared.closure.entry(id)?; - let signature = entry.signature.as_ref()?.clone(); + let entry = self + .shared + .closure + .entry(id) + .ok_or_else(|| LseError::Unavailable(format!("`{id}` is absent")))?; + let Some(signature) = entry.signature.as_ref().cloned() else { + return Ok(None); + }; let universe_map = universe_map(&entry.universes, |_, name| { match self.metas.as_deref_mut() { Some(metas) => Universe::Var(metas.fresh_universe(self.alloc)), @@ -786,11 +814,25 @@ impl LseWalk<'_, '_, '_> { self.visiting.push(id.clone()); let saved_scope = std::mem::take(&mut self.scope); let saved_map = std::mem::replace(self.map_slot(), universe_map); - let converted = self.walk(&signature, None).ok().map(|(term, _)| term); + let converted = self.walk(&signature, None).map(|(term, _)| term); *self.map_slot() = saved_map; self.scope = saved_scope; self.visiting.pop(); - converted + let converted = match converted { + Ok(converted) => converted, + Err(failure) => { + if matches!(&entry.denotation, Denotation::Document { module, component } if self.shared.decls.semantic_get(module, component).is_some()) + { + return Err(failure); + } + // Preserve the previous conservative inference boundary for + // non-semantic constants: unavailable inferred type is not + // an invented actual type and does not add a new rejection. + return Ok(None); + } + }; + validate_semantic_signature(self.shared, self.alloc, entry, &converted)?; + Ok(Some(converted)) } fn map_slot(&mut self) -> &mut BTreeMap { @@ -816,8 +858,13 @@ impl LseWalk<'_, '_, '_> { (Term::Sort(level), Some(Term::Sort(ty))) } Lse::Const(id, universes) => { - let global = global_for_entry(self.shared, id).map_err(LseError::Unavailable)?; - let ty = self.constant_type(id); + let entry = self + .shared + .closure + .entry(id) + .ok_or_else(|| LseError::Unavailable(format!("`{id}` is absent")))?; + let global = global_for(self.shared, id, entry).map_err(LseError::Unavailable)?; + let ty = self.constant_type(id)?; ( Term::Global( global, @@ -1064,6 +1111,13 @@ pub fn global_for_entry(shared: &Shared<'_>, id: &QualifiedId) -> Result, id: &QualifiedId, entry: &Entry) -> Result { - let info = shared.decls.get(module, component).ok_or_else(|| { - format!("document declaration `{module}::{component}` is not available here") - })?; - GlobalRef::Document(DocumentDeclRef { - module: module.clone(), - component: component.clone(), - lean_name: info.lean_name.clone(), - }) + if let Some(info) = shared.decls.get(module, component) { + GlobalRef::Document(DocumentDeclRef { + module: module.clone(), + component: component.clone(), + lean_name: info.lean_name.clone(), + }) + } else if let Some(info) = shared.decls.semantic_get(module, component) { + info.check_category(entry.category)?; + GlobalRef::Document(info.reference()) + } else { + return Err(format!( + "document declaration `{module}::{component}` is not available here" + )); + } } Denotation::Defined { .. } => GlobalRef::DefinedLexicon(DefinedLexiconRef { package: id.package.clone(), @@ -1114,6 +1174,94 @@ fn global_for(shared: &Shared<'_>, id: &QualifiedId, entry: &Entry) -> Result Term { + match term { + Term::Pi { .. } => { + let (binders, body) = flatten_pi(term); + Term::Pi { + binders: binders + .into_iter() + .map(|mut binder| { + binder.ty = canonical_signature(&binder.ty); + binder + }) + .collect(), + body: Box::new(canonical_signature(&body)), + } + } + Term::Lambda { binders, body } => Term::Lambda { + binders: binders + .iter() + .cloned() + .map(|mut binder| { + binder.ty = canonical_signature(&binder.ty); + binder + }) + .collect(), + body: Box::new(canonical_signature(body)), + }, + Term::App { + function, + explicit_args, + omitted_implicit_binders, + } => Term::App { + function: Box::new(canonical_signature(function)), + explicit_args: explicit_args.iter().map(canonical_signature).collect(), + omitted_implicit_binders: omitted_implicit_binders.clone(), + }, + Term::Let { + binder, + value, + body, + } => { + let mut binder = (**binder).clone(); + binder.ty = canonical_signature(&binder.ty); + Term::Let { + binder: Box::new(binder), + value: Box::new(canonical_signature(value)), + body: Box::new(canonical_signature(body)), + } + } + Term::NatLiteral { + decimal, + expected_type, + } => Term::NatLiteral { + decimal: decimal.clone(), + expected_type: Box::new(canonical_signature(expected_type)), + }, + other => other.clone(), + } +} + +/// Semantic entries never derive their type from the claimed glossary +/// signature. Compare the independently constructed entire telescope before +/// returning any accepted glossary reference (including nested LSE constants). +fn validate_semantic_signature( + shared: &Shared<'_>, + alloc: &mut LocalAlloc, + entry: &Entry, + claimed: &Term, +) -> Result<(), LseError> { + let Denotation::Document { module, component } = &entry.denotation else { + return Ok(()); + }; + let Some(info) = shared.decls.semantic_get(module, component) else { + return Ok(()); + }; + info.check_category(entry.category) + .map_err(LseError::IllTyped)?; + if !entry.universes.is_empty() { + return Err(LseError::IllTyped(format!("semantic declaration `{module}::{component}` has no universe parameters; glossary universes do not match its actual header"))); + } + let actual = info.ty(shared.closure, alloc).map_err(LseError::IllTyped)?; + if !unify_closed(&canonical_signature(&actual), &canonical_signature(claimed)) { + return Err(LseError::IllTyped(format!("glossary signature does not match the actual scoped semantic declaration `{module}::{component}`"))); + } + Ok(()) +} + impl<'a, 'b> ExprElab<'a, 'b> { fn bytes_of(&self, range: AtomRange) -> (usize, usize) { let first = &self.shared.atoms[range.0]; @@ -1174,6 +1322,7 @@ impl<'a, 'b> ExprElab<'a, 'b> { &universe_map, Some(metas), )?; + validate_semantic_signature(self.shared, self.alloc, entry, &ty)?; let global = global_for(self.shared, &qualified, entry).map_err(LseError::Unavailable)?; Ok((Term::Global(global, universe_args), ty)) } @@ -1570,13 +1719,29 @@ impl<'a, 'b> ExprElab<'a, 'b> { component, atoms, } => { - let info = self.shared.decls.get(module, component).ok_or_else(|| { - Diagnostic::new( + let (reference, actual_ty) = if let Some(info) = + self.shared.decls.get(module, component) + { + ( + DocumentDeclRef { + module: module.clone(), + component: component.clone(), + lean_name: info.lean_name.clone(), + }, + info.ty.clone(), + ) + } else if let Some(info) = self.shared.decls.semantic_get(module, component) { + let ty = info.ty(self.shared.closure, self.alloc).map_err(|reason| { + Diagnostic::new(code!("LLT4001"), reason).with_span(self.span_of(*atoms)) + })?; + (info.reference(), ty) + } else { + return Err(Diagnostic::new( code!("LLR3005"), format!("`{module}::{component}` is not an available document declaration"), ) - .with_span(self.span_of(*atoms)) - })?; + .with_span(self.span_of(*atoms))); + }; let mut rows = vec![self.atom_row( atoms.0, Origin::Structural { @@ -1612,15 +1777,8 @@ impl<'a, 'b> ExprElab<'a, 'b> { } } out.push(Cand { - term: Term::Global( - GlobalRef::Document(DocumentDeclRef { - module: module.clone(), - component: component.clone(), - lean_name: info.lean_name.clone(), - }), - Vec::new(), - ), - ty: info.ty.clone(), + term: Term::Global(GlobalRef::Document(reference), Vec::new()), + ty: actual_ty, metas: Metas::default(), rows, }); @@ -2274,6 +2432,8 @@ pub fn entry_signature_term( let universe_map = universe_map(&entry.universes, |_, name| Universe::Var(name.to_owned())); let ty = lse_to_term(signature, shared, alloc, &universe_map, None) .map_err(|failure| failure.to_string())?; + validate_semantic_signature(shared, alloc, entry, &ty) + .map_err(|failure| failure.to_string())?; let global = global_for(shared, entry_id, entry)?; Ok((global, ty)) } diff --git a/crates/lexlean/src/elaborate/mod.rs b/crates/lexlean/src/elaborate/mod.rs index 397bbaec54..c6b38e1786 100644 --- a/crates/lexlean/src/elaborate/mod.rs +++ b/crates/lexlean/src/elaborate/mod.rs @@ -8,6 +8,7 @@ pub mod delta; pub mod expressions; pub mod proofs; pub mod resolve; +pub mod semantic; use std::collections::BTreeSet; @@ -41,9 +42,19 @@ pub struct DeclInfo { pub struct DeclTable { /// The rows. pub rows: Vec, + /// Successfully linked semantic headers, converted only at prose use. + pub semantic: Vec, } impl DeclTable { + /// Look up a semantic declaration by its source-visible import key. + #[must_use] + pub fn semantic_get(&self, module: &str, component: &str) -> Option<&semantic::SemanticExport> { + self.semantic + .iter() + .find(|row| row.module == module && row.component == component) + } + /// Look up a declaration. #[must_use] pub fn get(&self, module: &str, component: &str) -> Option<&DeclInfo> { @@ -443,17 +454,25 @@ pub fn elab_binder( let ty = match &binder.type_phrase { TypePhraseAst::Noun { candidates, atoms } => { let mut survivors: Vec<(String, Term, SourceRow)> = Vec::new(); + let mut refusal = None; for reference in candidates { let mut elaborator = ExprElab::new(shared, scopes, alloc, budget); let leaf = crate::grammar::math::MathAst::Leaf { kinds: vec![crate::grammar::math::LeafKind::Form(reference.clone())], atoms: *atoms, }; - if let Ok(result) = elaborator.elaborate(&leaf, None) { - let key = result.term.eq_key(); - if !survivors.iter().any(|(existing, ..)| *existing == key) { - let row = result.rows[0].clone(); - survivors.push((key, result.term, row)); + match elaborator.elaborate(&leaf, None) { + Ok(result) => { + let key = result.term.eq_key(); + if !survivors.iter().any(|(existing, ..)| *existing == key) { + let row = result.rows[0].clone(); + survivors.push((key, result.term, row)); + } + } + Err(diagnostic) => { + if refusal.is_none() { + refusal = Some(diagnostic.message); + } } } } @@ -467,7 +486,10 @@ pub fn elab_binder( let a = &shared.atoms[atoms.0]; return Err(Diagnostic::new( code!("LLT4001"), - "no type-noun interpretation survives", + format!( + "no type-noun interpretation survives{}", + refusal.map_or_else(String::new, |reason| format!(": {reason}")) + ), ) .with_span(a.span(shared.path))); } diff --git a/crates/lexlean/src/elaborate/semantic.rs b/crates/lexlean/src/elaborate/semantic.rs new file mode 100644 index 0000000000..20925846cd --- /dev/null +++ b/crates/lexlean/src/elaborate/semantic.rs @@ -0,0 +1,474 @@ +//! Exact conversion of successfully linked semantic export headers to prose +//! types. Bodies remain semantic IR: no opaque or glossary-supplied type is +//! substituted when an existing LSE cannot express a header. +use std::collections::BTreeMap; +use std::sync::Arc; + +use crate::ir::semantic::{ + MemberRef, SemanticDeclaration, SemanticModule, SemanticParameter, SemanticTerm, SemanticType, +}; +use crate::ir::term::{ + Binder, BinderMode, CoreRef, DocumentDeclRef, ExternalConstRef, GlobalRef, LocalId, Term, + Universe, +}; +use crate::lexicon::entry::{Category, Denotation}; +use crate::lexicon::resolve::Closure; + +use super::resolve::LocalAlloc; + +#[derive(Debug, Clone)] +enum Header { + Type, + Definition(Box), + Theorem(Box), + Unavailable(&'static str), +} + +/// A validated semantic declaration's source key and actual backend name. +/// The header is converted lazily: an unused declaration whose signature +/// has no prose-LSE representation must not disable its semantic module. +#[derive(Debug, Clone)] +pub struct SemanticExport { + /// The key visible to the importing source, renamed with its imports. + pub module: String, + /// The exact semantic member name (never a prose component encoding). + pub component: String, + /// The full backend name. + pub lean_name: String, + own_module: String, + modules: Arc>, + type_parameters: Vec, + parameters: Vec, + header: Header, +} + +impl SemanticExport { + /// A source-visible reference keeps its logical key and actual Lean name. + #[must_use] + pub fn reference(&self) -> DocumentDeclRef { + DocumentDeclRef { + module: self.module.clone(), + component: self.component.clone(), + lean_name: self.lean_name.clone(), + } + } + + /// Semantic declaration categories are not interchangeable even when + /// their erased signatures would happen to have the same shape. + /// + /// # Errors + /// The semantic kind does not admit this glossary category. + pub fn check_category(&self, category: Category) -> Result<(), String> { + let accepted = match &self.header { + Header::Type => category == Category::TypeNoun, + Header::Theorem(_) => category == Category::ProofConstant, + Header::Definition(result) => { + if **result == SemanticType::Prop { + matches!(category, Category::PredicateConstant | Category::AdjectivePredicate | Category::IntransitivePredicate | Category::TransitivePredicate | Category::InfixPredicate) + } else if **result == SemanticType::Type { + category == Category::TypeNoun + } else { + matches!(category, Category::TermConstant | Category::Function | Category::PrefixFunction | Category::PostfixFunction | Category::InfixFunction | Category::NounFunction | Category::BinaryNounFunction) + } + } + Header::Unavailable(kind) => return Err(format!("semantic declaration `{}::{}` has category `{kind}`; document glossaries expose inductive, structure, definition and theorem declarations", self.module, self.component)), + }; + if accepted { + Ok(()) + } else { + Err(format!( + "semantic declaration `{}::{}` cannot be used as glossary category `{}`", + self.module, + self.component, + category.as_str() + )) + } + } + + /// Derive the entire actual telescope independently of the glossary. + /// Every local comes from the caller's allocator, so it cannot capture + /// the independently converted entry or an enclosing prose binder. + /// + /// # Errors + /// A category, term or required constant has no exact prose-LSE representation. + pub fn ty(&self, closure: &Closure, alloc: &mut LocalAlloc) -> Result { + if let Header::Unavailable(kind) = &self.header { + return Err(format!( + "semantic declaration `{}::{}` has unsupported glossary category `{kind}`", + self.module, self.component + )); + } + let mut conversion = Convert { + export: self, + closure, + alloc, + locals: BTreeMap::new(), + }; + let mut binders = Vec::new(); + for name in &self.type_parameters { + binders.push(conversion.bind(name, Term::Sort(Universe::Num(1)))); + } + for parameter in &self.parameters { + let ty = conversion.ty(¶meter.r#type)?; + binders.push(conversion.bind(¶meter.name, ty)); + } + let result = match &self.header { + Header::Type => Term::Sort(Universe::Num(1)), + Header::Definition(result) => conversion.ty(result)?, + Header::Theorem(statement) => conversion.term(statement)?, + Header::Unavailable(kind) => { + return Err(format!("unsupported semantic glossary category `{kind}`")) + } + }; + Ok(pi(binders, result)) + } +} + +/// Retain only headers, not duplicate computational bodies. Call this only +/// after linking, production checks and source closure have accepted a module. +#[must_use] +pub fn exports( + module: &str, + lean_module: &str, + semantic: &SemanticModule, + imported_lean: &BTreeMap, +) -> Vec { + let mut modules = imported_lean.clone(); + modules.insert(module.to_owned(), lean_module.to_owned()); + let modules = Arc::new(modules); + semantic + .declarations + .iter() + .map(|declaration| { + let (type_parameters, parameters, header) = match declaration { + SemanticDeclaration::Inductive { + type_parameters, + parameters, + .. + } + | SemanticDeclaration::Structure { + type_parameters, + parameters, + .. + } => (type_parameters.clone(), parameters.clone(), Header::Type), + SemanticDeclaration::Definition { + type_parameters, + parameters, + result, + .. + } => ( + type_parameters.clone(), + parameters.clone(), + Header::Definition(Box::new(result.clone())), + ), + SemanticDeclaration::Theorem { + type_parameters, + parameters, + statement, + .. + } => ( + type_parameters.clone(), + parameters.clone(), + Header::Theorem(Box::new(statement.clone())), + ), + other => (Vec::new(), Vec::new(), Header::Unavailable(other.kind())), + }; + SemanticExport { + module: module.to_owned(), + own_module: module.to_owned(), + component: declaration.name().to_owned(), + lean_name: crate::backend::semantic::identifier(&format!( + "{lean_module}.{}", + declaration.name() + )), + modules: modules.clone(), + type_parameters, + parameters, + header, + } + }) + .collect() +} + +fn pi(binders: Vec, body: Term) -> Term { + if binders.is_empty() { + body + } else { + Term::Pi { + binders, + body: Box::new(body), + } + } +} +fn app(function: Term, arguments: Vec) -> Term { + if arguments.is_empty() { + function + } else { + Term::App { + function: Box::new(function), + explicit_args: arguments, + omitted_implicit_binders: Vec::new(), + } + } +} +fn core(core: CoreRef, arguments: Vec) -> Term { + app(Term::Global(GlobalRef::Core(core), Vec::new()), arguments) +} + +struct Convert<'a, 'b> { + export: &'a SemanticExport, + closure: &'a Closure, + alloc: &'b mut LocalAlloc, + locals: BTreeMap, +} +impl Convert<'_, '_> { + fn bind(&mut self, name: &str, ty: Term) -> Binder { + let id = self.alloc.fresh(); + self.locals.insert(name.to_owned(), id); + Binder { + id, + mode: BinderMode::Explicit, + ty, + spelling: name.to_owned(), + } + } + fn local(&self, name: &str) -> Result { + self.locals + .get(name) + .copied() + .map(Term::Local) + .ok_or_else(|| format!("semantic header has no scoped binder `{name}`")) + } + // These names are fixed by the semantic backend, never inferred from a + // claimed glossary signature. Use an actual closure reference so normal + // external probing and source attribution remain unchanged. + fn builtin(&self, name: &str) -> Result { + for package in &self.closure.packages { + for (id, entry) in &package.entries { + if let Denotation::Lean { + module, + name: actual, + } = &entry.denotation + { + if module == "Init" && actual == name { + if let Some(signature_hash) = entry.signature_hash { + return Ok(Term::Global( + GlobalRef::External(ExternalConstRef { + package: package.id.clone(), + entry: format!("{}::{id}", package.id), + lean_module: module.clone(), + lean_name: actual.clone(), + signature_hash, + }), + Vec::new(), + )); + } + } + } + } + } + Err(format!("semantic header uses `{name}`, which has no declared glossary denotation in the closure")) + } + fn member(&self, member: &MemberRef) -> Result { + if member.module.is_none() { + if let Some((owner, _)) = member.name.split_once('.') { + if matches!( + owner, + "Nat" | "Bool" | "Unit" | "Option" | "List" | "Result" + ) { + let name = member.name.replacen("Result.", "Except.", 1); + return self.builtin(&name); + } + } + } + let module = member.module.as_deref().unwrap_or(&self.export.own_module); + let lean = self.export.modules.get(module).ok_or_else(|| { + format!( + "semantic header member `{module}::{}` is outside its validated direct imports", + member.name + ) + })?; + Ok(Term::Global( + GlobalRef::Document(DocumentDeclRef { + module: module.to_owned(), + component: member.name.clone(), + lean_name: crate::backend::semantic::identifier(&format!("{lean}.{}", member.name)), + }), + Vec::new(), + )) + } + fn ty(&mut self, ty: &SemanticType) -> Result { + use SemanticType as T; + Ok(match ty { + T::Type => Term::Sort(Universe::Num(1)), + T::Prop => Term::Sort(Universe::Num(0)), + T::Parameter { name } => self.local(name)?, + T::Named { member, arguments } => { + let function = self.member(member)?; + let args = arguments + .iter() + .map(|argument| self.ty(argument)) + .collect::, _>>()?; + app(function, args) + } + T::Function { parameters, result } => { + let mut binders = Vec::new(); + for parameter in parameters { + let ty = self.ty(parameter)?; + binders.push(Binder { + id: self.alloc.fresh(), + mode: BinderMode::Explicit, + ty, + spelling: String::new(), + }); + } + pi(binders, self.ty(result)?) + } + T::Option { value } => { + let value = self.ty(value)?; + app(self.builtin("Option")?, vec![value]) + } + T::Result { ok, error } => { + let error = self.ty(error)?; + let ok = self.ty(ok)?; + app(self.builtin("Except")?, vec![error, ok]) + } + T::List { element } | T::Set { element } => { + let element = self.ty(element)?; + app(self.builtin("List")?, vec![element]) + } + T::Product { left, right } + | T::Map { + key: left, + value: right, + } => { + let left = self.ty(left)?; + let right = self.ty(right)?; + let pair = app(self.builtin("Prod")?, vec![left, right]); + if matches!(ty, T::Map { .. }) { + app(self.builtin("List")?, vec![pair]) + } else { + pair + } + } + T::ContractViolation | T::ReasoningFailure => { + let boolean = self.builtin("Bool")?; + app(self.builtin("Prod")?, vec![boolean.clone(), boolean]) + } + T::Nat => self.builtin("Nat")?, + T::Bool => self.builtin("Bool")?, + T::Unit => self.builtin("Unit")?, + T::Int => self.builtin("Int")?, + T::Int8 => self.builtin("Int8")?, + T::Int16 => self.builtin("Int16")?, + T::Int32 => self.builtin("Int32")?, + T::Int64 => self.builtin("Int64")?, + T::UInt8 => self.builtin("UInt8")?, + T::UInt16 => self.builtin("UInt16")?, + T::UInt32 => self.builtin("UInt32")?, + T::UInt64 => self.builtin("UInt64")?, + T::String => self.builtin("String")?, + T::Bytes => self.builtin("ByteArray")?, + T::Ordering => self.builtin("Ordering")?, + }) + } + #[allow(clippy::too_many_lines)] + fn term(&mut self, term: &SemanticTerm) -> Result { + use SemanticTerm as S; + Ok(match term { + S::Var { name } => self.local(name)?, + S::Nat { value } => Term::NatLiteral { decimal: value.clone(), expected_type: Box::new(self.builtin("Nat")?) }, + S::Bool { value } => self.builtin(if *value { "Bool.true" } else { "Bool.false" })?, + S::Unit => self.builtin("Unit.unit")?, + S::Call { function, type_arguments, arguments } | S::Constructor { constructor: function, type_arguments, arguments } => { + let head = self.member(function)?; + let mut args = type_arguments.iter().map(|ty| self.ty(ty)).collect::, _>>()?; + args.extend(arguments.iter().map(|term| self.term(term)).collect::, _>>()?); + app(head, args) + } + S::FunctionRef { function, type_arguments } => { + let head = self.member(function)?; + app(head, type_arguments.iter().map(|ty| self.ty(ty)).collect::, _>>()?) + } + S::Apply { function, arguments } => { + let function = self.term(function)?; + app(function, arguments.iter().map(|arg| self.term(arg)).collect::, _>>()?) + } + S::Add { left, right } | S::Le { left, right } | S::Lt { left, right } | S::Beq { left, right } | S::Ble { left, right } | S::Blt { left, right } | S::And { left, right } | S::Or { left, right } => { + let name = match term { S::Add { .. } => "Nat.add", S::Le { .. } => "Nat.le", S::Lt { .. } => "Nat.lt", S::Beq { .. } => "Nat.beq", S::Ble { .. } => "Nat.ble", S::Blt { .. } => "Nat.blt", S::And { .. } => "Bool.and", _ => "Bool.or" }; + app(self.builtin(name)?, vec![self.term(left)?, self.term(right)?]) + } + S::Not { value } => app(self.builtin("Bool.not")?, vec![self.term(value)?]), + S::Eq { left, right } => core(CoreRef::Eq, vec![self.term(left)?, self.term(right)?]), + S::PropAnd { left, right } => core(CoreRef::And, vec![self.term(left)?, self.term(right)?]), + S::Iff { left, right } => core(CoreRef::Iff, vec![self.term(left)?, self.term(right)?]), + S::Implies { premise, conclusion } => { + let premise = self.term(premise)?; let conclusion = self.term(conclusion)?; + pi(vec![Binder { id: self.alloc.fresh(), mode: BinderMode::Explicit, ty: premise, spelling: String::new() }], conclusion) + } + S::Forall { binder, body } => { + let saved = self.locals.clone(); let ty = self.ty(&binder.r#type)?; + let binder = self.bind(&binder.name, ty); let body = self.term(body)?; self.locals = saved; + pi(vec![binder], body) + } + S::Lambda { parameters, body, .. } => { + let saved = self.locals.clone(); let mut binders = Vec::new(); + for parameter in parameters { let ty = self.ty(¶meter.r#type)?; binders.push(self.bind(¶meter.name, ty)); } + let body = self.term(body)?; self.locals = saved; + Term::Lambda { binders, body: Box::new(body) } + } + S::Let { binder, value, body } => { + let saved = self.locals.clone(); let ty = self.ty(&binder.r#type)?; let value = self.term(value)?; + let binder = self.bind(&binder.name, ty); let body = self.term(body)?; self.locals = saved; + Term::Let { binder: Box::new(binder), value: Box::new(value), body: Box::new(body) } + } + other => return Err(format!("semantic theorem header has no exact prose LSE representation for `{}`; name that expression with a typed semantic definition before referring to the theorem", term_kind(other))), + }) + } +} +fn term_kind(term: &SemanticTerm) -> &'static str { + match term { + SemanticTerm::Integer { .. } => "integer", + SemanticTerm::String { .. } => "string", + SemanticTerm::Bytes { .. } => "bytes", + SemanticTerm::Primitive { .. } => "primitive", + SemanticTerm::Nil { .. } => "nil", + SemanticTerm::Cons { .. } => "cons", + SemanticTerm::Record { .. } => "record", + SemanticTerm::InstanceValue { .. } => "instance_value", + SemanticTerm::Project { .. } => "project", + SemanticTerm::If { .. } => "if", + SemanticTerm::Match { .. } => "match", + SemanticTerm::Le { .. } => "le", + SemanticTerm::Lt { .. } => "lt", + SemanticTerm::Add { .. } => "add", + SemanticTerm::Beq { .. } => "beq", + SemanticTerm::Ble { .. } => "ble", + SemanticTerm::Blt { .. } => "blt", + SemanticTerm::And { .. } => "and", + SemanticTerm::Or { .. } => "or", + SemanticTerm::Not { .. } => "not", + SemanticTerm::Pair { .. } => "pair", + SemanticTerm::First { .. } => "first", + SemanticTerm::Second { .. } => "second", + SemanticTerm::MapLiteral { .. } => "map_literal", + SemanticTerm::SetLiteral { .. } => "set_literal", + SemanticTerm::GraphLiteral { .. } => "graph_literal", + SemanticTerm::CheckedApply { .. } => "checked_apply", + SemanticTerm::Var { .. } + | SemanticTerm::Nat { .. } + | SemanticTerm::Bool { .. } + | SemanticTerm::Unit + | SemanticTerm::Constructor { .. } + | SemanticTerm::Call { .. } + | SemanticTerm::Eq { .. } + | SemanticTerm::PropAnd { .. } + | SemanticTerm::Implies { .. } + | SemanticTerm::Iff { .. } + | SemanticTerm::Forall { .. } + | SemanticTerm::Let { .. } + | SemanticTerm::Lambda { .. } + | SemanticTerm::Apply { .. } + | SemanticTerm::FunctionRef { .. } => "represented term", + } +} diff --git a/crates/lexlean/src/link.rs b/crates/lexlean/src/link.rs index 50bbbb8108..6cfc178430 100644 --- a/crates/lexlean/src/link.rs +++ b/crates/lexlean/src/link.rs @@ -751,6 +751,16 @@ fn check_project_inline( } } + for row in &decls.semantic { + if imports.contains(&row.module) { + let mut visible_row = row.clone(); + if let Some(written) = renamed.get(&row.module) { + visible_row.module = written.clone(); + } + module_decls.semantic.push(visible_row); + } + } + // A package module is named by its Lean name throughout the linked // project; the project's own are named under the project's prefix. let lean_module = if load.package.is_some() { @@ -1192,6 +1202,17 @@ fn check_project_inline( return Err(err(vec![Diagnostic::new(code!("LLL1005"), reason)])); } + // Publish semantic headers only after this module's own validation, + // production checks and complete source closure have succeeded. + if let Some(semantic) = &document.semantic { + decls.semantic.extend(crate::elaborate::semantic::exports( + module_name, + &document.lean_module, + semantic, + &document.import_lean, + )); + } + modules.insert( module_name.clone(), CheckedModule { diff --git a/features/suites/lexicon.feature b/features/suites/lexicon.feature index 1276e49a29..1f1c1147d9 100644 --- a/features/suites/lexicon.feature +++ b/features/suites/lexicon.feature @@ -129,3 +129,9 @@ Feature: lexicon Then each package mismatch fails lock with LLC0103 naming both languages And the tampered lock fails check and `lock --check` with LLC0102 And build refuses every project and no build or verification root exists + + @GL-22 @build + Scenario: Document denotations over exported semantic-module inductive and structure types, definitions, and theorems resolve through explicit module imports with their exact canonical signatures and generated Lean names; unavailable declarations and mismatching signatures are refused before verification. + Given a language 1.2 project with an imported semantic Color inductive and a document type-noun + When the importing prose theorem quantifies over color and checks + Then the exact empty-policy reflexivity theorem checks successfully diff --git a/model/ids.toml b/model/ids.toml index d9c5959a38..9ce71bdc74 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -424,6 +424,12 @@ level = "build" suite = "lexicon" statement = "Cross-version package, lexicon, and lock combinations fail closed before backend execution." +[[id]] +id = "GL-22" +level = "build" +suite = "lexicon" +statement = "Document denotations over exported semantic-module inductive and structure types, definitions, and theorems resolve through explicit module imports with their exact canonical signatures and generated Lean names; unavailable declarations and mismatching signatures are refused before verification." + [[id]] id = "GR-01" level = "build" diff --git a/spec/src/Chapter17.lex.tex b/spec/src/Chapter17.lex.tex index 07a1e03b2c..cc51595597 100644 --- a/spec/src/Chapter17.lex.tex +++ b/spec/src/Chapter17.lex.tex @@ -426,6 +426,20 @@ name: i0033, parameters: [], result: DocRows::Item, + body: constructor{ + arguments: [ + (cons "An imported semantic module exposes its inductive and structure types, definitions, and theorems to document denotations after that module links successfully. The actual declaration's complete explicit type-parameter and value-parameter telescope, result type or proposition, category, and generated Lean name determine the reference; a glossary signature cannot replace them. The signature must have an exact representation in the existing canonical LSE. If it does not, linking refuses the prose use and names the unsupported signature construct. Unused semantic declarations are unaffected. Classes, instances, and model-, reasoning- or text-generated declarations are not implicitly exposed by this document bridge; a refusal identifies the declaration kind. This does not change their semantic-module availability or generated Lean declarations." (nil String)) + ], + constructor: DocRows::Item.para, + type_arguments: [] + }, + executable: true +} + +definition{ + name: i0034, + parameters: [], + result: DocRows::Item, body: constructor{ arguments: [3, 1, "17.8 Name generation"], constructor: DocRows::Item.heading, @@ -435,7 +449,7 @@ } definition{ - name: i0034, + name: i0035, parameters: [], result: DocRows::Item, body: constructor{ @@ -449,7 +463,7 @@ } definition{ - name: i0035, + name: i0036, parameters: [], result: DocRows::Item, body: constructor{ @@ -461,7 +475,7 @@ } definition{ - name: i0036, + name: i0037, parameters: [], result: DocRows::Item, body: constructor{ @@ -475,7 +489,7 @@ } definition{ - name: i0037, + name: i0038, parameters: [], result: DocRows::Item, body: constructor{ @@ -489,7 +503,7 @@ } definition{ - name: i0038, + name: i0039, parameters: [], result: DocRows::Item, body: constructor{ @@ -503,7 +517,7 @@ } definition{ - name: i0039, + name: i0040, parameters: [], result: DocRows::Item, body: constructor{ @@ -515,7 +529,7 @@ } definition{ - name: i0040, + name: i0041, parameters: [], result: DocRows::Item, body: constructor{ @@ -529,7 +543,7 @@ } definition{ - name: i0041, + name: i0042, parameters: [], result: DocRows::Item, body: constructor{ @@ -543,7 +557,7 @@ } definition{ - name: i0042, + name: i0043, parameters: [], result: DocRows::Item, body: constructor{ @@ -557,7 +571,7 @@ } definition{ - name: i0043, + name: i0044, parameters: [], result: DocRows::Item, body: constructor{ @@ -571,7 +585,7 @@ } definition{ - name: i0044, + name: i0045, parameters: [], result: DocRows::Item, body: constructor{ @@ -585,7 +599,7 @@ } definition{ - name: i0045, + name: i0046, parameters: [], result: DocRows::Item, body: constructor{ @@ -599,7 +613,7 @@ } definition{ - name: i0046, + name: i0047, parameters: [], result: DocRows::Item, body: constructor{ @@ -613,7 +627,7 @@ } definition{ - name: i0047, + name: i0048, parameters: [], result: DocRows::Item, body: constructor{ @@ -627,7 +641,7 @@ } definition{ - name: i0048, + name: i0049, parameters: [], result: DocRows::Item, body: constructor{ @@ -641,7 +655,7 @@ } definition{ - name: i0049, + name: i0050, parameters: [], result: DocRows::Item, body: constructor{ @@ -655,7 +669,7 @@ } definition{ - name: i0050, + name: i0051, parameters: [], result: DocRows::Item, body: constructor{ @@ -667,7 +681,7 @@ } definition{ - name: i0051, + name: i0052, parameters: [], result: DocRows::Item, body: constructor{ @@ -681,7 +695,7 @@ } definition{ - name: i0052, + name: i0053, parameters: [], result: DocRows::Item, body: constructor{ @@ -695,7 +709,7 @@ } definition{ - name: i0053, + name: i0054, parameters: [], result: DocRows::Item, body: constructor{ @@ -709,7 +723,7 @@ } definition{ - name: i0054, + name: i0055, parameters: [], result: DocRows::Item, body: constructor{ @@ -723,7 +737,7 @@ } definition{ - name: i0055, + name: i0056, parameters: [], result: DocRows::Item, body: constructor{ @@ -737,7 +751,7 @@ } definition{ - name: i0056, + name: i0057, parameters: [], result: DocRows::Item, body: constructor{ @@ -751,7 +765,7 @@ } definition{ - name: i0057, + name: i0058, parameters: [], result: DocRows::Item, body: constructor{ @@ -765,7 +779,7 @@ } definition{ - name: i0058, + name: i0059, parameters: [], result: DocRows::Item, body: constructor{ @@ -779,7 +793,7 @@ } definition{ - name: i0059, + name: i0060, parameters: [], result: DocRows::Item, body: constructor{ @@ -793,7 +807,7 @@ } definition{ - name: i0060, + name: i0061, parameters: [], result: DocRows::Item, body: constructor{ @@ -807,7 +821,7 @@ } definition{ - name: i0061, + name: i0062, parameters: [], result: DocRows::Item, body: constructor{ @@ -821,7 +835,7 @@ } definition{ - name: i0062, + name: i0063, parameters: [], result: DocRows::Item, body: constructor{ @@ -835,7 +849,7 @@ } definition{ - name: i0063, + name: i0064, parameters: [], result: DocRows::Item, body: constructor{ @@ -849,7 +863,7 @@ } definition{ - name: i0064, + name: i0065, parameters: [], result: DocRows::Item, body: constructor{ @@ -863,7 +877,7 @@ } definition{ - name: i0065, + name: i0066, parameters: [], result: DocRows::Item, body: constructor{ @@ -877,7 +891,7 @@ } definition{ - name: i0066, + name: i0067, parameters: [], result: DocRows::Item, body: constructor{ @@ -891,7 +905,7 @@ } definition{ - name: i0067, + name: i0068, parameters: [], result: DocRows::Item, body: constructor{ @@ -903,7 +917,7 @@ } definition{ - name: i0068, + name: i0069, parameters: [], result: DocRows::Item, body: constructor{ @@ -917,7 +931,7 @@ } definition{ - name: i0069, + name: i0070, parameters: [], result: DocRows::Item, body: constructor{ @@ -931,7 +945,7 @@ } definition{ - name: i0070, + name: i0071, parameters: [], result: DocRows::Item, body: constructor{ @@ -943,7 +957,7 @@ } definition{ - name: i0071, + name: i0072, parameters: [], result: DocRows::Item, body: constructor{ @@ -957,7 +971,7 @@ } definition{ - name: i0072, + name: i0073, parameters: [], result: DocRows::Item, body: constructor{ @@ -971,7 +985,7 @@ } definition{ - name: i0073, + name: i0074, parameters: [], result: DocRows::Item, body: constructor{ @@ -985,7 +999,7 @@ } definition{ - name: i0074, + name: i0075, parameters: [], result: DocRows::Item, body: constructor{ @@ -999,7 +1013,7 @@ } definition{ - name: i0075, + name: i0076, parameters: [], result: DocRows::Item, body: constructor{ @@ -1011,7 +1025,7 @@ } definition{ - name: i0076, + name: i0077, parameters: [], result: DocRows::Item, body: constructor{ @@ -1025,7 +1039,7 @@ } definition{ - name: i0077, + name: i0078, parameters: [], result: DocRows::Item, body: constructor{ @@ -1039,7 +1053,7 @@ } definition{ - name: i0078, + name: i0079, parameters: [], result: DocRows::Item, body: constructor{ @@ -1051,7 +1065,7 @@ } definition{ - name: i0079, + name: i0080, parameters: [], result: DocRows::Item, body: constructor{ @@ -1065,7 +1079,7 @@ } definition{ - name: i0080, + name: i0081, parameters: [], result: DocRows::Item, body: constructor{ @@ -1079,7 +1093,7 @@ } definition{ - name: i0081, + name: i0082, parameters: [], result: DocRows::Item, body: constructor{ @@ -1093,7 +1107,7 @@ } definition{ - name: i0082, + name: i0083, parameters: [], result: DocRows::Item, body: constructor{ @@ -1105,7 +1119,7 @@ } definition{ - name: i0083, + name: i0084, parameters: [], result: DocRows::Item, body: constructor{ @@ -1119,7 +1133,7 @@ } definition{ - name: i0084, + name: i0085, parameters: [], result: DocRows::Item, body: constructor{ @@ -1133,7 +1147,7 @@ } definition{ - name: i0085, + name: i0086, parameters: [], result: DocRows::Item, body: constructor{ @@ -1147,7 +1161,7 @@ } definition{ - name: i0086, + name: i0087, parameters: [], result: DocRows::Item, body: constructor{ @@ -1161,7 +1175,7 @@ } definition{ - name: i0087, + name: i0088, parameters: [], result: DocRows::Item, body: constructor{ @@ -1173,7 +1187,7 @@ } definition{ - name: i0088, + name: i0089, parameters: [], result: DocRows::Item, body: constructor{ @@ -1187,7 +1201,7 @@ } definition{ - name: i0089, + name: i0090, parameters: [], result: DocRows::Item, body: constructor{ @@ -1201,7 +1215,7 @@ } definition{ - name: i0090, + name: i0091, parameters: [], result: DocRows::Item, body: constructor{ @@ -1215,7 +1229,7 @@ } definition{ - name: i0091, + name: i0092, parameters: [], result: DocRows::Item, body: constructor{ @@ -1229,7 +1243,7 @@ } definition{ - name: i0092, + name: i0093, parameters: [], result: DocRows::Item, body: constructor{ @@ -1243,7 +1257,7 @@ } definition{ - name: i0093, + name: i0094, parameters: [], result: DocRows::Item, body: constructor{ @@ -1255,7 +1269,7 @@ } definition{ - name: i0094, + name: i0095, parameters: [], result: DocRows::Item, body: constructor{ @@ -1269,7 +1283,7 @@ } definition{ - name: i0095, + name: i0096, parameters: [], result: DocRows::Item, body: constructor{ @@ -1283,7 +1297,7 @@ } definition{ - name: i0096, + name: i0097, parameters: [], result: DocRows::Item, body: constructor{ @@ -1295,7 +1309,7 @@ } definition{ - name: i0097, + name: i0098, parameters: [], result: DocRows::Item, body: constructor{ @@ -1309,7 +1323,7 @@ } definition{ - name: i0098, + name: i0099, parameters: [], result: DocRows::Item, body: constructor{ @@ -1323,7 +1337,7 @@ } definition{ - name: i0099, + name: i0100, parameters: [], result: DocRows::Item, body: constructor{ @@ -1337,7 +1351,7 @@ } definition{ - name: i0100, + name: i0101, parameters: [], result: DocRows::Item, body: constructor{ @@ -1351,7 +1365,7 @@ } definition{ - name: i0101, + name: i0102, parameters: [], result: DocRows::Item, body: constructor{ @@ -1365,7 +1379,7 @@ } definition{ - name: i0102, + name: i0103, parameters: [], result: DocRows::Item, body: constructor{ @@ -1379,7 +1393,7 @@ } definition{ - name: i0103, + name: i0104, parameters: [], result: DocRows::Item, body: constructor{ @@ -1393,7 +1407,7 @@ } definition{ - name: i0104, + name: i0105, parameters: [], result: DocRows::Item, body: constructor{ @@ -1407,7 +1421,7 @@ } definition{ - name: i0105, + name: i0106, parameters: [], result: DocRows::Item, body: constructor{ @@ -1421,7 +1435,7 @@ } definition{ - name: i0106, + name: i0107, parameters: [], result: DocRows::Item, body: constructor{ @@ -1435,7 +1449,7 @@ } definition{ - name: i0107, + name: i0108, parameters: [], result: DocRows::Item, body: constructor{ @@ -1449,7 +1463,7 @@ } definition{ - name: i0108, + name: i0109, parameters: [], result: DocRows::Item, body: constructor{ @@ -1463,7 +1477,7 @@ } definition{ - name: i0109, + name: i0110, parameters: [], result: DocRows::Item, body: constructor{ @@ -1475,7 +1489,7 @@ } definition{ - name: i0110, + name: i0111, parameters: [], result: DocRows::Item, body: constructor{ @@ -1489,7 +1503,7 @@ } definition{ - name: i0111, + name: i0112, parameters: [], result: DocRows::Item, body: constructor{ @@ -1503,7 +1517,7 @@ } definition{ - name: i0112, + name: i0113, parameters: [], result: DocRows::Item, body: constructor{ @@ -1517,7 +1531,7 @@ } definition{ - name: i0113, + name: i0114, parameters: [], result: DocRows::Item, body: constructor{ @@ -1531,7 +1545,7 @@ } definition{ - name: i0114, + name: i0115, parameters: [], result: DocRows::Item, body: constructor{ @@ -1545,7 +1559,7 @@ } definition{ - name: i0115, + name: i0116, parameters: [], result: DocRows::Item, body: constructor{ @@ -1559,7 +1573,7 @@ } definition{ - name: i0116, + name: i0117, parameters: [], result: DocRows::Item, body: constructor{ @@ -1571,7 +1585,7 @@ } definition{ - name: i0117, + name: i0118, parameters: [], result: DocRows::Item, body: constructor{ @@ -1585,7 +1599,7 @@ } definition{ - name: i0118, + name: i0119, parameters: [], result: DocRows::Item, body: constructor{ @@ -1599,7 +1613,7 @@ } definition{ - name: i0119, + name: i0120, parameters: [], result: DocRows::Item, body: constructor{ @@ -1613,7 +1627,7 @@ } definition{ - name: i0120, + name: i0121, parameters: [], result: DocRows::Item, body: constructor{ @@ -1627,7 +1641,7 @@ } definition{ - name: i0121, + name: i0122, parameters: [], result: DocRows::Item, body: constructor{ @@ -1639,7 +1653,7 @@ } definition{ - name: i0122, + name: i0123, parameters: [], result: DocRows::Item, body: constructor{ @@ -1653,7 +1667,7 @@ } definition{ - name: i0123, + name: i0124, parameters: [], result: DocRows::Item, body: constructor{ @@ -1667,7 +1681,7 @@ } definition{ - name: i0124, + name: i0125, parameters: [], result: DocRows::Item, body: constructor{ @@ -1681,7 +1695,7 @@ } definition{ - name: i0125, + name: i0126, parameters: [], result: DocRows::Item, body: constructor{ @@ -1695,7 +1709,7 @@ } definition{ - name: i0126, + name: i0127, parameters: [], result: DocRows::Item, body: constructor{ @@ -1709,7 +1723,7 @@ } definition{ - name: i0127, + name: i0128, parameters: [], result: DocRows::Item, body: constructor{ @@ -1721,7 +1735,7 @@ } definition{ - name: i0128, + name: i0129, parameters: [], result: DocRows::Item, body: constructor{ @@ -1735,7 +1749,7 @@ } definition{ - name: i0129, + name: i0130, parameters: [], result: DocRows::Item, body: constructor{ @@ -1749,7 +1763,7 @@ } definition{ - name: i0130, + name: i0131, parameters: [], result: DocRows::Item, body: constructor{ @@ -1763,7 +1777,7 @@ } definition{ - name: i0131, + name: i0132, parameters: [], result: DocRows::Item, body: constructor{ @@ -1777,7 +1791,7 @@ } definition{ - name: i0132, + name: i0133, parameters: [], result: DocRows::Item, body: constructor{ @@ -1791,7 +1805,7 @@ } definition{ - name: i0133, + name: i0134, parameters: [], result: DocRows::Item, body: constructor{ @@ -1803,7 +1817,7 @@ } definition{ - name: i0134, + name: i0135, parameters: [], result: DocRows::Item, body: constructor{ @@ -1817,7 +1831,7 @@ } definition{ - name: i0135, + name: i0136, parameters: [], result: DocRows::Item, body: constructor{ @@ -1832,7 +1846,7 @@ } definition{ - name: i0136, + name: i0137, parameters: [], result: DocRows::Item, body: constructor{ @@ -1846,7 +1860,7 @@ } definition{ - name: i0137, + name: i0138, parameters: [], result: DocRows::Item, body: constructor{ @@ -1858,7 +1872,7 @@ } definition{ - name: i0138, + name: i0139, parameters: [], result: DocRows::Item, body: constructor{ @@ -1872,7 +1886,7 @@ } definition{ - name: i0139, + name: i0140, parameters: [], result: DocRows::Item, body: constructor{ @@ -1886,7 +1900,7 @@ } definition{ - name: i0140, + name: i0141, parameters: [], result: DocRows::Item, body: constructor{ @@ -1900,7 +1914,7 @@ } definition{ - name: i0141, + name: i0142, parameters: [], result: DocRows::Item, body: constructor{ @@ -1914,7 +1928,7 @@ } definition{ - name: i0142, + name: i0143, parameters: [], result: DocRows::Item, body: constructor{ @@ -1928,7 +1942,7 @@ } definition{ - name: i0143, + name: i0144, parameters: [], result: DocRows::Item, body: constructor{ @@ -1942,7 +1956,7 @@ } definition{ - name: i0144, + name: i0145, parameters: [], result: DocRows::Item, body: constructor{ @@ -1956,7 +1970,7 @@ } definition{ - name: i0145, + name: i0146, parameters: [], result: DocRows::Item, body: constructor{ @@ -1970,7 +1984,7 @@ } definition{ - name: i0146, + name: i0147, parameters: [], result: DocRows::Item, body: constructor{ @@ -1984,7 +1998,7 @@ } definition{ - name: i0147, + name: i0148, parameters: [], result: DocRows::Item, body: constructor{ @@ -1998,7 +2012,7 @@ } definition{ - name: i0148, + name: i0149, parameters: [], result: DocRows::Item, body: constructor{ @@ -2012,7 +2026,7 @@ } definition{ - name: i0149, + name: i0150, parameters: [], result: DocRows::Item, body: constructor{ @@ -2026,7 +2040,7 @@ } definition{ - name: i0150, + name: i0151, parameters: [], result: DocRows::Item, body: constructor{ @@ -2038,7 +2052,7 @@ } definition{ - name: i0151, + name: i0152, parameters: [], result: DocRows::Item, body: constructor{ @@ -2052,7 +2066,7 @@ } definition{ - name: i0152, + name: i0153, parameters: [], result: DocRows::Item, body: constructor{ @@ -2066,7 +2080,7 @@ } definition{ - name: i0153, + name: i0154, parameters: [], result: DocRows::Item, body: constructor{ @@ -2080,7 +2094,7 @@ } definition{ - name: i0154, + name: i0155, parameters: [], result: DocRows::Item, body: constructor{ @@ -2094,7 +2108,7 @@ } definition{ - name: i0155, + name: i0156, parameters: [], result: DocRows::Item, body: constructor{ @@ -2108,7 +2122,7 @@ } definition{ - name: i0156, + name: i0157, parameters: [], result: DocRows::Item, body: constructor{ @@ -2122,7 +2136,7 @@ } definition{ - name: i0157, + name: i0158, parameters: [], result: DocRows::Item, body: constructor{ @@ -2136,7 +2150,7 @@ } definition{ - name: i0158, + name: i0159, parameters: [], result: DocRows::Item, body: constructor{ @@ -2150,7 +2164,7 @@ } definition{ - name: i0159, + name: i0160, parameters: [], result: DocRows::Item, body: constructor{ @@ -2164,7 +2178,7 @@ } definition{ - name: i0160, + name: i0161, parameters: [], result: DocRows::Item, body: constructor{ @@ -2178,7 +2192,7 @@ } definition{ - name: i0161, + name: i0162, parameters: [], result: DocRows::Item, body: constructor{ @@ -2192,7 +2206,7 @@ } definition{ - name: i0162, + name: i0163, parameters: [], result: DocRows::Item, body: constructor{ @@ -2206,7 +2220,7 @@ } definition{ - name: i0163, + name: i0164, parameters: [], result: DocRows::Item, body: constructor{ @@ -2220,7 +2234,7 @@ } definition{ - name: i0164, + name: i0165, parameters: [], result: DocRows::Item, body: constructor{ @@ -2234,7 +2248,7 @@ } definition{ - name: i0165, + name: i0166, parameters: [], result: DocRows::Item, body: constructor{ @@ -2248,7 +2262,7 @@ } definition{ - name: i0166, + name: i0167, parameters: [], result: DocRows::Item, body: constructor{ @@ -2262,7 +2276,7 @@ } definition{ - name: i0167, + name: i0168, parameters: [], result: DocRows::Item, body: constructor{ @@ -2274,7 +2288,7 @@ } definition{ - name: i0168, + name: i0169, parameters: [], result: DocRows::Item, body: constructor{ @@ -2288,7 +2302,7 @@ } definition{ - name: i0169, + name: i0170, parameters: [], result: DocRows::Item, body: constructor{ @@ -2302,7 +2316,7 @@ } definition{ - name: i0170, + name: i0171, parameters: [], result: DocRows::Item, body: constructor{ @@ -2316,7 +2330,7 @@ } definition{ - name: i0171, + name: i0172, parameters: [], result: DocRows::Item, body: constructor{ @@ -2330,7 +2344,7 @@ } definition{ - name: i0172, + name: i0173, parameters: [], result: DocRows::Item, body: constructor{ @@ -2344,7 +2358,7 @@ } definition{ - name: i0173, + name: i0174, parameters: [], result: DocRows::Item, body: constructor{ @@ -2358,7 +2372,7 @@ } definition{ - name: i0174, + name: i0175, parameters: [], result: DocRows::Item, body: constructor{ @@ -2372,7 +2386,7 @@ } definition{ - name: i0175, + name: i0176, parameters: [], result: DocRows::Item, body: constructor{ @@ -2386,7 +2400,7 @@ } definition{ - name: i0176, + name: i0177, parameters: [], result: DocRows::Item, body: constructor{ @@ -2400,7 +2414,7 @@ } definition{ - name: i0177, + name: i0178, parameters: [], result: DocRows::Item, body: constructor{ @@ -2414,7 +2428,7 @@ } definition{ - name: i0178, + name: i0179, parameters: [], result: DocRows::Item, body: constructor{ @@ -2428,7 +2442,7 @@ } definition{ - name: i0179, + name: i0180, parameters: [], result: DocRows::Item, body: constructor{ @@ -2440,7 +2454,7 @@ } definition{ - name: i0180, + name: i0181, parameters: [], result: DocRows::Item, body: constructor{ @@ -2454,7 +2468,7 @@ } definition{ - name: i0181, + name: i0182, parameters: [], result: DocRows::Item, body: constructor{ @@ -2468,7 +2482,7 @@ } definition{ - name: i0182, + name: i0183, parameters: [], result: DocRows::Item, body: constructor{ @@ -2482,7 +2496,7 @@ } definition{ - name: i0183, + name: i0184, parameters: [], result: DocRows::Item, body: constructor{ @@ -2496,7 +2510,7 @@ } definition{ - name: i0184, + name: i0185, parameters: [], result: DocRows::Item, body: constructor{ @@ -2510,7 +2524,7 @@ } definition{ - name: i0185, + name: i0186, parameters: [], result: DocRows::Item, body: constructor{ @@ -2524,7 +2538,7 @@ } definition{ - name: i0186, + name: i0187, parameters: [], result: DocRows::Item, body: constructor{ @@ -2538,7 +2552,7 @@ } definition{ - name: i0187, + name: i0188, parameters: [], result: DocRows::Item, body: constructor{ @@ -2552,7 +2566,7 @@ } definition{ - name: i0188, + name: i0189, parameters: [], result: DocRows::Item, body: constructor{ @@ -2566,7 +2580,7 @@ } definition{ - name: i0189, + name: i0190, parameters: [], result: DocRows::Item, body: constructor{ @@ -2580,7 +2594,7 @@ } definition{ - name: i0190, + name: i0191, parameters: [], result: DocRows::Item, body: constructor{ @@ -2594,7 +2608,7 @@ } definition{ - name: i0191, + name: i0192, parameters: [], result: DocRows::Item, body: constructor{ @@ -2608,7 +2622,7 @@ } definition{ - name: i0192, + name: i0193, parameters: [], result: DocRows::Item, body: constructor{ @@ -2622,7 +2636,7 @@ } definition{ - name: i0193, + name: i0194, parameters: [], result: DocRows::Item, body: constructor{ @@ -2636,7 +2650,7 @@ } definition{ - name: i0194, + name: i0195, parameters: [], result: DocRows::Item, body: constructor{ @@ -2650,7 +2664,7 @@ } definition{ - name: i0195, + name: i0196, parameters: [], result: DocRows::Item, body: constructor{ @@ -2664,7 +2678,7 @@ } definition{ - name: i0196, + name: i0197, parameters: [], result: DocRows::Item, body: constructor{ @@ -2678,7 +2692,7 @@ } definition{ - name: i0197, + name: i0198, parameters: [], result: DocRows::Item, body: constructor{ @@ -2692,7 +2706,7 @@ } definition{ - name: i0198, + name: i0199, parameters: [], result: DocRows::Item, body: constructor{ @@ -2706,7 +2720,7 @@ } definition{ - name: i0199, + name: i0200, parameters: [], result: DocRows::Item, body: constructor{ @@ -2718,7 +2732,7 @@ } definition{ - name: i0200, + name: i0201, parameters: [], result: DocRows::Item, body: constructor{ @@ -2732,7 +2746,7 @@ } definition{ - name: i0201, + name: i0202, parameters: [], result: DocRows::Item, body: constructor{ @@ -2746,7 +2760,7 @@ } definition{ - name: i0202, + name: i0203, parameters: [], result: DocRows::Item, body: constructor{ @@ -2760,7 +2774,7 @@ } definition{ - name: i0203, + name: i0204, parameters: [], result: DocRows::Item, body: constructor{ @@ -2775,7 +2789,7 @@ } definition{ - name: i0204, + name: i0205, parameters: [], result: DocRows::Item, body: constructor{ @@ -2789,7 +2803,7 @@ } definition{ - name: i0205, + name: i0206, parameters: [], result: DocRows::Item, body: constructor{ @@ -2803,7 +2817,7 @@ } definition{ - name: i0206, + name: i0207, parameters: [], result: DocRows::Item, body: constructor{ @@ -2817,7 +2831,7 @@ } definition{ - name: i0207, + name: i0208, parameters: [], result: DocRows::Item, body: constructor{ @@ -2831,7 +2845,7 @@ } definition{ - name: i0208, + name: i0209, parameters: [], result: DocRows::Item, body: constructor{ @@ -2845,7 +2859,7 @@ } definition{ - name: i0209, + name: i0210, parameters: [], result: DocRows::Item, body: constructor{ @@ -2859,7 +2873,7 @@ } definition{ - name: i0210, + name: i0211, parameters: [], result: DocRows::Item, body: constructor{ @@ -2873,7 +2887,7 @@ } definition{ - name: i0211, + name: i0212, parameters: [], result: DocRows::Item, body: constructor{ @@ -2887,7 +2901,7 @@ } definition{ - name: i0212, + name: i0213, parameters: [], result: DocRows::Item, body: constructor{ @@ -2901,7 +2915,7 @@ } definition{ - name: i0213, + name: i0214, parameters: [], result: DocRows::Item, body: constructor{ @@ -2915,7 +2929,7 @@ } definition{ - name: i0214, + name: i0215, parameters: [], result: DocRows::Item, body: constructor{ @@ -2929,7 +2943,7 @@ } definition{ - name: i0215, + name: i0216, parameters: [], result: DocRows::Item, body: constructor{ @@ -2943,7 +2957,7 @@ } definition{ - name: i0216, + name: i0217, parameters: [], result: DocRows::Item, body: constructor{ @@ -2957,7 +2971,7 @@ } definition{ - name: i0217, + name: i0218, parameters: [], result: DocRows::Item, body: constructor{ @@ -2971,7 +2985,7 @@ } definition{ - name: i0218, + name: i0219, parameters: [], result: DocRows::Item, body: constructor{ @@ -2985,7 +2999,7 @@ } definition{ - name: i0219, + name: i0220, parameters: [], result: DocRows::Item, body: constructor{ @@ -2999,7 +3013,7 @@ } definition{ - name: i0220, + name: i0221, parameters: [], result: DocRows::Item, body: constructor{ @@ -3013,7 +3027,7 @@ } definition{ - name: i0221, + name: i0222, parameters: [], result: DocRows::Item, body: constructor{ @@ -3028,7 +3042,7 @@ } definition{ - name: i0222, + name: i0223, parameters: [], result: DocRows::Item, body: constructor{ @@ -3042,7 +3056,7 @@ } definition{ - name: i0223, + name: i0224, parameters: [], result: DocRows::Item, body: constructor{ @@ -3056,7 +3070,7 @@ } definition{ - name: i0224, + name: i0225, parameters: [], result: DocRows::Item, body: constructor{ @@ -3070,7 +3084,7 @@ } definition{ - name: i0225, + name: i0226, parameters: [], result: DocRows::Item, body: constructor{ @@ -3085,7 +3099,7 @@ } definition{ - name: i0226, + name: i0227, parameters: [], result: DocRows::Item, body: constructor{ @@ -3100,7 +3114,7 @@ } definition{ - name: i0227, + name: i0228, parameters: [], result: DocRows::Item, body: constructor{ @@ -3115,7 +3129,7 @@ } definition{ - name: i0228, + name: i0229, parameters: [], result: DocRows::Item, body: constructor{ @@ -3130,7 +3144,7 @@ } definition{ - name: i0229, + name: i0230, parameters: [], result: DocRows::Item, body: constructor{ @@ -3145,7 +3159,7 @@ } definition{ - name: i0230, + name: i0231, parameters: [], result: DocRows::Item, body: constructor{ @@ -3159,7 +3173,7 @@ } definition{ - name: i0231, + name: i0232, parameters: [], result: DocRows::Item, body: constructor{ @@ -3173,7 +3187,7 @@ } definition{ - name: i0232, + name: i0233, parameters: [], result: DocRows::Item, body: constructor{ @@ -3187,7 +3201,7 @@ } definition{ - name: i0233, + name: i0234, parameters: [], result: DocRows::Item, body: constructor{ @@ -3201,7 +3215,7 @@ } definition{ - name: i0234, + name: i0235, parameters: [], result: DocRows::Item, body: constructor{ @@ -3215,7 +3229,7 @@ } definition{ - name: i0235, + name: i0236, parameters: [], result: DocRows::Item, body: constructor{ @@ -3229,7 +3243,7 @@ } definition{ - name: i0236, + name: i0237, parameters: [], result: DocRows::Item, body: constructor{ @@ -3243,7 +3257,7 @@ } definition{ - name: i0237, + name: i0238, parameters: [], result: DocRows::Item, body: constructor{ @@ -3257,7 +3271,7 @@ } definition{ - name: i0238, + name: i0239, parameters: [], result: DocRows::Item, body: constructor{ @@ -3271,7 +3285,7 @@ } definition{ - name: i0239, + name: i0240, parameters: [], result: DocRows::Item, body: constructor{ @@ -3285,7 +3299,7 @@ } definition{ - name: i0240, + name: i0241, parameters: [], result: DocRows::Item, body: constructor{ @@ -3299,7 +3313,7 @@ } definition{ - name: i0241, + name: i0242, parameters: [], result: DocRows::Item, body: constructor{ @@ -3313,7 +3327,7 @@ } definition{ - name: i0242, + name: i0243, parameters: [], result: DocRows::Item, body: constructor{ @@ -3327,7 +3341,7 @@ } definition{ - name: i0243, + name: i0244, parameters: [], result: DocRows::Item, body: constructor{ @@ -3341,7 +3355,7 @@ } definition{ - name: i0244, + name: i0245, parameters: [], result: DocRows::Item, body: constructor{ @@ -3355,7 +3369,7 @@ } definition{ - name: i0245, + name: i0246, parameters: [], result: DocRows::Item, body: constructor{ @@ -3369,7 +3383,7 @@ } definition{ - name: i0246, + name: i0247, parameters: [], result: DocRows::Item, body: constructor{ @@ -3383,7 +3397,7 @@ } definition{ - name: i0247, + name: i0248, parameters: [], result: DocRows::Item, body: constructor{ @@ -3397,7 +3411,7 @@ } definition{ - name: i0248, + name: i0249, parameters: [], result: DocRows::Item, body: constructor{ @@ -3409,7 +3423,7 @@ } definition{ - name: i0249, + name: i0250, parameters: [], result: DocRows::Item, body: constructor{ @@ -3423,7 +3437,7 @@ } definition{ - name: i0250, + name: i0251, parameters: [], result: DocRows::Item, body: constructor{ @@ -3437,7 +3451,7 @@ } definition{ - name: i0251, + name: i0252, parameters: [], result: DocRows::Item, body: constructor{ @@ -3451,7 +3465,7 @@ } definition{ - name: i0252, + name: i0253, parameters: [], result: DocRows::Item, body: constructor{ @@ -3466,7 +3480,7 @@ } definition{ - name: i0253, + name: i0254, parameters: [], result: DocRows::Item, body: constructor{ @@ -3480,7 +3494,7 @@ } definition{ - name: i0254, + name: i0255, parameters: [], result: DocRows::Item, body: constructor{ @@ -3495,7 +3509,7 @@ } definition{ - name: i0255, + name: i0256, parameters: [], result: DocRows::Item, body: constructor{ @@ -3509,7 +3523,7 @@ } definition{ - name: i0256, + name: i0257, parameters: [], result: DocRows::Item, body: constructor{ @@ -3523,7 +3537,7 @@ } definition{ - name: i0257, + name: i0258, parameters: [], result: DocRows::Item, body: constructor{ @@ -3537,7 +3551,7 @@ } definition{ - name: i0258, + name: i0259, parameters: [], result: DocRows::Item, body: constructor{ @@ -3551,7 +3565,7 @@ } definition{ - name: i0259, + name: i0260, parameters: [], result: DocRows::Item, body: constructor{ @@ -3565,7 +3579,7 @@ } definition{ - name: i0260, + name: i0261, parameters: [], result: DocRows::Item, body: constructor{ @@ -3579,7 +3593,7 @@ } definition{ - name: i0261, + name: i0262, parameters: [], result: DocRows::Item, body: constructor{ @@ -3593,7 +3607,7 @@ } definition{ - name: i0262, + name: i0263, parameters: [], result: DocRows::Item, body: constructor{ @@ -3607,7 +3621,7 @@ } definition{ - name: i0263, + name: i0264, parameters: [], result: DocRows::Item, body: constructor{ @@ -3621,7 +3635,7 @@ } definition{ - name: i0264, + name: i0265, parameters: [], result: DocRows::Item, body: constructor{ @@ -3636,7 +3650,7 @@ } definition{ - name: i0265, + name: i0266, parameters: [], result: DocRows::Item, body: constructor{ @@ -3650,7 +3664,7 @@ } definition{ - name: i0266, + name: i0267, parameters: [], result: DocRows::Item, body: constructor{ @@ -3662,7 +3676,7 @@ } definition{ - name: i0267, + name: i0268, parameters: [], result: DocRows::Item, body: constructor{ @@ -3676,7 +3690,7 @@ } definition{ - name: i0268, + name: i0269, parameters: [], result: DocRows::Item, body: constructor{ @@ -3690,7 +3704,7 @@ } definition{ - name: i0269, + name: i0270, parameters: [], result: DocRows::Item, body: constructor{ @@ -3704,7 +3718,7 @@ } definition{ - name: i0270, + name: i0271, parameters: [], result: DocRows::Item, body: constructor{ @@ -3718,7 +3732,7 @@ } definition{ - name: i0271, + name: i0272, parameters: [], result: DocRows::Item, body: constructor{ @@ -3732,7 +3746,7 @@ } definition{ - name: i0272, + name: i0273, parameters: [], result: DocRows::Item, body: constructor{ @@ -3746,7 +3760,7 @@ } definition{ - name: i0273, + name: i0274, parameters: [], result: DocRows::Item, body: constructor{ @@ -3760,7 +3774,7 @@ } definition{ - name: i0274, + name: i0275, parameters: [], result: DocRows::Item, body: constructor{ @@ -3774,7 +3788,7 @@ } definition{ - name: i0275, + name: i0276, parameters: [], result: DocRows::Item, body: constructor{ @@ -3788,7 +3802,7 @@ } definition{ - name: i0276, + name: i0277, parameters: [], result: DocRows::Item, body: constructor{ @@ -3802,7 +3816,7 @@ } definition{ - name: i0277, + name: i0278, parameters: [], result: DocRows::Item, body: constructor{ @@ -3816,7 +3830,7 @@ } definition{ - name: i0278, + name: i0279, parameters: [], result: DocRows::Item, body: constructor{ @@ -3830,7 +3844,7 @@ } definition{ - name: i0279, + name: i0280, parameters: [], result: DocRows::Item, body: constructor{ @@ -3844,7 +3858,7 @@ } definition{ - name: i0280, + name: i0281, parameters: [], result: DocRows::Item, body: constructor{ @@ -3858,7 +3872,7 @@ } definition{ - name: i0281, + name: i0282, parameters: [], result: DocRows::Item, body: constructor{ @@ -3872,7 +3886,7 @@ } definition{ - name: i0282, + name: i0283, parameters: [], result: DocRows::Item, body: constructor{ @@ -3886,7 +3900,7 @@ } definition{ - name: i0283, + name: i0284, parameters: [], result: DocRows::Item, body: constructor{ @@ -3900,7 +3914,7 @@ } definition{ - name: i0284, + name: i0285, parameters: [], result: DocRows::Item, body: constructor{ @@ -3912,7 +3926,7 @@ } definition{ - name: i0285, + name: i0286, parameters: [], result: DocRows::Item, body: constructor{ @@ -3926,7 +3940,7 @@ } definition{ - name: i0286, + name: i0287, parameters: [], result: DocRows::Item, body: constructor{ @@ -3940,7 +3954,7 @@ } definition{ - name: i0287, + name: i0288, parameters: [], result: DocRows::Item, body: constructor{ @@ -3954,7 +3968,7 @@ } definition{ - name: i0288, + name: i0289, parameters: [], result: DocRows::Item, body: constructor{ @@ -3968,7 +3982,7 @@ } definition{ - name: i0289, + name: i0290, parameters: [], result: DocRows::Item, body: constructor{ @@ -3982,7 +3996,7 @@ } definition{ - name: i0290, + name: i0291, parameters: [], result: DocRows::Item, body: constructor{ @@ -3996,7 +4010,7 @@ } definition{ - name: i0291, + name: i0292, parameters: [], result: DocRows::Item, body: constructor{ @@ -4010,7 +4024,7 @@ } definition{ - name: i0292, + name: i0293, parameters: [], result: DocRows::Item, body: constructor{ @@ -4024,7 +4038,7 @@ } definition{ - name: i0293, + name: i0294, parameters: [], result: DocRows::Item, body: constructor{ @@ -4038,7 +4052,7 @@ } definition{ - name: i0294, + name: i0295, parameters: [], result: DocRows::Item, body: constructor{ @@ -4052,7 +4066,7 @@ } definition{ - name: i0295, + name: i0296, parameters: [], result: DocRows::Item, body: constructor{ @@ -4066,7 +4080,7 @@ } definition{ - name: i0296, + name: i0297, parameters: [], result: DocRows::Item, body: constructor{ @@ -4080,7 +4094,7 @@ } definition{ - name: i0297, + name: i0298, parameters: [], result: DocRows::Item, body: constructor{ @@ -4094,7 +4108,7 @@ } definition{ - name: i0298, + name: i0299, parameters: [], result: DocRows::Item, body: constructor{ @@ -4108,7 +4122,7 @@ } definition{ - name: i0299, + name: i0300, parameters: [], result: DocRows::Item, body: constructor{ @@ -4122,7 +4136,7 @@ } definition{ - name: i0300, + name: i0301, parameters: [], result: DocRows::Item, body: constructor{ @@ -4136,7 +4150,7 @@ } definition{ - name: i0301, + name: i0302, parameters: [], result: DocRows::Item, body: constructor{ @@ -4150,7 +4164,7 @@ } definition{ - name: i0302, + name: i0303, parameters: [], result: DocRows::Item, body: constructor{ @@ -4164,7 +4178,7 @@ } definition{ - name: i0303, + name: i0304, parameters: [], result: DocRows::Item, body: constructor{ @@ -4178,7 +4192,7 @@ } definition{ - name: i0304, + name: i0305, parameters: [], result: DocRows::Item, body: constructor{ @@ -4190,7 +4204,7 @@ } definition{ - name: i0305, + name: i0306, parameters: [], result: DocRows::Item, body: constructor{ @@ -4204,7 +4218,7 @@ } definition{ - name: i0306, + name: i0307, parameters: [], result: DocRows::Item, body: constructor{ @@ -4218,7 +4232,7 @@ } definition{ - name: i0307, + name: i0308, parameters: [], result: DocRows::Item, body: constructor{ @@ -4232,7 +4246,7 @@ } definition{ - name: i0308, + name: i0309, parameters: [], result: DocRows::Item, body: constructor{ @@ -4246,7 +4260,7 @@ } definition{ - name: i0309, + name: i0310, parameters: [], result: DocRows::Item, body: constructor{ @@ -4260,7 +4274,7 @@ } definition{ - name: i0310, + name: i0311, parameters: [], result: DocRows::Item, body: constructor{ @@ -4274,7 +4288,7 @@ } definition{ - name: i0311, + name: i0312, parameters: [], result: DocRows::Item, body: constructor{ @@ -4288,7 +4302,7 @@ } definition{ - name: i0312, + name: i0313, parameters: [], result: DocRows::Item, body: constructor{ @@ -4302,7 +4316,7 @@ } definition{ - name: i0313, + name: i0314, parameters: [], result: DocRows::Item, body: constructor{ @@ -4316,7 +4330,7 @@ } definition{ - name: i0314, + name: i0315, parameters: [], result: DocRows::Item, body: constructor{ @@ -4330,7 +4344,7 @@ } definition{ - name: i0315, + name: i0316, parameters: [], result: DocRows::Item, body: constructor{ @@ -4344,7 +4358,7 @@ } definition{ - name: i0316, + name: i0317, parameters: [], result: DocRows::Item, body: constructor{ @@ -4358,7 +4372,7 @@ } definition{ - name: i0317, + name: i0318, parameters: [], result: DocRows::Item, body: constructor{ @@ -4372,7 +4386,7 @@ } definition{ - name: i0318, + name: i0319, parameters: [], result: DocRows::Item, body: constructor{ @@ -4386,7 +4400,7 @@ } definition{ - name: i0319, + name: i0320, parameters: [], result: DocRows::Item, body: constructor{ @@ -4398,7 +4412,7 @@ } definition{ - name: i0320, + name: i0321, parameters: [], result: DocRows::Item, body: constructor{ @@ -4412,7 +4426,7 @@ } definition{ - name: i0321, + name: i0322, parameters: [], result: DocRows::Item, body: constructor{ @@ -4424,7 +4438,7 @@ } definition{ - name: i0322, + name: i0323, parameters: [], result: DocRows::Item, body: constructor{ @@ -4438,7 +4452,7 @@ } definition{ - name: i0323, + name: i0324, parameters: [], result: DocRows::Item, body: constructor{ @@ -4452,7 +4466,7 @@ } definition{ - name: i0324, + name: i0325, parameters: [], result: DocRows::Item, body: constructor{ @@ -4464,7 +4478,7 @@ } definition{ - name: i0325, + name: i0326, parameters: [], result: DocRows::Item, body: constructor{ @@ -4478,7 +4492,7 @@ } definition{ - name: i0326, + name: i0327, parameters: [], result: DocRows::Item, body: constructor{ @@ -4493,7 +4507,7 @@ } definition{ - name: i0327, + name: i0328, parameters: [], result: DocRows::Item, body: constructor{ @@ -4507,7 +4521,7 @@ } definition{ - name: i0328, + name: i0329, parameters: [], result: DocRows::Item, body: constructor{ @@ -4519,7 +4533,7 @@ } definition{ - name: i0329, + name: i0330, parameters: [], result: DocRows::Item, body: constructor{ @@ -4533,7 +4547,7 @@ } definition{ - name: i0330, + name: i0331, parameters: [], result: DocRows::Item, body: constructor{ @@ -4548,7 +4562,7 @@ } definition{ - name: i0331, + name: i0332, parameters: [], result: DocRows::Item, body: constructor{ @@ -4562,7 +4576,7 @@ } definition{ - name: i0332, + name: i0333, parameters: [], result: DocRows::Item, body: constructor{ @@ -4574,7 +4588,7 @@ } definition{ - name: i0333, + name: i0334, parameters: [], result: DocRows::Item, body: constructor{ @@ -4588,7 +4602,7 @@ } definition{ - name: i0334, + name: i0335, parameters: [], result: DocRows::Item, body: constructor{ @@ -4602,7 +4616,7 @@ } definition{ - name: i0335, + name: i0336, parameters: [], result: DocRows::Item, body: constructor{ @@ -4614,7 +4628,7 @@ } definition{ - name: i0336, + name: i0337, parameters: [], result: DocRows::Item, body: constructor{ @@ -4628,7 +4642,7 @@ } definition{ - name: i0337, + name: i0338, parameters: [], result: DocRows::Item, body: constructor{ @@ -4642,7 +4656,7 @@ } definition{ - name: i0338, + name: i0339, parameters: [], result: DocRows::Item, body: constructor{ @@ -4656,7 +4670,7 @@ } definition{ - name: i0339, + name: i0340, parameters: [], result: DocRows::Item, body: constructor{ @@ -4670,7 +4684,7 @@ } definition{ - name: i0340, + name: i0341, parameters: [], result: DocRows::Item, body: constructor{ @@ -4684,7 +4698,7 @@ } definition{ - name: i0341, + name: i0342, parameters: [], result: DocRows::Item, body: constructor{ @@ -4696,7 +4710,7 @@ } definition{ - name: i0342, + name: i0343, parameters: [], result: DocRows::Item, body: constructor{ @@ -4710,7 +4724,7 @@ } definition{ - name: i0343, + name: i0344, parameters: [], result: DocRows::Item, body: constructor{ @@ -4724,7 +4738,7 @@ } definition{ - name: i0344, + name: i0345, parameters: [], result: DocRows::Item, body: constructor{ @@ -4736,7 +4750,7 @@ } definition{ - name: i0345, + name: i0346, parameters: [], result: DocRows::Item, body: constructor{ @@ -4750,7 +4764,7 @@ } definition{ - name: i0346, + name: i0347, parameters: [], result: DocRows::Item, body: constructor{ @@ -4764,7 +4778,7 @@ } definition{ - name: i0347, + name: i0348, parameters: [], result: DocRows::Item, body: constructor{ @@ -4776,7 +4790,7 @@ } definition{ - name: i0348, + name: i0349, parameters: [], result: DocRows::Item, body: constructor{ @@ -4790,7 +4804,7 @@ } definition{ - name: i0349, + name: i0350, parameters: [], result: DocRows::Item, body: constructor{ @@ -4802,7 +4816,7 @@ } definition{ - name: i0350, + name: i0351, parameters: [], result: DocRows::Item, body: constructor{ @@ -4816,7 +4830,7 @@ } definition{ - name: i0351, + name: i0352, parameters: [], result: DocRows::Item, body: constructor{ @@ -4830,7 +4844,7 @@ } definition{ - name: i0352, + name: i0353, parameters: [], result: DocRows::Item, body: constructor{ @@ -4845,7 +4859,7 @@ } definition{ - name: i0353, + name: i0354, parameters: [], result: DocRows::Item, body: constructor{ @@ -4859,7 +4873,7 @@ } definition{ - name: i0354, + name: i0355, parameters: [], result: DocRows::Item, body: constructor{ @@ -4873,7 +4887,7 @@ } definition{ - name: i0355, + name: i0356, parameters: [], result: DocRows::Item, body: constructor{ @@ -4887,7 +4901,7 @@ } definition{ - name: i0356, + name: i0357, parameters: [], result: DocRows::Item, body: constructor{ @@ -4901,7 +4915,7 @@ } definition{ - name: i0357, + name: i0358, parameters: [], result: DocRows::Item, body: constructor{ @@ -4915,7 +4929,7 @@ } definition{ - name: i0358, + name: i0359, parameters: [], result: DocRows::Item, body: constructor{ @@ -4927,7 +4941,7 @@ } definition{ - name: i0359, + name: i0360, parameters: [], result: DocRows::Item, body: constructor{ @@ -4941,7 +4955,7 @@ } definition{ - name: i0360, + name: i0361, parameters: [], result: DocRows::Item, body: constructor{ @@ -4955,7 +4969,7 @@ } definition{ - name: i0361, + name: i0362, parameters: [], result: DocRows::Item, body: constructor{ @@ -4969,7 +4983,7 @@ } definition{ - name: i0362, + name: i0363, parameters: [], result: DocRows::Item, body: constructor{ @@ -4983,7 +4997,7 @@ } definition{ - name: i0363, + name: i0364, parameters: [], result: DocRows::Item, body: constructor{ @@ -4997,7 +5011,7 @@ } definition{ - name: i0364, + name: i0365, parameters: [], result: DocRows::Item, body: constructor{ @@ -5011,7 +5025,7 @@ } definition{ - name: i0365, + name: i0366, parameters: [], result: DocRows::Item, body: constructor{ @@ -5025,7 +5039,7 @@ } definition{ - name: i0366, + name: i0367, parameters: [], result: DocRows::Item, body: constructor{ @@ -5039,7 +5053,7 @@ } definition{ - name: i0367, + name: i0368, parameters: [], result: DocRows::Item, body: constructor{ @@ -5053,7 +5067,7 @@ } definition{ - name: i0368, + name: i0369, parameters: [], result: DocRows::Item, body: constructor{ @@ -5067,7 +5081,7 @@ } definition{ - name: i0369, + name: i0370, parameters: [], result: DocRows::Item, body: constructor{ @@ -5081,7 +5095,7 @@ } definition{ - name: i0370, + name: i0371, parameters: [], result: DocRows::Item, body: constructor{ @@ -5095,7 +5109,7 @@ } definition{ - name: i0371, + name: i0372, parameters: [], result: DocRows::Item, body: constructor{ @@ -5109,7 +5123,7 @@ } definition{ - name: i0372, + name: i0373, parameters: [], result: DocRows::Item, body: constructor{ @@ -5123,7 +5137,7 @@ } definition{ - name: i0373, + name: i0374, parameters: [], result: DocRows::Item, body: constructor{ @@ -5137,7 +5151,7 @@ } definition{ - name: i0374, + name: i0375, parameters: [], result: DocRows::Item, body: constructor{ @@ -5151,7 +5165,7 @@ } definition{ - name: i0375, + name: i0376, parameters: [], result: DocRows::Item, body: constructor{ @@ -5165,7 +5179,7 @@ } definition{ - name: i0376, + name: i0377, parameters: [], result: DocRows::Item, body: constructor{ @@ -5179,7 +5193,7 @@ } definition{ - name: i0377, + name: i0378, parameters: [], result: DocRows::Item, body: constructor{ @@ -5193,7 +5207,7 @@ } definition{ - name: i0378, + name: i0379, parameters: [], result: DocRows::Item, body: constructor{ @@ -5207,7 +5221,7 @@ } definition{ - name: i0379, + name: i0380, parameters: [], result: DocRows::Item, body: constructor{ @@ -5221,7 +5235,7 @@ } definition{ - name: i0380, + name: i0381, parameters: [], result: DocRows::Item, body: constructor{ @@ -5235,7 +5249,7 @@ } definition{ - name: i0381, + name: i0382, parameters: [], result: DocRows::Item, body: constructor{ @@ -5249,7 +5263,7 @@ } definition{ - name: i0382, + name: i0383, parameters: [], result: DocRows::Item, body: constructor{ @@ -5261,7 +5275,7 @@ } definition{ - name: i0383, + name: i0384, parameters: [], result: DocRows::Item, body: constructor{ @@ -5275,7 +5289,7 @@ } definition{ - name: i0384, + name: i0385, parameters: [], result: DocRows::Item, body: constructor{ @@ -5289,7 +5303,7 @@ } definition{ - name: i0385, + name: i0386, parameters: [], result: DocRows::Item, body: constructor{ @@ -5303,7 +5317,7 @@ } definition{ - name: i0386, + name: i0387, parameters: [], result: DocRows::Item, body: constructor{ @@ -5317,7 +5331,7 @@ } definition{ - name: i0387, + name: i0388, parameters: [], result: DocRows::Item, body: constructor{ @@ -5331,7 +5345,7 @@ } definition{ - name: i0388, + name: i0389, parameters: [], result: DocRows::Item, body: constructor{ @@ -5345,7 +5359,7 @@ } definition{ - name: i0389, + name: i0390, parameters: [], result: DocRows::Item, body: constructor{ @@ -5359,7 +5373,7 @@ } definition{ - name: i0390, + name: i0391, parameters: [], result: DocRows::Item, body: constructor{ @@ -5373,7 +5387,7 @@ } definition{ - name: i0391, + name: i0392, parameters: [], result: DocRows::Item, body: constructor{ @@ -5387,7 +5401,7 @@ } definition{ - name: i0392, + name: i0393, parameters: [], result: DocRows::Item, body: constructor{ @@ -5401,7 +5415,7 @@ } definition{ - name: i0393, + name: i0394, parameters: [], result: DocRows::Item, body: constructor{ @@ -5415,7 +5429,7 @@ } definition{ - name: i0394, + name: i0395, parameters: [], result: DocRows::Item, body: constructor{ @@ -5429,7 +5443,7 @@ } definition{ - name: i0395, + name: i0396, parameters: [], result: DocRows::Item, body: constructor{ @@ -5443,7 +5457,7 @@ } definition{ - name: i0396, + name: i0397, parameters: [], result: DocRows::Item, body: constructor{ @@ -5455,7 +5469,7 @@ } definition{ - name: i0397, + name: i0398, parameters: [], result: DocRows::Item, body: constructor{ @@ -5469,7 +5483,7 @@ } definition{ - name: i0398, + name: i0399, parameters: [], result: DocRows::Item, body: constructor{ @@ -5483,7 +5497,7 @@ } definition{ - name: i0399, + name: i0400, parameters: [], result: DocRows::Item, body: constructor{ @@ -5497,7 +5511,7 @@ } definition{ - name: i0400, + name: i0401, parameters: [], result: DocRows::Item, body: constructor{ @@ -5511,7 +5525,7 @@ } definition{ - name: i0401, + name: i0402, parameters: [], result: DocRows::Item, body: constructor{ @@ -5525,7 +5539,7 @@ } definition{ - name: i0402, + name: i0403, parameters: [], result: DocRows::Item, body: constructor{ @@ -5539,7 +5553,7 @@ } definition{ - name: i0403, + name: i0404, parameters: [], result: DocRows::Item, body: constructor{ @@ -5553,7 +5567,7 @@ } definition{ - name: i0404, + name: i0405, parameters: [], result: DocRows::Item, body: constructor{ @@ -5567,7 +5581,7 @@ } definition{ - name: i0405, + name: i0406, parameters: [], result: DocRows::Item, body: constructor{ @@ -5581,7 +5595,7 @@ } definition{ - name: i0406, + name: i0407, parameters: [], result: DocRows::Item, body: constructor{ @@ -5595,7 +5609,7 @@ } definition{ - name: i0407, + name: i0408, parameters: [], result: DocRows::Item, body: constructor{ @@ -5609,7 +5623,7 @@ } definition{ - name: i0408, + name: i0409, parameters: [], result: DocRows::Item, body: constructor{ @@ -5623,7 +5637,7 @@ } definition{ - name: i0409, + name: i0410, parameters: [], result: DocRows::Item, body: constructor{ @@ -5637,7 +5651,7 @@ } definition{ - name: i0410, + name: i0411, parameters: [], result: DocRows::Item, body: constructor{ @@ -5651,7 +5665,7 @@ } definition{ - name: i0411, + name: i0412, parameters: [], result: DocRows::Item, body: constructor{ @@ -5665,7 +5679,7 @@ } definition{ - name: i0412, + name: i0413, parameters: [], result: DocRows::Item, body: constructor{ @@ -5679,7 +5693,7 @@ } definition{ - name: i0413, + name: i0414, parameters: [], result: DocRows::Item, body: constructor{ @@ -5693,7 +5707,7 @@ } definition{ - name: i0414, + name: i0415, parameters: [], result: DocRows::Item, body: constructor{ @@ -5707,7 +5721,7 @@ } definition{ - name: i0415, + name: i0416, parameters: [], result: DocRows::Item, body: constructor{ @@ -5721,7 +5735,7 @@ } definition{ - name: i0416, + name: i0417, parameters: [], result: DocRows::Item, body: constructor{ @@ -5735,7 +5749,7 @@ } definition{ - name: i0417, + name: i0418, parameters: [], result: DocRows::Item, body: constructor{ @@ -5749,7 +5763,7 @@ } definition{ - name: i0418, + name: i0419, parameters: [], result: DocRows::Item, body: constructor{ @@ -5763,7 +5777,7 @@ } definition{ - name: i0419, + name: i0420, parameters: [], result: DocRows::Item, body: constructor{ @@ -5777,7 +5791,7 @@ } definition{ - name: i0420, + name: i0421, parameters: [], result: DocRows::Item, body: constructor{ @@ -5791,7 +5805,7 @@ } definition{ - name: i0421, + name: i0422, parameters: [], result: DocRows::Item, body: constructor{ @@ -5805,7 +5819,7 @@ } definition{ - name: i0422, + name: i0423, parameters: [], result: DocRows::Item, body: constructor{ @@ -5819,7 +5833,7 @@ } definition{ - name: i0423, + name: i0424, parameters: [], result: DocRows::Item, body: constructor{ @@ -5833,7 +5847,7 @@ } definition{ - name: i0424, + name: i0425, parameters: [], result: DocRows::Item, body: constructor{ @@ -5847,7 +5861,7 @@ } definition{ - name: i0425, + name: i0426, parameters: [], result: DocRows::Item, body: constructor{ @@ -5861,7 +5875,7 @@ } definition{ - name: i0426, + name: i0427, parameters: [], result: DocRows::Item, body: constructor{ @@ -5875,7 +5889,7 @@ } definition{ - name: i0427, + name: i0428, parameters: [], result: DocRows::Item, body: constructor{ @@ -5889,7 +5903,7 @@ } definition{ - name: i0428, + name: i0429, parameters: [], result: DocRows::Item, body: constructor{ @@ -5903,7 +5917,7 @@ } definition{ - name: i0429, + name: i0430, parameters: [], result: DocRows::Item, body: constructor{ @@ -5917,7 +5931,7 @@ } definition{ - name: i0430, + name: i0431, parameters: [], result: DocRows::Item, body: constructor{ @@ -5931,7 +5945,7 @@ } definition{ - name: i0431, + name: i0432, parameters: [], result: DocRows::Item, body: constructor{ @@ -5945,7 +5959,7 @@ } definition{ - name: i0432, + name: i0433, parameters: [], result: DocRows::Item, body: constructor{ @@ -5959,7 +5973,7 @@ } definition{ - name: i0433, + name: i0434, parameters: [], result: DocRows::Item, body: constructor{ @@ -5973,7 +5987,7 @@ } definition{ - name: i0434, + name: i0435, parameters: [], result: DocRows::Item, body: constructor{ @@ -5987,7 +6001,7 @@ } definition{ - name: i0435, + name: i0436, parameters: [], result: DocRows::Item, body: constructor{ @@ -6001,7 +6015,7 @@ } definition{ - name: i0436, + name: i0437, parameters: [], result: DocRows::Item, body: constructor{ @@ -6015,7 +6029,7 @@ } definition{ - name: i0437, + name: i0438, parameters: [], result: DocRows::Item, body: constructor{ @@ -6029,7 +6043,7 @@ } definition{ - name: i0438, + name: i0439, parameters: [], result: DocRows::Item, body: constructor{ @@ -6043,7 +6057,7 @@ } definition{ - name: i0439, + name: i0440, parameters: [], result: DocRows::Item, body: constructor{ @@ -6057,7 +6071,7 @@ } definition{ - name: i0440, + name: i0441, parameters: [], result: DocRows::Item, body: constructor{ @@ -6071,7 +6085,7 @@ } definition{ - name: i0441, + name: i0442, parameters: [], result: DocRows::Item, body: constructor{ @@ -6085,7 +6099,7 @@ } definition{ - name: i0442, + name: i0443, parameters: [], result: DocRows::Item, body: constructor{ @@ -6099,7 +6113,7 @@ } definition{ - name: i0443, + name: i0444, parameters: [], result: DocRows::Item, body: constructor{ @@ -6113,7 +6127,7 @@ } definition{ - name: i0444, + name: i0445, parameters: [], result: DocRows::Item, body: constructor{ @@ -6127,7 +6141,7 @@ } definition{ - name: i0445, + name: i0446, parameters: [], result: DocRows::Item, body: constructor{ @@ -6141,7 +6155,7 @@ } definition{ - name: i0446, + name: i0447, parameters: [], result: DocRows::Item, body: constructor{ @@ -6155,7 +6169,7 @@ } definition{ - name: i0447, + name: i0448, parameters: [], result: DocRows::Item, body: constructor{ @@ -6169,7 +6183,7 @@ } definition{ - name: i0448, + name: i0449, parameters: [], result: DocRows::Item, body: constructor{ @@ -6183,7 +6197,7 @@ } definition{ - name: i0449, + name: i0450, parameters: [], result: DocRows::Item, body: constructor{ @@ -6197,7 +6211,7 @@ } definition{ - name: i0450, + name: i0451, parameters: [], result: DocRows::Item, body: constructor{ @@ -6211,7 +6225,7 @@ } definition{ - name: i0451, + name: i0452, parameters: [], result: DocRows::Item, body: constructor{ @@ -6225,7 +6239,7 @@ } definition{ - name: i0452, + name: i0453, parameters: [], result: DocRows::Item, body: constructor{ @@ -6239,7 +6253,7 @@ } definition{ - name: i0453, + name: i0454, parameters: [], result: DocRows::Item, body: constructor{ @@ -6253,7 +6267,7 @@ } definition{ - name: i0454, + name: i0455, parameters: [], result: DocRows::Item, body: constructor{ @@ -6267,7 +6281,7 @@ } definition{ - name: i0455, + name: i0456, parameters: [], result: DocRows::Item, body: constructor{ @@ -6281,7 +6295,7 @@ } definition{ - name: i0456, + name: i0457, parameters: [], result: DocRows::Item, body: constructor{ @@ -6295,7 +6309,7 @@ } definition{ - name: i0457, + name: i0458, parameters: [], result: DocRows::Item, body: constructor{ @@ -6309,7 +6323,7 @@ } definition{ - name: i0458, + name: i0459, parameters: [], result: DocRows::Item, body: constructor{ @@ -6323,7 +6337,7 @@ } definition{ - name: i0459, + name: i0460, parameters: [], result: DocRows::Item, body: constructor{ @@ -6337,7 +6351,7 @@ } definition{ - name: i0460, + name: i0461, parameters: [], result: DocRows::Item, body: constructor{ @@ -6351,7 +6365,7 @@ } definition{ - name: i0461, + name: i0462, parameters: [], result: DocRows::Item, body: constructor{ @@ -6365,7 +6379,7 @@ } definition{ - name: i0462, + name: i0463, parameters: [], result: DocRows::Item, body: constructor{ @@ -6379,7 +6393,7 @@ } definition{ - name: i0463, + name: i0464, parameters: [], result: DocRows::Item, body: constructor{ @@ -6393,7 +6407,7 @@ } definition{ - name: i0464, + name: i0465, parameters: [], result: DocRows::Item, body: constructor{ @@ -6407,7 +6421,7 @@ } definition{ - name: i0465, + name: i0466, parameters: [], result: DocRows::Item, body: constructor{ @@ -6421,7 +6435,7 @@ } definition{ - name: i0466, + name: i0467, parameters: [], result: DocRows::Item, body: constructor{ @@ -6435,7 +6449,7 @@ } definition{ - name: i0467, + name: i0468, parameters: [], result: DocRows::Item, body: constructor{ @@ -6449,7 +6463,7 @@ } definition{ - name: i0468, + name: i0469, parameters: [], result: DocRows::Item, body: constructor{ @@ -6463,7 +6477,7 @@ } definition{ - name: i0469, + name: i0470, parameters: [], result: DocRows::Item, body: constructor{ @@ -6477,7 +6491,7 @@ } definition{ - name: i0470, + name: i0471, parameters: [], result: DocRows::Item, body: constructor{ @@ -6491,7 +6505,7 @@ } definition{ - name: i0471, + name: i0472, parameters: [], result: DocRows::Item, body: constructor{ @@ -6505,7 +6519,7 @@ } definition{ - name: i0472, + name: i0473, parameters: [], result: DocRows::Item, body: constructor{ @@ -6519,7 +6533,7 @@ } definition{ - name: i0473, + name: i0474, parameters: [], result: DocRows::Item, body: constructor{ @@ -6533,7 +6547,7 @@ } definition{ - name: i0474, + name: i0475, parameters: [], result: DocRows::Item, body: constructor{ @@ -6547,7 +6561,7 @@ } definition{ - name: i0475, + name: i0476, parameters: [], result: DocRows::Item, body: constructor{ @@ -6561,7 +6575,7 @@ } definition{ - name: i0476, + name: i0477, parameters: [], result: DocRows::Item, body: constructor{ @@ -6575,7 +6589,7 @@ } definition{ - name: i0477, + name: i0478, parameters: [], result: DocRows::Item, body: constructor{ @@ -6589,7 +6603,7 @@ } definition{ - name: i0478, + name: i0479, parameters: [], result: DocRows::Item, body: constructor{ @@ -6603,7 +6617,7 @@ } definition{ - name: i0479, + name: i0480, parameters: [], result: DocRows::Item, body: constructor{ @@ -6617,7 +6631,7 @@ } definition{ - name: i0480, + name: i0481, parameters: [], result: DocRows::Item, body: constructor{ @@ -6631,7 +6645,7 @@ } definition{ - name: i0481, + name: i0482, parameters: [], result: DocRows::Item, body: constructor{ @@ -6645,7 +6659,7 @@ } definition{ - name: i0482, + name: i0483, parameters: [], result: DocRows::Item, body: constructor{ @@ -6659,7 +6673,7 @@ } definition{ - name: i0483, + name: i0484, parameters: [], result: DocRows::Item, body: constructor{ @@ -6673,7 +6687,7 @@ } definition{ - name: i0484, + name: i0485, parameters: [], result: DocRows::Item, body: constructor{ @@ -6687,7 +6701,7 @@ } definition{ - name: i0485, + name: i0486, parameters: [], result: DocRows::Item, body: constructor{ @@ -6701,7 +6715,7 @@ } definition{ - name: i0486, + name: i0487, parameters: [], result: DocRows::Item, body: constructor{ @@ -6715,7 +6729,7 @@ } definition{ - name: i0487, + name: i0488, parameters: [], result: DocRows::Item, body: constructor{ @@ -6729,7 +6743,7 @@ } definition{ - name: i0488, + name: i0489, parameters: [], result: DocRows::Item, body: constructor{ @@ -6743,7 +6757,7 @@ } definition{ - name: i0489, + name: i0490, parameters: [], result: DocRows::Item, body: constructor{ @@ -6757,7 +6771,7 @@ } definition{ - name: i0490, + name: i0491, parameters: [], result: DocRows::Item, body: constructor{ @@ -6771,7 +6785,7 @@ } definition{ - name: i0491, + name: i0492, parameters: [], result: DocRows::Item, body: constructor{ @@ -6785,7 +6799,7 @@ } definition{ - name: i0492, + name: i0493, parameters: [], result: DocRows::Item, body: constructor{ @@ -6799,7 +6813,7 @@ } definition{ - name: i0493, + name: i0494, parameters: [], result: DocRows::Item, body: constructor{ @@ -6813,7 +6827,7 @@ } definition{ - name: i0494, + name: i0495, parameters: [], result: DocRows::Item, body: constructor{ @@ -6827,7 +6841,7 @@ } definition{ - name: i0495, + name: i0496, parameters: [], result: DocRows::Item, body: constructor{ @@ -6841,7 +6855,7 @@ } definition{ - name: i0496, + name: i0497, parameters: [], result: DocRows::Item, body: constructor{ @@ -6855,7 +6869,7 @@ } definition{ - name: i0497, + name: i0498, parameters: [], result: DocRows::Item, body: constructor{ @@ -6869,7 +6883,7 @@ } definition{ - name: i0498, + name: i0499, parameters: [], result: DocRows::Item, body: constructor{ @@ -6883,7 +6897,7 @@ } definition{ - name: i0499, + name: i0500, parameters: [], result: DocRows::Item, body: constructor{ @@ -6897,7 +6911,7 @@ } definition{ - name: i0500, + name: i0501, parameters: [], result: DocRows::Item, body: constructor{ @@ -6911,7 +6925,7 @@ } definition{ - name: i0501, + name: i0502, parameters: [], result: DocRows::Item, body: constructor{ @@ -6925,7 +6939,7 @@ } definition{ - name: i0502, + name: i0503, parameters: [], result: DocRows::Item, body: constructor{ @@ -6939,7 +6953,7 @@ } definition{ - name: i0503, + name: i0504, parameters: [], result: DocRows::Item, body: constructor{ @@ -6953,7 +6967,7 @@ } definition{ - name: i0504, + name: i0505, parameters: [], result: DocRows::Item, body: constructor{ @@ -6967,7 +6981,7 @@ } definition{ - name: i0505, + name: i0506, parameters: [], result: DocRows::Item, body: constructor{ @@ -6981,7 +6995,7 @@ } definition{ - name: i0506, + name: i0507, parameters: [], result: DocRows::Item, body: constructor{ diff --git a/spec/src/IdsGL.lex.tex b/spec/src/IdsGL.lex.tex index 60deb6f2af..421134b1d8 100644 --- a/spec/src/IdsGL.lex.tex +++ b/spec/src/IdsGL.lex.tex @@ -147,5 +147,13 @@ body: (record Rows::IdRow {id := "GL-18", level := "build", suite := "lexicon", statement := "Cross-version package, lexicon, and lock combinations fail closed before backend execution.", sections := "§10.1, §13.11"}), executable: true } + +definition{ + name: gl22, + parameters: [], + result: Rows::IdRow, + body: (record Rows::IdRow {id := "GL-22", level := "build", suite := "lexicon", statement := "Document denotations over exported semantic-module inductive and structure types, definitions, and theorems resolve through explicit module imports with their exact canonical signatures and generated Lean names; unavailable declarations and mismatching signatures are refused before verification.", sections := "§13.6, §17.7"}), + executable: true +} \end{semanticmodule} \end{lexlean}