parseltongue/ Core Overview

Parseltongue Core

LLMs hallucinate. They produce fluent, confident text that may have no basis in the source material. Traditional approaches treat this as a retrieval problem — feed the model better context and hope for the best. Parseltongue takes a different approach: instead of trusting an LLM's summary, we ask it to encode each document as a logic system. Every extracted claim must cite a verbatim quote. Every conclusion must derive from stated premises. And every derivation is checked.

This notebook loads the engine's own formal specification — 50 nodes extracted by LLMs from engine.py, each citing a verbatim quote from the source code. These are the tip of a 2000+ node iceberg — switch to the Layers or Graph tab to see the full structure. And some of the nodes we extracted may be wrong! E.G. we forgot to update documentation after refactoring. The engine catches such errors. The ⚠ and ✖ markers you'll see throughout aren't bugs in the demo — they're the system working.

pltg Load ▸
Out: True

Can We Actually Check Axioms?

The README promises that Parseltongue grounds axioms in evidence. That's easy to promise. Can we prove it?

Here's how it works. You have a claim — say, "Q3 revenue grew 15%." You find it quoted in one report. Then you find the raw quarterly figures in another document and compute growth independently. Now you have two paths to the same number. If they agree, the claim held up under scrutiny. If they don't — 15% vs 9.5% — you caught a contradiction. The more independent paths that converge on the same answer, the stronger the grounding.

In Parseltongue, this comparison between two independent paths to the same value is called a diff.

The engine takes this further. It formally defines the epistemic status of every axiom — exemplifiable (evidence found), hallucinated (evidence contradicts), or unknown (can't tell). It maps these statuses to the errors and warnings it produces. And then it proves — not asserts, proves — that the mapping is exact. Every hallucinated claim becomes an error[1]. Every unknown becomes a warning[2]. What survives is exemplifiable — the system witnessed it through evidence[3].

1core.engine.hallucinated-is-error 2core.engine.unknown-is-warning 3core.readme.parseltongue-makes-axioms-exemplifiable

This is not an aspirational claim but a theorem[4]. The comparison true = true[5] shows it holds computationally. And the ⚠ and ✖ markers on this page are that classification running live.

4core.engine.isomorphism-hallucinations-errors-unknowns-warnings 5core.thm-epistemics-cross-check

Everything below explains the machinery that makes this work.

Facts and Evidence — Where It Starts

A fact is a named value extracted from a document. But a value alone means nothing — anyone can write revenue = 15. What makes it a Parseltongue fact is the evidence: the name of the source document and a verbatim quote. The engine literally searches the document for that exact text.

If the quote is found, the fact is grounded. If not, it's flagged unverified_evidence — the first kind of error. This is how hallucination detection works at its most basic level: the LLM says "the code does X" and quotes a line from engine.py. The engine checks. If that line isn't there, the fact is ungrounded.

This is the first of three consistency layers — Evidence grounding.[6] Every fact in the engine's specification goes through this check. The ones with ⚠ markers on this page? That's a fact whose evidence the engine couldn't fully verify.

6core.engine.consistency-layer-1

Derivation — The Proof Chain

You have facts. You want to prove something from them. A derivation is a theorem: an expression evaluated against specific facts listed in its :using clause. The engine checks that every fact you claim to use actually exists and is accessible.

The critical property: if ANY fact in the :using list has unverified evidence, the entire derivation inherits the taint. One fabricated revenue figure can contaminate dozens of downstream calculations. The engine doesn't hide this — it shows you the full contamination tree, not just the root cause.

This propagation is called fabrication taint, and it's the second consistency layer — Fabrication propagation.[7] You don't just catch the lie; you see everything it contaminates.

7core.engine.consistency-layer-2

The engine's specification proves three things about this chain. First, that facts, axioms, and terms all verify their origin through the same mechanism[8]. Second, that derivation inherits grounding from its sources — if the language says derive is a documentation directive, the engine checks its sources[9]. Third, that diffs need no evidence at all — inconsistency between their sides is itself a system-level issue, not a claim requiring grounding[10⚠].

8core.engine.bound-evidence-attachable 9core.engine.bound-derive-inherits 10core.engine.bound-diff-no-evidence ⚠
pltg Derivation ▸
Out: 3
derivation-theorem-count = 3 ⚠

3[11⚠] theorems prove the derivation chain. The number of derivation mechanisms documented matches the number implemented: 5 = 5.[12]

11derivation-theorem-count ⚠ 12core.engine.derivation-mechanism-coverage

Comparing Independent Paths

Back to the revenue example from Section 2. Two paths, one number, do they agree? That's what diffs do formally. You register a :replace side and a :with side — two independently computed values for the same quantity. When the consistency checker runs, it evaluates both and compares.

When the paths disagree, the engine flags a divergence — the third and final consistency layer: Diff agreement.[13] But it doesn't stop at the point of disagreement. If theorem B depends on a value that just diverged, B is now suspect too. To find the full blast radius, the engine scans all five definition types — facts[14], terms[15], axioms[16], theorems[17], and other diffs[18]. It follows derivation chains for indirect dependencies[19], and the expansion is transitive — quoting the actual while frontier: loop from the source[20].

13core.engine.consistency-layer-3 14core.engine.dependents-scans-facts 15core.engine.dependents-scans-terms 16core.engine.dependents-scans-axioms 17core.engine.dependents-scans-theorems 18core.engine.dependents-scans-diffs 19core.engine.dependents-checks-derivation-list 20core.engine.dependents-is-transitive
pltg Dependents ▸
Out: 5
dependents-scan-count = 5

The scanner covers 5[21] definition types. The paired count matches what the documentation claims (5 = 5)[22] and what the implementation provides (5 = 5).[23]

21dependents-scan-count 22core.engine.dependents-paired-vs-doc 23core.engine.dependents-paired-vs-impl

Diffs evaluate structurally, not by string comparison[24✖]. A diff excludes itself from its own dependency scan — without this, every diff would flag itself as divergent. All 3[25] documented aspects of the diff mechanism are implemented: 3 = 3.[26]

24core.engine.diff-evaluated-structurally ✖ 25core.engine.diff-mechanism-doc-count 26core.engine.diff-mechanism-coverage

The Three Layers

We've now walked through each consistency layer individually:

  1. Evidence grounding[6] — is the quote actually in the document?
    6core.engine.consistency-layer-1
  2. Fabrication propagation[7] — does the taint from ungrounded facts propagate to derivations?
    7core.engine.consistency-layer-2
  3. Diff agreement[13] — do independent paths to the same value agree?
    13core.engine.consistency-layer-3

The consistency checker runs them in sequence. The specification confirms it checks all 3[27] layers, and the documented layer count matches the implementation: 3 = 3.[28]

27core.engine.consistency-layer-count 28core.engine.consistency-layers-coverage
pltg Consistency Layers ▸
Out: 3

Errors, Warnings, and the Classification

The three layers produce 7[29] distinct states — 5[30] errors and 2[31] warnings.

29core.engine.consistency-states-total 30core.engine.causes-error-count 31core.engine.causes-warning-count

The distinction matters. Hard errors mean something is definitely wrong — unverified evidence, a derivation built on fabricated sources. Warnings are different — they mark the boundary of what the engine can prove. A fact verified manually has no quote for the engine to check[32]. A diff whose :replace side references another diff[33] would require the engine to evaluate itself to resolve — a circularity akin to the halting problem[34]. In both cases the engine reaches an incompleteness boundary: it cannot confirm the hypothesis, but it also cannot refute it. The result is epistemically unknown, so the engine hands off responsibility and produces a warning[35]. This is called contamination.

32core.engine.manual-causes-warning 33core.engine.contamination-all-are-diff-refs 34core.engine.contamination-is-empty 35core.engine.contamination-causes-warning

Each failure mode has a witness pattern — a theorem that proves exactly how that kind of failure is detected:

pltg Error Witnesses ▸
Out: 5
witness-count = 5

5[36] patterns: hallucinated evidence[37], missing evidence entirely[38], an axiom that doesn't hold under binding[39], an ungrounded derivation source[40], and unknown evidence status[41].

36witness-count 37core.engine.witness-evidence-hallucinated 38core.engine.witness-no-evidence-hallucinated 39core.engine.witness-fabrication-does-not-hold 40core.engine.witness-fabrication-ungrounded-source 41core.engine.witness-evidence-unknown
pltg Error vs Warning Counts ▸
Out: 5

Now the payoff. This classification — hallucinated→error, unknown→warning, what survives→exemplifiable — is exactly what Section 2 promised. The engine doesn't just produce these labels. It proves the mapping is exhaustive. The epistemics isomorphism[4] is the theorem that ties it together: the README's philosophical claim about grounding axioms in evidence[42] and the engine's mechanical error classification are the same operation. Axiom status collapses to std.epistemics.exemplifiable[43] — because the engine witnessed them.

4core.engine.isomorphism-hallucinations-errors-unknowns-warnings 42core.readme.evidence-is-departure 43core.readme.parseltongue-axiom-status

Cross-Module Validation

The engine's specification doesn't exist in isolation. It's one of roughly 15 modules that cross-validate each other. The README makes claims. Each module's specification makes claims. The implementation exists. Cross-module diffs connect them — and the rendered values show whether they agree:

  • Consistency state count: 7 = 7[44]
    44core.thm-consistency-states-total
  • Error types vs README's issue table: 5 = 5[45]
    45core.thm-engine-error-cross-check
  • Warning types vs README's warning table: 2 = 2[46]
    46core.thm-engine-warning-cross-check
  • Fabrication propagation described vs implemented: true = true[47]
    47core.thm-fabrication
  • Automatic grounding claimed vs built: true = true[48]
    48core.thm-fact-cites-quote
  • Cross-validation mechanism: true = true[49⚠]
    49core.thm-diffs-detect ⚠
  • The epistemics isomorphism: true = true[5]
    5core.thm-epistemics-cross-check
pltg Cross-Module ▸
Out: 7
cross-module-count = 7

7[50] cross-module diffs. When any of them drift — someone updates the README but forgets the implementation, or vice versa — the comparison catches it automatically.

50cross-module-count

Document Management — Items × Layers

The engine manages documents through registration, loading, and ground-truth indexing. When a subsystem appears in multiple representations — documentation says it exists, implementation actually provides it — the Items × Layers pattern creates a fact per item per layer, derives per-layer aggregates, and compares across layers.

pltg Document Management ▸
Out: 3

3[51] features are fully paired — documented AND implemented. The paired count matches what the documentation claims (3 = 3)[52] and what the implementation provides (3 = 3).[53]

51core.engine.doc-mgmt-paired-count 52core.engine.doc-mgmt-paired-vs-doc 53core.engine.doc-mgmt-paired-vs-impl

The Engine's Shape

pltg Core Facts ▸
Out: 8
engine-fact-count = 8 ⚠

8[54⚠] key facts form the foundation — from the derive directive's docstring (Derive a theorem from existing axioms/terms.)[55] to the consistency checker's (Check full consistency state of the system.),[56] from the requirement that axioms have free ?-variables[57] to the transitive dependents expansion[20]. Each one quotes verbatim from engine.py. The engine's formal specification is built from its own source code, extracted by LLMs, and verified by the engine itself.

54engine-fact-count ⚠ 55core.engine.derive-doc 56core.engine.consistency-doc 57core.engine.axiom-requires-free-vars 20core.engine.dependents-is-transitive

Screening Report

The engine is designed to know its own status — after all, that's what it's for. It has an explicit directive to produce its own consistency report and act on it. Here is the report for the engine's own specification — Parseltongue validating itself:

pltg Screen ▸
Out: True
System inconsistent: 4 issue(s) Unverified evidence: core.ast_verifier.derive-extracts-from-using quote: 'using = get_keyword(expr, KW_USING, [])\n if isinstance(using, list):\n for s in using:\n deps.add(str(s))' core.ast_verifier.doc-carries-children quote: '- Resolved child node references (nodes this directive depends on)' core.ast_verifier.doc-carries-dep-names quote: '- The set of symbol dependency names (unresolved)' core.ast_verifier.doc-carries-dependents quote: '- Resolved dependent node references (nodes that depend on this one)' core.ast_verifier.doc-carries-expr quote: '- The raw expression for later execution' core.ast_verifier.doc-carries-kind quote: '- The directive kind (fact, axiom, defterm, derive, diff, effect)' core.ast_verifier.doc-carries-name quote: '- The defined name (if any)' core.ast_verifier.doc-carries-source-file quote: '- The source file path that defined the directive' core.ast_verifier.doc-carries-source-order quote: '- The source order (parse position within the file)' core.ast_verifier.effects-have-no-name quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' core.ast_verifier.extract-recurses-lists quote: 'elif isinstance(expr, list):\n for item in expr:\n extract_symbols(item, out)' core.ast_verifier.kind-comment-axiom quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-defterm quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-derive quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-diff quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-effect quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-fact quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-effect quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' core.ast_verifier.node-has-kind quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.atoms.atom-conv-impl-count quote: 'return int(token)' quote: 'return float(token)' quote: 'if token.startswith(":"):' quote: 'if token == "false":' quote: 'return Symbol(token)' core.atoms.atom-doc quote: 'Convert a token string to a typed value.' core.atoms.atom-fallback-is-symbol quote: 'return Symbol(token)' core.atoms.atom-false-token quote: 'if token == "false":' core.atoms.atom-keyword-prefix quote: 'if token.startswith(":"):' core.atoms.atom-tries-float-second quote: 'return float(token)' core.atoms.atom-tries-int-first quote: 'return int(token)' core.atoms.atom-true-token quote: 'if token == "true":' core.atoms.axiom-impl-wff quote: 'class Axiom:\n """An axiom: a foundational WFF assumed true, with evidence.\n\n Every axiom carries a wff (never None).\n """\n\n name: str\n wff: Any' core.atoms.comment-char quote: 'if char == ";":' core.atoms.dsl-helpers-impl-count quote: 'def match(' quote: 'def free_vars(' quote: 'def substitute(' quote: 'def to_sexp(' core.atoms.free-vars-doc quote: 'Extract all ?-prefixed symbols from an expression.' core.atoms.match-doc quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' core.atoms.match-splat-doc quote: 'A ``?...name`` symbol as the last element of a list pattern matches\n zero or more remaining elements, bound as a list.' core.atoms.match-splat-impl quote: '# Splat: ?...name as last element matches remaining items\n if (pattern and isinstance(pattern[-1], Symbol)\n and str(pattern[-1]).startswith("?...")):' core.atoms.match-substitute-roundtrip quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' quote: 'Replace symbols with their bound values in an expression tree.' core.atoms.module-claims-pure-types quote: 'Pure types, s-expression reader/printer.' core.atoms.parse-all-doc quote: 'Parse all top-level s-expressions from source.' core.atoms.parse-doc quote: 'Parse a source string into an s-expression.' core.atoms.purity-implies-immutable quote: 'Pure types, s-expression reader/printer.\nNo domain knowledge, no state.' core.atoms.read-tokens-doc quote: 'Recursively parse token list into nested Python structures.' core.atoms.reader-impl-count quote: 'def tokenize(' quote: 'def read_tokens(' quote: 'def atom(' quote: 'def parse(' quote: 'def parse_all(' quote: 'if char == ";":' core.atoms.substitute-doc quote: 'Replace symbols with their bound values in an expression tree.' core.atoms.substitute-splat-doc quote: '``?...name`` bindings are spliced into the parent list rather than\n inserted as a nested list.' core.atoms.substitute-splat-impl quote: 'if (isinstance(sub, Symbol) and str(sub).startswith("?...")\n and sub in bindings):\n val = bindings[sub]\n if isinstance(val, list):\n result.extend(val)' core.atoms.term-display-impl-count quote: '(primitive)' quote: 'to_sexp(self.definition)' core.atoms.term-display-rule quote: 'to_sexp(self.definition) if self.definition is not None else "(primitive)"' core.atoms.term-has-body-display quote: 'to_sexp(self.definition)' core.atoms.term-impl-computed quote: 'to_sexp(self.definition) if self.definition is not None' core.atoms.theorem-impl-wff quote: 'class Theorem:\n """A theorem: a WFF derived from facts, axioms, terms, or other theorems.\n\n Every theorem carries a wff (never None).\n """\n\n name: str\n wff: Any' core.atoms.to-sexp-bool-false quote: 'return "true" if obj else "false"' core.atoms.to-sexp-bool-true quote: 'return "true" if obj else "false"' core.atoms.to-sexp-doc quote: 'Pretty-print a Python object back to s-expression string.' core.atoms.tokenize-doc quote: 'Tokenize s-expression source into atoms and parens.' core.demos.apples-count quote: 'Demo: Parseltongue DSL' core.demos.apples-pltg-count quote: 'Demo: Peano Arithmetic via .pltg' core.demos.apples-pltg-topic quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.' core.demos.biomarkers-count quote: 'Demo: Parseltongue DSL' core.demos.deferred-pltg-count quote: 'Demo: run-on-entry' core.demos.deferred-skips-on-import quote: 'skipped when imported' core.demos.entry-mocks-count quote: 'Demo: run-on-entry as a self-contained unit test' core.demos.entry-mocks-features-impl-count quote: 'run-on-entry as a self-contained unit test with let + mocks' quote: 'rebinds forward-declared primitives' core.demos.entry-mocks-topic quote: 'run-on-entry as a self-contained unit test' core.demos.extensibility-count quote: 'Demo: System Extensibility' core.demos.extensibility-features-impl-count quote: 'System Extensibility' quote: 'load-data' quote: 'Effects are callables that receive (system, *args)' core.demos.extensibility-topic quote: 'System Extensibility' core.demos.extensibility-uses-effects quote: 'pass a' quote: 'load-data' quote: 'effect at construction time' core.demos.pltg-demo-proves-loader-bootstrap quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.\n\nScenario: Same orchard arithmetic as the apples demo, but executed\nentirely through .pltg file loading with an empty initial environment.\nProves that the Loader of modules works correctly to load DSL for\nbootstrapping Peano successor notation, axioms, imports, and derives\nfrom scratch — no Python-side setup.' core.demos.revenue-count quote: 'Demo: Parseltongue DSL in action.' core.demos.revenue-features-impl-count quote: 'Analyzing company performance' quote: 'manual override' core.demos.revenue-topic quote: 'Analyzing company performance' core.demos.self-healing-all-dsl quote: 'The entire flow is written in Parseltongue DSL' core.demos.self-healing-count quote: 'Demo: Self-Healing Probes via Effects' core.demos.self-healing-features-impl-count quote: 'Self-Healing Probes via Effects' quote: 'The entire flow is written in Parseltongue DSL' core.demos.self-healing-topic quote: 'Self-Healing Probes via Effects' core.engine.consistency-checks-three-layers quote: '# 1. Evidence grounding\n unverified = []\n manually_verified = []\n no_evidence = []' quote: '# 2. Fabrication propagation\n fabrications = sorted(\n name\n for name, thm in self.theorems.items()\n if isinstance(thm.origin, str) and "potential fabrication" in thm.origin\n )' quote: '# 3. Diff divergences — evaluated live\n all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' core.engine.diff-evaluated-structurally quote: 'all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' quote: 'downstream_divergent = [d for d in all_diffs if not d.empty and not d.diff_contamination_only]' quote: 'value_divergent = [d for d in all_diffs if d.values_diverge and d.empty]' core.engine.eq-has-rewrite-fallback quote: 'if result is False and head == EQ and any(isinstance(a, list) for a in args):' core.engine.expr-references-recurses-lists quote: 'return any(Engine._expr_references(sub, name) for sub in expr)' core.engine_scopes.delegate-counts-depth quote: 'depth = 0\n e = expr\n while isinstance(e, list) and e and e[0] == DELEGATE:\n depth += 1\n e = e[1]' core.engine_scopes.proposal-binds-from-env quote: 'plain = Symbol(vname.lstrip("?"))\n if plain not in env:\n return []\n bindings[var] = env[plain]' core.engine_scopes.proposal-evaluates-body quote: 'bound_body = substitute(body, bindings)\n return self._eval(\n bound_body, env, axiom_scope, restricted)' core.engine_scopes.proposal-peels-delegate-nesting quote: 'while isinstance(e, list) and e and e[0] == DELEGATE:' core.engine_scopes.proposal-returns-empty-on-mismatch quote: 'if not result:\n return []' core.engine_scopes.scope-checks-self quote: 'if name == SELF:' core.engine_scopes.scope-passes-name-to-callable quote: 'return scope_val(name, *resolved)' core.engine_scopes.scope-resolves-name quote: 'scope_val = self._eval(name, env, axiom_scope, restricted)' core.engine_scopes.self-evaluates-all-args quote: 'if head == SELF:\n # (self expr ...) — evaluate all args in the current engine\n result = None\n for arg in expr[1:]:\n result = self._eval(arg, env, axiom_scope, restricted)\n return result' core.lazy_loader.catches-directive-errors quote: 'try:\n _execute_directive(system.engine, node.expr)\n executed.add(node.name)\n if self._result:\n self._result.loaded.add(node)\n return True\n except Exception as e:\n self._failed_names[node.name] = node' core.lazy_loader.catches-effect-errors quote: 'for expr, ord_idx, line in pre_effects:\n try:\n _execute_directive(system.engine, expr)\n except Exception as e:' core.lazy_loader.catches-parse-errors quote: 'try:\n pre_len = len(tokens)\n expr = read_tokens(tokens)' quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None,\n expr=[],\n dep_names=set(),\n kind="error",\n source_file=self._current.current_file,\n source_order=order,\n source_line=expr_line,\n )' core.lazy_loader.has-line-tracking quote: 'tokens, token_lines = tokenize(source, track_lines=True)' core.lazy_loader.parse-errors-dont-crash quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None, expr=[], dep_names=set(),\n kind="error"' core.lazy_loader.phase-1a-parses-all quote: "# Phase 1a: Parse all expressions, namespace definition names,\n # but DON'T patch body symbols yet (engine is empty)." core.lazy_loader.phase-1c-patches-from-names quote: '# Phase 1c: Now patch body symbols using collected names + aliases,\n # then build DirectiveNodes.' core.lazy_loader.phase-4-topological-exec quote: '# Phase 4: Topological execution of named directives' core.loader.context-resolves-via-registry quote: 'module = self.names_to_modules.get(key_str)' quote: 'if module is not None:' quote: 'ctx = self.modules_contexts[module]' core.loader.effect-behavior-expected quote: 'def print_effect' quote: 'if prop == ":file":' quote: 'if not self._current.is_main:' quote: 'if abs_path in self._file_stack:' quote: 'if abs_path in self._imported:' quote: 'resolved = os.path.normpath' core.loader.effect-import-deduplicates quote: 'if abs_path in self._imported:' quote: 'return True' core.loader.effect-verify-manual-doc quote: 'Effect: (verify-manual name) — manually verify a fact/term/axiom.' core.loader.import-deduplication quote: 'if abs_path in self._imported:' quote: 'log.debug("Module \'%s\' already imported, skipping", module_name)' quote: 'return True' core.loader.import-resolves-dots-to-sep quote: 'module_name.replace(".", os.sep) + ".pltg"' core.loader.loader-namespaces-definitions quote: 'Namespace definition names for non-main modules' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' core.loader.loader-patches-context quote: 'Recursively patch (context :key)' quote: 'patched = f"{self._current.module_name}.{expr[1]}"' core.loader.loader-patches-symbols quote: 'Recursively namespace bare symbols in expression bodies.' quote: 'candidate = f"{self._current.module_name}.{s}"' core.loader.namespacing-only-non-main quote: 'if head in DSL_KEYWORDS or head in SPECIAL_FORMS:' quote: 'if not self._current.is_main:' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' core.system.constructor-params-impl-count quote: 'Composes Engine with default operators' quote: 'overridable: bool = False' quote: 'strict_derive: bool = True' quote: 'effects: dict[str, Callable] | None = None' quote: 'initial_env: dict | None = None' quote: 'docs: dict | None = None' core.system.effects-impl-count quote: 'self.engine.env[Symbol(name)] = lambda *args, _fn=fn: _fn(self, *args)' quote: 'def load_source(system: System, source: str):' core.system.load-source-is-module-fn quote: 'def load_source(system: System, source: str):' core.system.system-docstring quote: 'Composes Engine with default operators, serialization, and introspection.' validation.core.ast_verifier.derive-extracts-from-using quote: 'using = get_keyword(expr, KW_USING, [])\n if isinstance(using, list):\n for s in using:\n deps.add(str(s))' validation.core.ast_verifier.doc-carries-children quote: '- Resolved child node references (nodes this directive depends on)' validation.core.ast_verifier.doc-carries-dep-names quote: '- The set of symbol dependency names (unresolved)' validation.core.ast_verifier.doc-carries-dependents quote: '- Resolved dependent node references (nodes that depend on this one)' validation.core.ast_verifier.doc-carries-expr quote: '- The raw expression for later execution' validation.core.ast_verifier.doc-carries-kind quote: '- The directive kind (fact, axiom, defterm, derive, diff, effect)' validation.core.ast_verifier.doc-carries-name quote: '- The defined name (if any)' validation.core.ast_verifier.doc-carries-source-file quote: '- The source file path that defined the directive' validation.core.ast_verifier.doc-carries-source-order quote: '- The source order (parse position within the file)' validation.core.ast_verifier.effects-have-no-name quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' validation.core.ast_verifier.extract-recurses-lists quote: 'elif isinstance(expr, list):\n for item in expr:\n extract_symbols(item, out)' validation.core.ast_verifier.kind-comment-axiom quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-defterm quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-derive quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-diff quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-effect quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-fact quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-effect quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' validation.core.ast_verifier.node-has-kind quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.atoms.atom-conv-impl-count quote: 'return int(token)' quote: 'return float(token)' quote: 'if token.startswith(":"):' quote: 'if token == "false":' quote: 'return Symbol(token)' validation.core.atoms.atom-doc quote: 'Convert a token string to a typed value.' validation.core.atoms.atom-fallback-is-symbol quote: 'return Symbol(token)' validation.core.atoms.atom-false-token quote: 'if token == "false":' validation.core.atoms.atom-keyword-prefix quote: 'if token.startswith(":"):' validation.core.atoms.atom-tries-float-second quote: 'return float(token)' validation.core.atoms.atom-tries-int-first quote: 'return int(token)' validation.core.atoms.atom-true-token quote: 'if token == "true":' validation.core.atoms.axiom-impl-wff quote: 'class Axiom:\n """An axiom: a foundational WFF assumed true, with evidence.\n\n Every axiom carries a wff (never None).\n """\n\n name: str\n wff: Any' validation.core.atoms.comment-char quote: 'if char == ";":' validation.core.atoms.dsl-helpers-impl-count quote: 'def match(' quote: 'def free_vars(' quote: 'def substitute(' quote: 'def to_sexp(' validation.core.atoms.free-vars-doc quote: 'Extract all ?-prefixed symbols from an expression.' validation.core.atoms.match-doc quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' validation.core.atoms.match-splat-doc quote: 'A ``?...name`` symbol as the last element of a list pattern matches\n zero or more remaining elements, bound as a list.' validation.core.atoms.match-splat-impl quote: '# Splat: ?...name as last element matches remaining items\n if (pattern and isinstance(pattern[-1], Symbol)\n and str(pattern[-1]).startswith("?...")):' validation.core.atoms.match-substitute-roundtrip quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' quote: 'Replace symbols with their bound values in an expression tree.' validation.core.atoms.module-claims-pure-types quote: 'Pure types, s-expression reader/printer.' validation.core.atoms.parse-all-doc quote: 'Parse all top-level s-expressions from source.' validation.core.atoms.parse-doc quote: 'Parse a source string into an s-expression.' validation.core.atoms.purity-implies-immutable quote: 'Pure types, s-expression reader/printer.\nNo domain knowledge, no state.' validation.core.atoms.read-tokens-doc quote: 'Recursively parse token list into nested Python structures.' validation.core.atoms.reader-impl-count quote: 'def tokenize(' quote: 'def read_tokens(' quote: 'def atom(' quote: 'def parse(' quote: 'def parse_all(' quote: 'if char == ";":' validation.core.atoms.substitute-doc quote: 'Replace symbols with their bound values in an expression tree.' validation.core.atoms.substitute-splat-doc quote: '``?...name`` bindings are spliced into the parent list rather than\n inserted as a nested list.' validation.core.atoms.substitute-splat-impl quote: 'if (isinstance(sub, Symbol) and str(sub).startswith("?...")\n and sub in bindings):\n val = bindings[sub]\n if isinstance(val, list):\n result.extend(val)' validation.core.atoms.term-display-impl-count quote: '(primitive)' quote: 'to_sexp(self.definition)' validation.core.atoms.term-display-rule quote: 'to_sexp(self.definition) if self.definition is not None else "(primitive)"' validation.core.atoms.term-has-body-display quote: 'to_sexp(self.definition)' validation.core.atoms.term-impl-computed quote: 'to_sexp(self.definition) if self.definition is not None' validation.core.atoms.theorem-impl-wff quote: 'class Theorem:\n """A theorem: a WFF derived from facts, axioms, terms, or other theorems.\n\n Every theorem carries a wff (never None).\n """\n\n name: str\n wff: Any' validation.core.atoms.to-sexp-bool-false quote: 'return "true" if obj else "false"' validation.core.atoms.to-sexp-bool-true quote: 'return "true" if obj else "false"' validation.core.atoms.to-sexp-doc quote: 'Pretty-print a Python object back to s-expression string.' validation.core.atoms.tokenize-doc quote: 'Tokenize s-expression source into atoms and parens.' validation.core.demos.apples-count quote: 'Demo: Parseltongue DSL' validation.core.demos.apples-pltg-count quote: 'Demo: Peano Arithmetic via .pltg' validation.core.demos.apples-pltg-topic quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.' validation.core.demos.biomarkers-count quote: 'Demo: Parseltongue DSL' validation.core.demos.deferred-pltg-count quote: 'Demo: run-on-entry' validation.core.demos.deferred-skips-on-import quote: 'skipped when imported' validation.core.demos.entry-mocks-count quote: 'Demo: run-on-entry as a self-contained unit test' validation.core.demos.entry-mocks-features-impl-count quote: 'run-on-entry as a self-contained unit test with let + mocks' quote: 'rebinds forward-declared primitives' validation.core.demos.entry-mocks-topic quote: 'run-on-entry as a self-contained unit test' validation.core.demos.extensibility-count quote: 'Demo: System Extensibility' validation.core.demos.extensibility-features-impl-count quote: 'System Extensibility' quote: 'load-data' quote: 'Effects are callables that receive (system, *args)' validation.core.demos.extensibility-topic quote: 'System Extensibility' validation.core.demos.extensibility-uses-effects quote: 'pass a' quote: 'load-data' quote: 'effect at construction time' validation.core.demos.pltg-demo-proves-loader-bootstrap quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.\n\nScenario: Same orchard arithmetic as the apples demo, but executed\nentirely through .pltg file loading with an empty initial environment.\nProves that the Loader of modules works correctly to load DSL for\nbootstrapping Peano successor notation, axioms, imports, and derives\nfrom scratch — no Python-side setup.' validation.core.demos.revenue-count quote: 'Demo: Parseltongue DSL in action.' validation.core.demos.revenue-features-impl-count quote: 'Analyzing company performance' quote: 'manual override' validation.core.demos.revenue-topic quote: 'Analyzing company performance' validation.core.demos.self-healing-all-dsl quote: 'The entire flow is written in Parseltongue DSL' validation.core.demos.self-healing-count quote: 'Demo: Self-Healing Probes via Effects' validation.core.demos.self-healing-features-impl-count quote: 'Self-Healing Probes via Effects' quote: 'The entire flow is written in Parseltongue DSL' validation.core.demos.self-healing-topic quote: 'Self-Healing Probes via Effects' validation.core.engine.consistency-checks-three-layers quote: '# 1. Evidence grounding\n unverified = []\n manually_verified = []\n no_evidence = []' quote: '# 2. Fabrication propagation\n fabrications = sorted(\n name\n for name, thm in self.theorems.items()\n if isinstance(thm.origin, str) and "potential fabrication" in thm.origin\n )' quote: '# 3. Diff divergences — evaluated live\n all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' validation.core.engine.diff-evaluated-structurally quote: 'all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' quote: 'downstream_divergent = [d for d in all_diffs if not d.empty and not d.diff_contamination_only]' quote: 'value_divergent = [d for d in all_diffs if d.values_diverge and d.empty]' validation.core.engine.eq-has-rewrite-fallback quote: 'if result is False and head == EQ and any(isinstance(a, list) for a in args):' validation.core.engine.expr-references-recurses-lists quote: 'return any(Engine._expr_references(sub, name) for sub in expr)' validation.core.engine_scopes.delegate-counts-depth quote: 'depth = 0\n e = expr\n while isinstance(e, list) and e and e[0] == DELEGATE:\n depth += 1\n e = e[1]' validation.core.engine_scopes.proposal-binds-from-env quote: 'plain = Symbol(vname.lstrip("?"))\n if plain not in env:\n return []\n bindings[var] = env[plain]' validation.core.engine_scopes.proposal-evaluates-body quote: 'bound_body = substitute(body, bindings)\n return self._eval(\n bound_body, env, axiom_scope, restricted)' validation.core.engine_scopes.proposal-peels-delegate-nesting quote: 'while isinstance(e, list) and e and e[0] == DELEGATE:' validation.core.engine_scopes.proposal-returns-empty-on-mismatch quote: 'if not result:\n return []' validation.core.engine_scopes.scope-checks-self quote: 'if name == SELF:' validation.core.engine_scopes.scope-passes-name-to-callable quote: 'return scope_val(name, *resolved)' validation.core.engine_scopes.scope-resolves-name quote: 'scope_val = self._eval(name, env, axiom_scope, restricted)' validation.core.engine_scopes.self-evaluates-all-args quote: 'if head == SELF:\n # (self expr ...) — evaluate all args in the current engine\n result = None\n for arg in expr[1:]:\n result = self._eval(arg, env, axiom_scope, restricted)\n return result' validation.core.lazy_loader.catches-directive-errors quote: 'try:\n _execute_directive(system.engine, node.expr)\n executed.add(node.name)\n if self._result:\n self._result.loaded.add(node)\n return True\n except Exception as e:\n self._failed_names[node.name] = node' validation.core.lazy_loader.catches-effect-errors quote: 'for expr, ord_idx, line in pre_effects:\n try:\n _execute_directive(system.engine, expr)\n except Exception as e:' validation.core.lazy_loader.catches-parse-errors quote: 'try:\n pre_len = len(tokens)\n expr = read_tokens(tokens)' quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None,\n expr=[],\n dep_names=set(),\n kind="error",\n source_file=self._current.current_file,\n source_order=order,\n source_line=expr_line,\n )' validation.core.lazy_loader.has-line-tracking quote: 'tokens, token_lines = tokenize(source, track_lines=True)' validation.core.lazy_loader.parse-errors-dont-crash quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None, expr=[], dep_names=set(),\n kind="error"' validation.core.lazy_loader.phase-1a-parses-all quote: "# Phase 1a: Parse all expressions, namespace definition names,\n # but DON'T patch body symbols yet (engine is empty)." validation.core.lazy_loader.phase-1c-patches-from-names quote: '# Phase 1c: Now patch body symbols using collected names + aliases,\n # then build DirectiveNodes.' validation.core.lazy_loader.phase-4-topological-exec quote: '# Phase 4: Topological execution of named directives' validation.core.loader.context-resolves-via-registry quote: 'module = self.names_to_modules.get(key_str)' quote: 'if module is not None:' quote: 'ctx = self.modules_contexts[module]' validation.core.loader.effect-behavior-expected quote: 'def print_effect' quote: 'if prop == ":file":' quote: 'if not self._current.is_main:' quote: 'if abs_path in self._file_stack:' quote: 'if abs_path in self._imported:' quote: 'resolved = os.path.normpath' validation.core.loader.effect-import-deduplicates quote: 'if abs_path in self._imported:' quote: 'return True' validation.core.loader.effect-verify-manual-doc quote: 'Effect: (verify-manual name) — manually verify a fact/term/axiom.' validation.core.loader.import-deduplication quote: 'if abs_path in self._imported:' quote: 'log.debug("Module \'%s\' already imported, skipping", module_name)' quote: 'return True' validation.core.loader.import-resolves-dots-to-sep quote: 'module_name.replace(".", os.sep) + ".pltg"' validation.core.loader.loader-namespaces-definitions quote: 'Namespace definition names for non-main modules' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' validation.core.loader.loader-patches-context quote: 'Recursively patch (context :key)' quote: 'patched = f"{self._current.module_name}.{expr[1]}"' validation.core.loader.loader-patches-symbols quote: 'Recursively namespace bare symbols in expression bodies.' quote: 'candidate = f"{self._current.module_name}.{s}"' validation.core.loader.namespacing-only-non-main quote: 'if head in DSL_KEYWORDS or head in SPECIAL_FORMS:' quote: 'if not self._current.is_main:' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' validation.core.system.constructor-params-impl-count quote: 'Composes Engine with default operators' quote: 'overridable: bool = False' quote: 'strict_derive: bool = True' quote: 'effects: dict[str, Callable] | None = None' quote: 'initial_env: dict | None = None' quote: 'docs: dict | None = None' validation.core.system.effects-impl-count quote: 'self.engine.env[Symbol(name)] = lambda *args, _fn=fn: _fn(self, *args)' quote: 'def load_source(system: System, source: str):' validation.core.system.load-source-is-module-fn quote: 'def load_source(system: System, source: str):' validation.core.system.system-docstring quote: 'Composes Engine with default operators, serialization, and introspection.' No evidence provided: core.ast_verifier.stub-source-line-field (origin: TODO: DirectiveNode gained source_line: int = 0 field — quote ast.py and add paired diff) core.atoms.stub-evidence-document-field (origin: TODO: Evidence.document: str — name of registered source document to verify quotes against) core.atoms.stub-evidence-verification-field (origin: TODO: Evidence.verification: list — filled by verifier, list of result dicts with keys: verified, quote, reason, confidence) core.atoms.stub-evidence-verification-result-schema (origin: TODO: Each verification result is a dict with 'verified' (bool), 'quote' (str), 'reason' (str), 'confidence' (dict with 'score', 'level')) core.atoms.stub-track-lines (origin: TODO: tokenize() gained track_lines=True param — returns (tokens, token_lines) tuple for source line tracking) core.domain.manual-control-implies-human (origin: manual verification capability implies human-in-the-loop workflow) core.domain.set-implies-fast (origin: set-based indexing implies fast intersection and lookup) core.engine.stub-delegate-handler (origin: TODO: DELEGATE handler — counts nesting depth, picks from :bind proposal stack) core.engine.stub-delegate-proposal (origin: TODO: _delegate_proposal — peels delegate nesting, binds ?-vars from env + ?_level, evaluates conditional pattern then body) core.engine.stub-project-handler (origin: TODO: PROJECT handler — evaluates in current engine (1 arg) or named basis (2 args)) core.engine.stub-rp (origin: TODO: _rp — project resolution walk inside SCOPE, eagerly evaluates project, posts delegate proposals to :bind stack) core.engine.stub-scope-handler (origin: TODO: SCOPE handler — dispatches to callable or self, resolves project/delegate in args via _rp) core.engine.stub-self-handler (origin: TODO: SELF handler — evaluates all args in current engine (identity scope)) core.engine.stub-suppress-log (origin: TODO: consistency() gained suppress_log: bool = True param — silences log.warning output by default) core.engine_scopes.count-exists (origin: import) core.engine_scopes.stub-scope-error-message (origin: TODO: scope target not callable error message) core.inspect_main.inspect_bench.stub (origin: import) core.inspect_main.inspect_evaluate.stub (origin: import) core.inspect_main.inspect_hologram.stub (origin: import) core.inspect_main.inspect_lens.stub (origin: import) core.inspect_main.inspect_search.stub (origin: import) core.inspect_main.stub (origin: import) core.integrity.count-exists (origin: import) core.integrity.stub (origin: import) core.lang.stub-delegate-lang-docs (origin: TODO: DELEGATE LANG_DOCS entry — :bind stack semantics, ?_level, conditional patterns) core.lang.stub-project-lang-docs (origin: TODO: PROJECT LANG_DOCS entry — evaluate in current or named basis) core.lang.stub-scope-lang-docs (origin: TODO: SCOPE LANG_DOCS entry — dispatches to callable, project resolved eagerly) core.lang.stub-self-lang-docs (origin: TODO: SELF LANG_DOCS entry — identity scope, evaluates in current engine) core.loader.stub-pltg-error (origin: TODO: PltgError exception class added — wraps errors with file:line and import stack trace) core.quote_verifier.stub-original-line (origin: TODO: original_line added to verification result dict — 1-based line number computed from char offset) core.readme.evidence-computes (origin: negation: evidence doesn't compute → false) core.readme.readme-documents-consistency-test-plan (origin: README does not yet document test_parseltongue_core_consistency.py pytest integration for CI) core.readme.readme-documents-core-pltg-plan (origin: README does not yet document core.pltg as top-level orchestrator importing all validation modules) core.readme.readme-documents-introspection-and-self-consistency-plan (origin: README does not yet have an Introspection and Self-Consistency section (provenance walking, state(), self-validation via .pltg modules, the ouroboros)) core.readme.readme-documents-per-module-validators-plan (origin: README does not yet document per-module .pltg verifiers (atoms, lang, engine, system, loader, etc.)) core.readme.readme-documents-self-test-goedel-plan (origin: README does not yet document Gödel incompleteness derive (system cannot prove own consistency)) core.readme.readme-documents-self-test-plan (origin: README does not yet document self_test.pltg (self-referential incompleteness proof)) core.readme.readme-documents-self-test-pytest-plan (origin: README does not yet document system running its own test suite via dangerously-eval) core.readme.readme-documents-self-test-turing-plan (origin: README does not yet document Turing ordinal extension exemplified via axiom→theorem hierarchy) core.readme.readme-documents-validation-framework-plan (origin: README does not yet document the .pltg self-validation system) core.readme.readme-needs-consistency-badge-plan (origin: README should display a self-consistency CI badge from GitLab workflow showing core validation pass/fail status) core.stub (origin: import) core.stub-brief-vs-detailed (origin: TODO: fmt_dsl(brief=True) truncates quotes in structure view; fmt_origin_rows(detailed=True) shows QV line + confidence in detail view) core.stub-inspect-loaded (origin: TODO: inspect_loaded(term, loader) — convenience combining probe + Lens with MDebuggerPerspective) core.stub-lens-api (origin: TODO: Lens class — view, view_layer, view_consumer, view_node, view_inputs, view_subgraph, view_kinds, view_roots, focus) core.stub-mdebugger-perspective (origin: TODO: MDebuggerPerspective takes LazyLoader, annotates output with file:line from AST, uses os.path.relpath) core.stub-perspective-instances (origin: TODO: Perspective instances (not types) — MarkdownPerspective, AsciiPerspective, MDebuggerPerspective) core.stub-probe-structure (origin: TODO: probe(term, engine) → CoreToConsequenceStructure — graph, layers, depths, max_depth) counting.count-exists (origin: variadic existence counter) counting.count-exists-base (origin: base: single argument) counting.count-exists-step (origin: step: peel first, count rest) counting.sum-values (origin: variadic numeric sum) counting.sum-values-base (origin: base: single value) counting.sum-values-step (origin: step: peel first, sum rest) counting.util.export (origin: export command via rewrites) counting.util.export-base (origin: rewrite: identity export — marks a value as intentionally dangling for cross-module use) counting.util.stub (origin: stub) counting.util.stub-base (origin: Stubs allow to make things which don't match anything) epistemics.collapse (origin: collapse a superposed status via observation into a definite status) epistemics.collapse-hypothesised (origin: hypothesised observation collapses superpose to unknown) epistemics.collapse-refuted (origin: refuted observation collapses superpose to hallucinated) epistemics.collapse-witnessed (origin: witnessed observation collapses superpose to exemplifiable) epistemics.count-hallucinated (origin: variadic count of hallucinated statuses) epistemics.count-hallucinated-base (origin: base: single status) epistemics.count-hallucinated-step (origin: step: peel first, count rest) epistemics.exemplifiable (origin: system found a witness — claim is observably grounded) epistemics.hallucinated (origin: system found evidence of failure — claim is demonstrably ungrounded) epistemics.hypothesised (origin: observation: claim proposed but system cannot check either way) epistemics.joint-status (origin: epistemic status of a group — hallucination is contagious) epistemics.joint-status-base (origin: base: single status passes through) epistemics.joint-status-step (origin: step: merge first two, recurse — hallucinated > unknown > exemplifiable) epistemics.joint-superposed (origin: bundle values into a single superposed observation) epistemics.joint-superposed-rewrite (origin: rewrite: joint-superposed wraps all args in strict and superposes them) epistemics.refuted (origin: observation: system found counter-evidence against the claim) epistemics.russell-teapot (origin: Russell's teapot: unwitnessable claims are hallucinated) epistemics.superpose (origin: indeterminate value — one of the listed possibilities) epistemics.unknown (origin: system cannot determine — neither exemplifiable nor provably hallucinated) epistemics.witness (origin: epistemic status labeling — witness a claim's classification) epistemics.witness-base (origin: rewrite: (witness status) returns the status — labels a claim as witnessed) epistemics.witnessed (origin: observation: system found a witness for the claim) lang.count-exists (origin: import) lang.stub-delegate-lang-docs (origin: TODO: DELEGATE LANG_DOCS entry — :bind stack semantics, ?_level, conditional patterns) lang.stub-project-lang-docs (origin: TODO: PROJECT LANG_DOCS entry — evaluate in current or named basis) lang.stub-scope-lang-docs (origin: TODO: SCOPE LANG_DOCS entry — dispatches to callable, project resolved eagerly) lang.stub-self-lang-docs (origin: TODO: SELF LANG_DOCS entry — identity scope, evaluates in current engine) lists.bare-filter (origin: TODO: filter on bare arglist without explicit quote pairs — needs lazy eval) lists.classify (origin: TODO: group items by status using filter — needs lazy eval) lists.concat (origin: variadic list concatenation via double splat) lists.concat-base (origin: base: single list passes through) lists.concat-step (origin: step: merge first two, recurse — needs unquote axiom in :using for 3+ lists) lists.concat-two (origin: two lists: merge via double splat) lists.cons (origin: variadic list constructor — evaluated args to quoted list) lists.cons-base (origin: base: single element to singleton quoted list) lists.cons-prepend (origin: binary prepend — splice element into quoted list head) lists.cons-prepend-rule (origin: rewrite: prepend ?x to list contents) lists.cons-step (origin: step: peel first, recurse tail, prepend via cons-prepend) lists.filter (origin: filter name-value pairs by target match — collect matching names) lists.filter-base (origin: base: single pair — include name if value matches target) lists.filter-step (origin: step: peel pair, include or skip, recurse on rest) lists.fold (origin: left fold — reduce list with binary axiom-function) lists.fold-empty (origin: base: empty list returns accumulator) lists.fold-step (origin: step: apply f to acc and head, recurse on tail) lists.length (origin: count elements via structural recursion) lists.length-base (origin: base: singleton list has length 1) lists.length-step (origin: step: 1 + length of tail) lists.map (origin: apply axiom-function to each element — ?-var head dispatch) lists.map-base (origin: base: singleton — apply and wrap in quoted list) lists.map-step (origin: step: apply to head, prepend to mapped tail) lists.nth (origin: element at index via decrement) lists.nth-base (origin: base: index 0 returns head) lists.nth-step (origin: step: decrement index, recurse on tail) lists.reverse (origin: reverse a list via accumulator) lists.reverse-acc (origin: reverse accumulator helper) lists.reverse-acc-base (origin: base: input exhausted, return accumulator) lists.reverse-acc-step (origin: step: move head to accumulator front) lists.reverse-rule (origin: init: start with empty accumulator) lists.unquote.unquote (origin: rewrite: strip quote wrapper — exposes bare list to splat patterns) lists.uq-concat (origin: concat + unquote bundle — include in :using for variadic list concatenation) unquote.unquote (origin: rewrite: strip quote wrapper — exposes bare list to splat patterns) util.export (origin: export command via rewrites) util.export-base (origin: rewrite: identity export — marks a value as intentionally dangling for cross-module use) util.stub (origin: stub) util.stub-base (origin: Stubs allow to make things which don't match anything) validation.core.ast_verifier.stub-source-line-field (origin: TODO: DirectiveNode gained source_line: int = 0 field — quote ast.py and add paired diff) validation.core.atoms.stub-evidence-document-field (origin: TODO: Evidence.document: str — name of registered source document to verify quotes against) validation.core.atoms.stub-evidence-verification-field (origin: TODO: Evidence.verification: list — filled by verifier, list of result dicts with keys: verified, quote, reason, confidence) validation.core.atoms.stub-evidence-verification-result-schema (origin: TODO: Each verification result is a dict with 'verified' (bool), 'quote' (str), 'reason' (str), 'confidence' (dict with 'score', 'level')) validation.core.atoms.stub-track-lines (origin: TODO: tokenize() gained track_lines=True param — returns (tokens, token_lines) tuple for source line tracking) validation.core.domain.manual-control-implies-human (origin: manual verification capability implies human-in-the-loop workflow) validation.core.domain.set-implies-fast (origin: set-based indexing implies fast intersection and lookup) validation.core.engine.stub-delegate-handler (origin: TODO: DELEGATE handler — counts nesting depth, picks from :bind proposal stack) validation.core.engine.stub-delegate-proposal (origin: TODO: _delegate_proposal — peels delegate nesting, binds ?-vars from env + ?_level, evaluates conditional pattern then body) validation.core.engine.stub-project-handler (origin: TODO: PROJECT handler — evaluates in current engine (1 arg) or named basis (2 args)) validation.core.engine.stub-rp (origin: TODO: _rp — project resolution walk inside SCOPE, eagerly evaluates project, posts delegate proposals to :bind stack) validation.core.engine.stub-scope-handler (origin: TODO: SCOPE handler — dispatches to callable or self, resolves project/delegate in args via _rp) validation.core.engine.stub-self-handler (origin: TODO: SELF handler — evaluates all args in current engine (identity scope)) validation.core.engine.stub-suppress-log (origin: TODO: consistency() gained suppress_log: bool = True param — silences log.warning output by default) validation.core.engine_scopes.count-exists (origin: import) validation.core.engine_scopes.stub-scope-error-message (origin: TODO: scope target not callable error message) validation.core.inspect_main.inspect_bench.stub (origin: import) validation.core.inspect_main.inspect_evaluate.stub (origin: import) validation.core.inspect_main.inspect_hologram.stub (origin: import) validation.core.inspect_main.inspect_lens.stub (origin: import) validation.core.inspect_main.inspect_search.stub (origin: import) validation.core.inspect_main.stub (origin: import) validation.core.integrity.count-exists (origin: import) validation.core.integrity.stub (origin: import) validation.core.lang.stub-delegate-lang-docs (origin: TODO: DELEGATE LANG_DOCS entry — :bind stack semantics, ?_level, conditional patterns) validation.core.lang.stub-project-lang-docs (origin: TODO: PROJECT LANG_DOCS entry — evaluate in current or named basis) validation.core.lang.stub-scope-lang-docs (origin: TODO: SCOPE LANG_DOCS entry — dispatches to callable, project resolved eagerly) validation.core.lang.stub-self-lang-docs (origin: TODO: SELF LANG_DOCS entry — identity scope, evaluates in current engine) validation.core.loader.stub-pltg-error (origin: TODO: PltgError exception class added — wraps errors with file:line and import stack trace) validation.core.quote_verifier.stub-original-line (origin: TODO: original_line added to verification result dict — 1-based line number computed from char offset) validation.core.readme.evidence-computes (origin: negation: evidence doesn't compute → false) validation.core.readme.readme-documents-consistency-test-plan (origin: README does not yet document test_parseltongue_core_consistency.py pytest integration for CI) validation.core.readme.readme-documents-core-pltg-plan (origin: README does not yet document core.pltg as top-level orchestrator importing all validation modules) validation.core.readme.readme-documents-introspection-and-self-consistency-plan (origin: README does not yet have an Introspection and Self-Consistency section (provenance walking, state(), self-validation via .pltg modules, the ouroboros)) validation.core.readme.readme-documents-per-module-validators-plan (origin: README does not yet document per-module .pltg verifiers (atoms, lang, engine, system, loader, etc.)) validation.core.readme.readme-documents-self-test-goedel-plan (origin: README does not yet document Gödel incompleteness derive (system cannot prove own consistency)) validation.core.readme.readme-documents-self-test-plan (origin: README does not yet document self_test.pltg (self-referential incompleteness proof)) validation.core.readme.readme-documents-self-test-pytest-plan (origin: README does not yet document system running its own test suite via dangerously-eval) validation.core.readme.readme-documents-self-test-turing-plan (origin: README does not yet document Turing ordinal extension exemplified via axiom→theorem hierarchy) validation.core.readme.readme-documents-validation-framework-plan (origin: README does not yet document the .pltg self-validation system) validation.core.readme.readme-needs-consistency-badge-plan (origin: README should display a self-consistency CI badge from GitLab workflow showing core validation pass/fail status) validation.core.stub (origin: import) validation.core.stub-brief-vs-detailed (origin: TODO: fmt_dsl(brief=True) truncates quotes in structure view; fmt_origin_rows(detailed=True) shows QV line + confidence in detail view) validation.core.stub-inspect-loaded (origin: TODO: inspect_loaded(term, loader) — convenience combining probe + Lens with MDebuggerPerspective) validation.core.stub-lens-api (origin: TODO: Lens class — view, view_layer, view_consumer, view_node, view_inputs, view_subgraph, view_kinds, view_roots, focus) validation.core.stub-mdebugger-perspective (origin: TODO: MDebuggerPerspective takes LazyLoader, annotates output with file:line from AST, uses os.path.relpath) validation.core.stub-perspective-instances (origin: TODO: Perspective instances (not types) — MarkdownPerspective, AsciiPerspective, MDebuggerPerspective) validation.core.stub-probe-structure (origin: TODO: probe(term, engine) → CoreToConsequenceStructure — graph, layers, depths, max_depth) Potential fabrication: core.ast_verifier.api-paired core.ast_verifier.bound-effects-no-name core.ast_verifier.dep-extraction-count core.ast_verifier.doc-carries-count core.ast_verifier.extract-behavior-count core.ast_verifier.kind-comment-count core.ast_verifier.kind-count core.ast_verifier.node-field-count core.atoms.atom-conv-doc-count core.atoms.bool-false-roundtrip core.atoms.bool-roundtrip-consistent core.atoms.bool-true-roundtrip core.atoms.dsl-helpers-doc-count core.atoms.export-core-types-confirmed core.atoms.export-match-substitute core.atoms.export-parser-stages-count core.atoms.export-splat-confirmed core.atoms.export-substitute-splat core.atoms.export-to-sexp core.atoms.impl-axiom-wff core.atoms.impl-term-computed core.atoms.impl-theorem-wff core.atoms.module-is-stateless core.atoms.module-purity-contract core.atoms.parser-stages-count core.atoms.purity-immutable-bound core.atoms.reader-doc-count core.atoms.splat-doc-count core.atoms.splat-impl-count core.atoms.splat-paired-count core.atoms.term-display-bound core.atoms.term-display-doc-count core.atoms.term-display-full-doc-count core.atoms.to-sexp-exists core.atoms.wff-impl-count core.atoms.wff-paired-count core.demos.apples-features-doc-count core.demos.demo-total-count core.demos.entry-mocks-features-doc-count core.demos.export-extensibility-topic core.demos.export-self-healing-topic core.demos.extensibility-exists core.demos.extensibility-features-doc-count core.demos.pltg-loader-bootstrap-confirmed core.demos.revenue-features-doc-count core.demos.run-on-entry-gating-proven core.demos.self-healing-exists core.demos.self-healing-features-doc-count core.engine.bound-diff-no-evidence core.engine.eval-mechanism-doc-count core.engine.export-diffs-cross-validation core.engine.export-diffs-no-evidence core.engine.export-rewrite-as-functions core.engine.export-three-layers core.engine_scopes.delegate-property-count core.engine_scopes.export-delegate-property-count core.engine_scopes.export-proposal-step-count core.engine_scopes.export-scope-handler-count core.engine_scopes.proposal-step-count core.engine_scopes.scope-handler-count core.engine_scopes.scope-handler-feature-count core.lazy_loader.cascade-produces-skipped core.lazy_loader.export-fault-tolerant core.lazy_loader.export-line-tracking core.lazy_loader.fault-tolerance-count core.lazy_loader.name-collection-enables-patching core.lazy_loader.parse-errors-produce-result core.lazy_loader.phase-count core.lazy_loader.phase-paired core.loader.all-axioms-backed-count core.loader.bound-context-resolves core.loader.bound-import-dedup core.loader.bound-namespacing-only-non-main core.loader.effect-behavior-count core.loader.effect-doc-count core.loader.effect-paired-count core.loader.entry-points-doc-count core.loader.entry-points-impl-count core.loader.export-dot-resolution core.loader.export-import-deduplicates core.loader.export-namespaces core.loader.export-patches-context core.loader.export-patches-symbols core.loader.import-dedup-mechanism core.loader.namespacing-impl-count core.loader.namespacing-stage-count core.loader.safety-axiom-count core.loader.safety-mechanism-count core.namespacing-three-stages-confirmed core.readme-loader-consistent core.splat-impl-confirmed core.system.constructor-params-doc-count core.system.docstring-confirms-composition core.system.effects-doc-count core.system.export-docstring core.system.export-load-source derivation-theorem-count engine-fact-count validation.core.ast_verifier.api-paired validation.core.ast_verifier.bound-effects-no-name validation.core.ast_verifier.dep-extraction-count validation.core.ast_verifier.doc-carries-count validation.core.ast_verifier.extract-behavior-count validation.core.ast_verifier.kind-comment-count validation.core.ast_verifier.kind-count validation.core.ast_verifier.node-field-count validation.core.atoms.atom-conv-doc-count validation.core.atoms.bool-false-roundtrip validation.core.atoms.bool-roundtrip-consistent validation.core.atoms.bool-true-roundtrip validation.core.atoms.dsl-helpers-doc-count validation.core.atoms.export-core-types-confirmed validation.core.atoms.export-match-substitute validation.core.atoms.export-parser-stages-count validation.core.atoms.export-splat-confirmed validation.core.atoms.export-substitute-splat validation.core.atoms.export-to-sexp validation.core.atoms.impl-axiom-wff validation.core.atoms.impl-term-computed validation.core.atoms.impl-theorem-wff validation.core.atoms.module-is-stateless validation.core.atoms.module-purity-contract validation.core.atoms.parser-stages-count validation.core.atoms.purity-immutable-bound validation.core.atoms.reader-doc-count validation.core.atoms.splat-doc-count validation.core.atoms.splat-impl-count validation.core.atoms.splat-paired-count validation.core.atoms.term-display-bound validation.core.atoms.term-display-doc-count validation.core.atoms.term-display-full-doc-count validation.core.atoms.to-sexp-exists validation.core.atoms.wff-impl-count validation.core.atoms.wff-paired-count validation.core.demos.apples-features-doc-count validation.core.demos.demo-total-count validation.core.demos.entry-mocks-features-doc-count validation.core.demos.export-extensibility-topic validation.core.demos.export-self-healing-topic validation.core.demos.extensibility-exists validation.core.demos.extensibility-features-doc-count validation.core.demos.pltg-loader-bootstrap-confirmed validation.core.demos.revenue-features-doc-count validation.core.demos.run-on-entry-gating-proven validation.core.demos.self-healing-exists validation.core.demos.self-healing-features-doc-count validation.core.engine.bound-diff-no-evidence validation.core.engine.eval-mechanism-doc-count validation.core.engine.export-diffs-cross-validation validation.core.engine.export-diffs-no-evidence validation.core.engine.export-rewrite-as-functions validation.core.engine.export-three-layers validation.core.engine_scopes.delegate-property-count validation.core.engine_scopes.export-delegate-property-count validation.core.engine_scopes.export-proposal-step-count validation.core.engine_scopes.export-scope-handler-count validation.core.engine_scopes.proposal-step-count validation.core.engine_scopes.scope-handler-count validation.core.engine_scopes.scope-handler-feature-count validation.core.lazy_loader.cascade-produces-skipped validation.core.lazy_loader.export-fault-tolerant validation.core.lazy_loader.export-line-tracking validation.core.lazy_loader.fault-tolerance-count validation.core.lazy_loader.name-collection-enables-patching validation.core.lazy_loader.parse-errors-produce-result validation.core.lazy_loader.phase-count validation.core.lazy_loader.phase-paired validation.core.loader.all-axioms-backed-count validation.core.loader.bound-context-resolves validation.core.loader.bound-import-dedup validation.core.loader.bound-namespacing-only-non-main validation.core.loader.effect-behavior-count validation.core.loader.effect-doc-count validation.core.loader.effect-paired-count validation.core.loader.entry-points-doc-count validation.core.loader.entry-points-impl-count validation.core.loader.export-dot-resolution validation.core.loader.export-import-deduplicates validation.core.loader.export-namespaces validation.core.loader.export-patches-context validation.core.loader.export-patches-symbols validation.core.loader.import-dedup-mechanism validation.core.loader.namespacing-impl-count validation.core.loader.namespacing-stage-count validation.core.loader.safety-axiom-count validation.core.loader.safety-mechanism-count validation.core.namespacing-three-stages-confirmed validation.core.readme-loader-consistent validation.core.splat-impl-confirmed validation.core.system.constructor-params-doc-count validation.core.system.docstring-confirms-composition validation.core.system.effects-doc-count validation.core.system.export-docstring validation.core.system.export-load-source Diff value divergence: validation.core.ee-computable-directives: validation.core.readme.export-computable-directive-count (5) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.ee-dependents-scan-paired: validation.core.readme.export-diff-scan-paired (5) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.ee-diff-scans-five: validation.core.readme.readme-diff-scans-five-types (True) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.ee-evidence-excluded: validation.core.readme.bound-evidence-excludes-computation (True) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.lang.special-forms-coverage: validation.core.lang.special-forms-doc-count (5) vs validation.core.lang.special-forms-impl-count (9) — values differ validation.core.thm-ast-effects-no-name: validation.core.ast_verifier.bound-effects-no-name (True) vs validation.core.stub-ast-effects-no-name (std.counting.util.stub) — values differ validation.core.thm-ast-extract-behavior: validation.core.ast_verifier.extract-behavior-count (2) vs validation.core.stub-ast-extract-behavior (std.counting.util.stub) — values differ validation.core.thm-ast-graph-behavior: validation.core.ast_verifier.graph-behavior-count (4) vs validation.core.stub-ast-graph-behavior (std.counting.util.stub) — values differ validation.core.thm-ast-identity-paired: validation.core.ast_verifier.identity-paired (1) vs validation.core.stub-ast-identity-paired (std.counting.util.stub) — values differ validation.core.thm-ast-node-identity: validation.core.ast_verifier.node-identity-paired (1) vs validation.core.stub-ast-node-identity (std.counting.util.stub) — values differ validation.core.thm-ast-walk-behavior: validation.core.ast_verifier.walk-behavior-count (2) vs validation.core.stub-ast-walk-behavior (std.counting.util.stub) — values differ validation.core.thm-lazy-effect-rank: validation.core.lazy_loader.export-effect-rank (True) vs validation.core.stub-lazy-effect-rank (std.counting.util.stub) — values differ validation.core.thm-lazy-entry-points: validation.core.lazy_loader.entry-point-count (3) vs validation.core.stub-lazy-entry-points (std.counting.util.stub) — values differ validation.core.thm-lazy-fault-tolerance: validation.core.lazy_loader.fault-tolerance-count (6) vs validation.core.stub-lazy-fault-tolerance (std.counting.util.stub) — values differ validation.core.thm-lazy-line-tracking: validation.core.lazy_loader.export-line-tracking (True) vs validation.core.stub-lazy-line-tracking (std.counting.util.stub) — values differ validation.core.thm-lazy-patch-paired: validation.core.lazy_loader.patch-paired (2) vs validation.core.stub-lazy-patch-paired (std.counting.util.stub) — values differ validation.core.thm-lazy-post-effects: validation.core.lazy_loader.export-post-directive-effects (True) vs validation.core.stub-lazy-post-effects (std.counting.util.stub) — values differ validation.core.thm-lazy-pre-effects: validation.core.lazy_loader.export-pre-directive-effects (True) vs validation.core.stub-lazy-pre-effects (std.counting.util.stub) — values differ validation.core.thm-readme-special-forms: validation.core.readme.export-special-forms-count (4) vs validation.core.lang.special-forms-tuple-size (8) — values differ [warning] Manually verified: c.count-exists, c.count-exists-base, c.count-exists-step, c.sum-values, c.sum-values-base, c.sum-values-step, c.util.export, c.util.export-base, c.util.stub, c.util.stub-base, core.ast_verifier.count-exists, core.atoms.count-exists, core.count-exists, core.default_system_settings.count-exists, core.demos.count-exists, core.engine.count-exists, core.lang.count-exists, core.lazy_loader.count-exists, core.loader.count-exists, core.pyproject.count-exists, core.quote_verifier.count-exists, core.quote_verifier.empty-has-no-content, core.quote_verifier.empty-verified-result, core.quote_verifier.no-transformations, core.quote_verifier.normalized-empty-verified, core.quote_verifier.normalized-has-content, core.quote_verifier.quote-has-content, core.quote_verifier.regular-is-not-dangerous, core.quote_verifier.regular-single-count, core.quote_verifier.regular-word-count, core.quote_verifier.remove-stopwords-enabled, core.quote_verifier.score-after-single-dangerous, core.quote_verifier.single-stopword-verified, core.quote_verifier.single-word-is-single, core.quote_verifier.single-word-is-stopword, core.quote_verifier.sum-values, core.readme.axiom-status, core.readme.count-exists, core.system.count-exists, std.counting.count-exists, std.counting.count-exists-base, std.counting.count-exists-step, std.counting.sum-values, std.counting.sum-values-base, std.counting.sum-values-step, std.counting.util.export, std.counting.util.export-base, std.counting.util.stub, std.counting.util.stub-base, std.epistemics.collapse, std.epistemics.collapse-hypothesised, std.epistemics.collapse-refuted, std.epistemics.collapse-witnessed, std.epistemics.count-hallucinated, std.epistemics.count-hallucinated-base, std.epistemics.count-hallucinated-step, std.epistemics.exemplifiable, std.epistemics.hallucinated, std.epistemics.hypothesised, std.epistemics.joint-status, std.epistemics.joint-status-base, std.epistemics.joint-status-step, std.epistemics.joint-superposed, std.epistemics.joint-superposed-rewrite, std.epistemics.refuted, std.epistemics.russell-teapot, std.epistemics.superpose, std.epistemics.unknown, std.epistemics.witness, std.epistemics.witness-base, std.epistemics.witnessed, std.lists.bare-filter, std.lists.classify, std.lists.concat, std.lists.concat-base, std.lists.concat-step, std.lists.concat-two, std.lists.cons, std.lists.cons-base, std.lists.cons-prepend, std.lists.cons-prepend-rule, std.lists.cons-step, std.lists.filter, std.lists.filter-base, std.lists.filter-step, std.lists.fold, std.lists.fold-empty, std.lists.fold-step, std.lists.length, std.lists.length-base, std.lists.length-step, std.lists.map, std.lists.map-base, std.lists.map-step, std.lists.nth, std.lists.nth-base, std.lists.nth-step, std.lists.reverse, std.lists.reverse-acc, std.lists.reverse-acc-base, std.lists.reverse-acc-step, std.lists.reverse-rule, std.lists.unquote.unquote, std.lists.uq-concat, std.std.higher_order.apply, std.std.higher_order.apply-1, std.std.higher_order.apply-2, std.std.higher_order.apply-3, std.std.higher_order.compose, std.std.higher_order.compose-rule, std.std.higher_order.pipe, std.std.higher_order.pipe-base, std.std.higher_order.pipe-step, std.std.predicates.all, std.std.predicates.all-base, std.std.predicates.all-step, std.std.predicates.any-true, std.std.predicates.any-true-base, std.std.predicates.any-true-step, std.std.predicates.member, std.std.predicates.member-base, std.std.predicates.member-step, std.std.predicates.none, std.std.predicates.none-rule, std.util.export, std.util.export-base, std.util.stub, std.util.stub-base, validation.core.ast_verifier.count-exists, validation.core.atoms.count-exists, validation.core.count-exists, validation.core.default_system_settings.count-exists, validation.core.demos.count-exists, validation.core.engine.count-exists, validation.core.lang.count-exists, validation.core.lazy_loader.count-exists, validation.core.loader.count-exists, validation.core.pyproject.count-exists, validation.core.quote_verifier.count-exists, validation.core.quote_verifier.empty-has-no-content, validation.core.quote_verifier.empty-verified-result, validation.core.quote_verifier.no-transformations, validation.core.quote_verifier.normalized-empty-verified, validation.core.quote_verifier.normalized-has-content, validation.core.quote_verifier.quote-has-content, validation.core.quote_verifier.regular-is-not-dangerous, validation.core.quote_verifier.regular-single-count, validation.core.quote_verifier.regular-word-count, validation.core.quote_verifier.remove-stopwords-enabled, validation.core.quote_verifier.score-after-single-dangerous, validation.core.quote_verifier.single-stopword-verified, validation.core.quote_verifier.single-word-is-single, validation.core.quote_verifier.single-word-is-stopword, validation.core.quote_verifier.sum-values, validation.core.readme.axiom-status, validation.core.readme.count-exists, validation.core.system.count-exists [warning] diff_contamination: validation.core.ast_verifier.kind-vs-dep-extraction, validation.core.atoms.match-splat-pair, validation.core.atoms.substitute-splat-pair, validation.core.atoms.wff-paired-vs-doc, validation.core.atoms.wff-paired-vs-impl, validation.core.default_system_settings.arith-decl-vs-category, validation.core.default_system_settings.arith-decl-vs-docs, validation.core.default_system_settings.arith-docs-vs-category, validation.core.default_system_settings.arith-docs-vs-impl, validation.core.default_system_settings.arith-impl-vs-category, validation.core.default_system_settings.comp-decl-vs-category, validation.core.default_system_settings.comp-decl-vs-docs, validation.core.default_system_settings.comp-docs-vs-category, validation.core.default_system_settings.comp-docs-vs-impl, validation.core.default_system_settings.comp-impl-vs-category, validation.core.default_system_settings.decl-vs-docs-total, validation.core.default_system_settings.docs-vs-impl-total, validation.core.default_system_settings.logic-decl-vs-category, validation.core.default_system_settings.logic-decl-vs-docs, validation.core.default_system_settings.logic-docs-vs-category, validation.core.default_system_settings.logic-docs-vs-impl, validation.core.default_system_settings.logic-impl-vs-category, validation.core.default_system_settings.paired-vs-decl-total, validation.core.default_system_settings.paired-vs-docs-total, validation.core.default_system_settings.paired-vs-impl-total, validation.core.default_system_settings.paired-vs-total, validation.core.default_system_settings.total-decl-vs-total, validation.core.default_system_settings.total-docs-vs-total, validation.core.default_system_settings.total-impl-vs-total, validation.core.demo-count, validation.core.demos.apples-splats-all-gt-doc-vs-impl, validation.core.demos.apples-splats-count-gt-doc-vs-impl, validation.core.demos.apples-splats-doc-vs-impl, validation.core.demos.apples-splats-splat-pair, validation.core.demos.apples-splats-sum-all-doc-vs-impl, validation.core.demos.lazy-label-vs-reality, validation.core.demos.self-healing-doc-vs-impl, validation.core.demos.spec-divergence-doc-vs-impl, validation.core.demos.spec-expiry-doc-vs-impl, validation.core.demos.spec-md5-doc-vs-impl, validation.core.demos.spec-session-doc-vs-impl, validation.core.engine.consistency-layers-coverage, validation.core.engine.defaults-coverage, validation.core.engine.dependents-paired-vs-doc, validation.core.engine.dependents-paired-vs-impl, validation.core.engine.doc-mgmt-paired-vs-doc, validation.core.engine.doc-mgmt-paired-vs-impl, validation.core.engine.eval-diff-contamination-paired-vs-doc, validation.core.engine.eval-diff-contamination-paired-vs-impl, validation.core.engine.unknown-vs-warnings, validation.core.engine.warning-layers-consistent, validation.core.forward-decl, validation.core.lang.directive-vs-keyword-count, validation.core.lazy-count-match, validation.core.lazy_loader.phase-impl-vs-paired, validation.core.lazy_loader.result-doc-vs-impl, validation.core.loader.consistency-facts-vs-axioms, validation.core.loader.effect-doc-vs-impl, validation.core.loader.effect-doc-vs-total, validation.core.loader.effect-impl-vs-total, validation.core.loader.effect-paired-vs-doc, validation.core.loader.effect-paired-vs-impl, validation.core.loader.effect-paired-vs-total, validation.core.misc-evidence-first-class, validation.core.mod-lazy-result-errors, validation.core.mod-lazy-result-loaded, validation.core.mod-lazy-result-ok, validation.core.mod-lazy-result-partial, validation.core.mod-lazy-result-skipped, validation.core.quote_verifier.axiom-paired-vs-doc, validation.core.quote_verifier.axiom-paired-vs-impl, validation.core.quote_verifier.flag-paired-vs-config, validation.core.quote_verifier.flag-paired-vs-doc, validation.core.quote_verifier.flag-paired-vs-init, validation.core.quote_verifier.level-paired-vs-doc, validation.core.quote_verifier.level-paired-vs-enum, validation.core.quote_verifier.level-paired-vs-usage, validation.core.quote_verifier.match-paired-vs-doc, validation.core.quote_verifier.match-paired-vs-enum, validation.core.quote_verifier.match-paired-vs-usage, validation.core.quote_verifier.medium-vs-default-threshold, validation.core.quote_verifier.paired-vs-config, validation.core.quote_verifier.paired-vs-usage, validation.core.quote_verifier.penalty-config-vs-usage, validation.core.quote_verifier.result-paired-vs-api, validation.core.quote_verifier.result-paired-vs-doc, validation.core.quote_verifier.result-paired-vs-impl, validation.core.readme-vs-ast-kinds, validation.core.readme-vs-directive-node, validation.core.readme-vs-lazy-phases, validation.core.readme-vs-loader-effect-count, validation.core.readme-vs-qv-hypotheticals, validation.core.readme.readme-ast-fields-vs-stated, validation.core.readme.readme-demo-listing-vs-count, validation.core.readme.readme-demo-paired-vs-listing, validation.core.readme.readme-diff-scan-paired-vs-computable, validation.core.readme.readme-diff-scan-paired-vs-scan, validation.core.readme.readme-directive-listing-vs-stated, validation.core.readme.readme-issue-types-vs-stated, validation.core.readme.readme-lazy-phases-vs-stated, validation.core.readme.readme-manual-categories-vs-stated, validation.core.readme.readme-special-forms-vs-stated, validation.core.readme.readme-warning-types-vs-stated, validation.core.special-forms-count, validation.core.splat-readme-vs-demo, validation.core.splat-readme-vs-impl, validation.core.sys-retract, validation.core.sys-serialization, validation.core.thm-import-circular, validation.core.thm-readme-issue-types, validation.core.thm-readme-warning-types System inconsistent: 4 issue(s) Unverified evidence: core.ast_verifier.derive-extracts-from-using quote: 'using = get_keyword(expr, KW_USING, [])\n if isinstance(using, list):\n for s in using:\n deps.add(str(s))' core.ast_verifier.doc-carries-children quote: '- Resolved child node references (nodes this directive depends on)' core.ast_verifier.doc-carries-dep-names quote: '- The set of symbol dependency names (unresolved)' core.ast_verifier.doc-carries-dependents quote: '- Resolved dependent node references (nodes that depend on this one)' core.ast_verifier.doc-carries-expr quote: '- The raw expression for later execution' core.ast_verifier.doc-carries-kind quote: '- The directive kind (fact, axiom, defterm, derive, diff, effect)' core.ast_verifier.doc-carries-name quote: '- The defined name (if any)' core.ast_verifier.doc-carries-source-file quote: '- The source file path that defined the directive' core.ast_verifier.doc-carries-source-order quote: '- The source order (parse position within the file)' core.ast_verifier.effects-have-no-name quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' core.ast_verifier.extract-recurses-lists quote: 'elif isinstance(expr, list):\n for item in expr:\n extract_symbols(item, out)' core.ast_verifier.kind-comment-axiom quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-defterm quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-derive quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-diff quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-effect quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-comment-fact quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.ast_verifier.kind-effect quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' core.ast_verifier.node-has-kind quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' core.atoms.atom-conv-impl-count quote: 'return int(token)' quote: 'return float(token)' quote: 'if token.startswith(":"):' quote: 'if token == "false":' quote: 'return Symbol(token)' core.atoms.atom-doc quote: 'Convert a token string to a typed value.' core.atoms.atom-fallback-is-symbol quote: 'return Symbol(token)' core.atoms.atom-false-token quote: 'if token == "false":' core.atoms.atom-keyword-prefix quote: 'if token.startswith(":"):' core.atoms.atom-tries-float-second quote: 'return float(token)' core.atoms.atom-tries-int-first quote: 'return int(token)' core.atoms.atom-true-token quote: 'if token == "true":' core.atoms.axiom-impl-wff quote: 'class Axiom:\n """An axiom: a foundational WFF assumed true, with evidence.\n\n Every axiom carries a wff (never None).\n """\n\n name: str\n wff: Any' core.atoms.comment-char quote: 'if char == ";":' core.atoms.dsl-helpers-impl-count quote: 'def match(' quote: 'def free_vars(' quote: 'def substitute(' quote: 'def to_sexp(' core.atoms.free-vars-doc quote: 'Extract all ?-prefixed symbols from an expression.' core.atoms.match-doc quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' core.atoms.match-splat-doc quote: 'A ``?...name`` symbol as the last element of a list pattern matches\n zero or more remaining elements, bound as a list.' core.atoms.match-splat-impl quote: '# Splat: ?...name as last element matches remaining items\n if (pattern and isinstance(pattern[-1], Symbol)\n and str(pattern[-1]).startswith("?...")):' core.atoms.match-substitute-roundtrip quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' quote: 'Replace symbols with their bound values in an expression tree.' core.atoms.module-claims-pure-types quote: 'Pure types, s-expression reader/printer.' core.atoms.parse-all-doc quote: 'Parse all top-level s-expressions from source.' core.atoms.parse-doc quote: 'Parse a source string into an s-expression.' core.atoms.purity-implies-immutable quote: 'Pure types, s-expression reader/printer.\nNo domain knowledge, no state.' core.atoms.read-tokens-doc quote: 'Recursively parse token list into nested Python structures.' core.atoms.reader-impl-count quote: 'def tokenize(' quote: 'def read_tokens(' quote: 'def atom(' quote: 'def parse(' quote: 'def parse_all(' quote: 'if char == ";":' core.atoms.substitute-doc quote: 'Replace symbols with their bound values in an expression tree.' core.atoms.substitute-splat-doc quote: '``?...name`` bindings are spliced into the parent list rather than\n inserted as a nested list.' core.atoms.substitute-splat-impl quote: 'if (isinstance(sub, Symbol) and str(sub).startswith("?...")\n and sub in bindings):\n val = bindings[sub]\n if isinstance(val, list):\n result.extend(val)' core.atoms.term-display-impl-count quote: '(primitive)' quote: 'to_sexp(self.definition)' core.atoms.term-display-rule quote: 'to_sexp(self.definition) if self.definition is not None else "(primitive)"' core.atoms.term-has-body-display quote: 'to_sexp(self.definition)' core.atoms.term-impl-computed quote: 'to_sexp(self.definition) if self.definition is not None' core.atoms.theorem-impl-wff quote: 'class Theorem:\n """A theorem: a WFF derived from facts, axioms, terms, or other theorems.\n\n Every theorem carries a wff (never None).\n """\n\n name: str\n wff: Any' core.atoms.to-sexp-bool-false quote: 'return "true" if obj else "false"' core.atoms.to-sexp-bool-true quote: 'return "true" if obj else "false"' core.atoms.to-sexp-doc quote: 'Pretty-print a Python object back to s-expression string.' core.atoms.tokenize-doc quote: 'Tokenize s-expression source into atoms and parens.' core.demos.apples-count quote: 'Demo: Parseltongue DSL' core.demos.apples-pltg-count quote: 'Demo: Peano Arithmetic via .pltg' core.demos.apples-pltg-topic quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.' core.demos.biomarkers-count quote: 'Demo: Parseltongue DSL' core.demos.deferred-pltg-count quote: 'Demo: run-on-entry' core.demos.deferred-skips-on-import quote: 'skipped when imported' core.demos.entry-mocks-count quote: 'Demo: run-on-entry as a self-contained unit test' core.demos.entry-mocks-features-impl-count quote: 'run-on-entry as a self-contained unit test with let + mocks' quote: 'rebinds forward-declared primitives' core.demos.entry-mocks-topic quote: 'run-on-entry as a self-contained unit test' core.demos.extensibility-count quote: 'Demo: System Extensibility' core.demos.extensibility-features-impl-count quote: 'System Extensibility' quote: 'load-data' quote: 'Effects are callables that receive (system, *args)' core.demos.extensibility-topic quote: 'System Extensibility' core.demos.extensibility-uses-effects quote: 'pass a' quote: 'load-data' quote: 'effect at construction time' core.demos.pltg-demo-proves-loader-bootstrap quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.\n\nScenario: Same orchard arithmetic as the apples demo, but executed\nentirely through .pltg file loading with an empty initial environment.\nProves that the Loader of modules works correctly to load DSL for\nbootstrapping Peano successor notation, axioms, imports, and derives\nfrom scratch — no Python-side setup.' core.demos.revenue-count quote: 'Demo: Parseltongue DSL in action.' core.demos.revenue-features-impl-count quote: 'Analyzing company performance' quote: 'manual override' core.demos.revenue-topic quote: 'Analyzing company performance' core.demos.self-healing-all-dsl quote: 'The entire flow is written in Parseltongue DSL' core.demos.self-healing-count quote: 'Demo: Self-Healing Probes via Effects' core.demos.self-healing-features-impl-count quote: 'Self-Healing Probes via Effects' quote: 'The entire flow is written in Parseltongue DSL' core.demos.self-healing-topic quote: 'Self-Healing Probes via Effects' core.engine.consistency-checks-three-layers quote: '# 1. Evidence grounding\n unverified = []\n manually_verified = []\n no_evidence = []' quote: '# 2. Fabrication propagation\n fabrications = sorted(\n name\n for name, thm in self.theorems.items()\n if isinstance(thm.origin, str) and "potential fabrication" in thm.origin\n )' quote: '# 3. Diff divergences — evaluated live\n all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' core.engine.diff-evaluated-structurally quote: 'all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' quote: 'downstream_divergent = [d for d in all_diffs if not d.empty and not d.diff_contamination_only]' quote: 'value_divergent = [d for d in all_diffs if d.values_diverge and d.empty]' core.engine.eq-has-rewrite-fallback quote: 'if result is False and head == EQ and any(isinstance(a, list) for a in args):' core.engine.expr-references-recurses-lists quote: 'return any(Engine._expr_references(sub, name) for sub in expr)' core.engine_scopes.delegate-counts-depth quote: 'depth = 0\n e = expr\n while isinstance(e, list) and e and e[0] == DELEGATE:\n depth += 1\n e = e[1]' core.engine_scopes.proposal-binds-from-env quote: 'plain = Symbol(vname.lstrip("?"))\n if plain not in env:\n return []\n bindings[var] = env[plain]' core.engine_scopes.proposal-evaluates-body quote: 'bound_body = substitute(body, bindings)\n return self._eval(\n bound_body, env, axiom_scope, restricted)' core.engine_scopes.proposal-peels-delegate-nesting quote: 'while isinstance(e, list) and e and e[0] == DELEGATE:' core.engine_scopes.proposal-returns-empty-on-mismatch quote: 'if not result:\n return []' core.engine_scopes.scope-checks-self quote: 'if name == SELF:' core.engine_scopes.scope-passes-name-to-callable quote: 'return scope_val(name, *resolved)' core.engine_scopes.scope-resolves-name quote: 'scope_val = self._eval(name, env, axiom_scope, restricted)' core.engine_scopes.self-evaluates-all-args quote: 'if head == SELF:\n # (self expr ...) — evaluate all args in the current engine\n result = None\n for arg in expr[1:]:\n result = self._eval(arg, env, axiom_scope, restricted)\n return result' core.lazy_loader.catches-directive-errors quote: 'try:\n _execute_directive(system.engine, node.expr)\n executed.add(node.name)\n if self._result:\n self._result.loaded.add(node)\n return True\n except Exception as e:\n self._failed_names[node.name] = node' core.lazy_loader.catches-effect-errors quote: 'for expr, ord_idx, line in pre_effects:\n try:\n _execute_directive(system.engine, expr)\n except Exception as e:' core.lazy_loader.catches-parse-errors quote: 'try:\n pre_len = len(tokens)\n expr = read_tokens(tokens)' quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None,\n expr=[],\n dep_names=set(),\n kind="error",\n source_file=self._current.current_file,\n source_order=order,\n source_line=expr_line,\n )' core.lazy_loader.has-line-tracking quote: 'tokens, token_lines = tokenize(source, track_lines=True)' core.lazy_loader.parse-errors-dont-crash quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None, expr=[], dep_names=set(),\n kind="error"' core.lazy_loader.phase-1a-parses-all quote: "# Phase 1a: Parse all expressions, namespace definition names,\n # but DON'T patch body symbols yet (engine is empty)." core.lazy_loader.phase-1c-patches-from-names quote: '# Phase 1c: Now patch body symbols using collected names + aliases,\n # then build DirectiveNodes.' core.lazy_loader.phase-4-topological-exec quote: '# Phase 4: Topological execution of named directives' core.loader.context-resolves-via-registry quote: 'module = self.names_to_modules.get(key_str)' quote: 'if module is not None:' quote: 'ctx = self.modules_contexts[module]' core.loader.effect-behavior-expected quote: 'def print_effect' quote: 'if prop == ":file":' quote: 'if not self._current.is_main:' quote: 'if abs_path in self._file_stack:' quote: 'if abs_path in self._imported:' quote: 'resolved = os.path.normpath' core.loader.effect-import-deduplicates quote: 'if abs_path in self._imported:' quote: 'return True' core.loader.effect-verify-manual-doc quote: 'Effect: (verify-manual name) — manually verify a fact/term/axiom.' core.loader.import-deduplication quote: 'if abs_path in self._imported:' quote: 'log.debug("Module \'%s\' already imported, skipping", module_name)' quote: 'return True' core.loader.import-resolves-dots-to-sep quote: 'module_name.replace(".", os.sep) + ".pltg"' core.loader.loader-namespaces-definitions quote: 'Namespace definition names for non-main modules' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' core.loader.loader-patches-context quote: 'Recursively patch (context :key)' quote: 'patched = f"{self._current.module_name}.{expr[1]}"' core.loader.loader-patches-symbols quote: 'Recursively namespace bare symbols in expression bodies.' quote: 'candidate = f"{self._current.module_name}.{s}"' core.loader.namespacing-only-non-main quote: 'if head in DSL_KEYWORDS or head in SPECIAL_FORMS:' quote: 'if not self._current.is_main:' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' core.system.constructor-params-impl-count quote: 'Composes Engine with default operators' quote: 'overridable: bool = False' quote: 'strict_derive: bool = True' quote: 'effects: dict[str, Callable] | None = None' quote: 'initial_env: dict | None = None' quote: 'docs: dict | None = None' core.system.effects-impl-count quote: 'self.engine.env[Symbol(name)] = lambda *args, _fn=fn: _fn(self, *args)' quote: 'def load_source(system: System, source: str):' core.system.load-source-is-module-fn quote: 'def load_source(system: System, source: str):' core.system.system-docstring quote: 'Composes Engine with default operators, serialization, and introspection.' validation.core.ast_verifier.derive-extracts-from-using quote: 'using = get_keyword(expr, KW_USING, [])\n if isinstance(using, list):\n for s in using:\n deps.add(str(s))' validation.core.ast_verifier.doc-carries-children quote: '- Resolved child node references (nodes this directive depends on)' validation.core.ast_verifier.doc-carries-dep-names quote: '- The set of symbol dependency names (unresolved)' validation.core.ast_verifier.doc-carries-dependents quote: '- Resolved dependent node references (nodes that depend on this one)' validation.core.ast_verifier.doc-carries-expr quote: '- The raw expression for later execution' validation.core.ast_verifier.doc-carries-kind quote: '- The directive kind (fact, axiom, defterm, derive, diff, effect)' validation.core.ast_verifier.doc-carries-name quote: '- The defined name (if any)' validation.core.ast_verifier.doc-carries-source-file quote: '- The source file path that defined the directive' validation.core.ast_verifier.doc-carries-source-order quote: '- The source order (parse position within the file)' validation.core.ast_verifier.effects-have-no-name quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' validation.core.ast_verifier.extract-recurses-lists quote: 'elif isinstance(expr, list):\n for item in expr:\n extract_symbols(item, out)' validation.core.ast_verifier.kind-comment-axiom quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-defterm quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-derive quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-diff quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-effect quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-comment-fact quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.ast_verifier.kind-effect quote: 'return DirectiveNode(name=None, expr=expr, dep_names=set(), kind="effect", source_order=order)' validation.core.ast_verifier.node-has-kind quote: 'kind: str # "fact", "axiom", "defterm", "derive", "diff", "effect"' validation.core.atoms.atom-conv-impl-count quote: 'return int(token)' quote: 'return float(token)' quote: 'if token.startswith(":"):' quote: 'if token == "false":' quote: 'return Symbol(token)' validation.core.atoms.atom-doc quote: 'Convert a token string to a typed value.' validation.core.atoms.atom-fallback-is-symbol quote: 'return Symbol(token)' validation.core.atoms.atom-false-token quote: 'if token == "false":' validation.core.atoms.atom-keyword-prefix quote: 'if token.startswith(":"):' validation.core.atoms.atom-tries-float-second quote: 'return float(token)' validation.core.atoms.atom-tries-int-first quote: 'return int(token)' validation.core.atoms.atom-true-token quote: 'if token == "true":' validation.core.atoms.axiom-impl-wff quote: 'class Axiom:\n """An axiom: a foundational WFF assumed true, with evidence.\n\n Every axiom carries a wff (never None).\n """\n\n name: str\n wff: Any' validation.core.atoms.comment-char quote: 'if char == ";":' validation.core.atoms.dsl-helpers-impl-count quote: 'def match(' quote: 'def free_vars(' quote: 'def substitute(' quote: 'def to_sexp(' validation.core.atoms.free-vars-doc quote: 'Extract all ?-prefixed symbols from an expression.' validation.core.atoms.match-doc quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' validation.core.atoms.match-splat-doc quote: 'A ``?...name`` symbol as the last element of a list pattern matches\n zero or more remaining elements, bound as a list.' validation.core.atoms.match-splat-impl quote: '# Splat: ?...name as last element matches remaining items\n if (pattern and isinstance(pattern[-1], Symbol)\n and str(pattern[-1]).startswith("?...")):' validation.core.atoms.match-substitute-roundtrip quote: 'Match pattern against expr. ?-prefixed symbols are pattern variables.' quote: 'Replace symbols with their bound values in an expression tree.' validation.core.atoms.module-claims-pure-types quote: 'Pure types, s-expression reader/printer.' validation.core.atoms.parse-all-doc quote: 'Parse all top-level s-expressions from source.' validation.core.atoms.parse-doc quote: 'Parse a source string into an s-expression.' validation.core.atoms.purity-implies-immutable quote: 'Pure types, s-expression reader/printer.\nNo domain knowledge, no state.' validation.core.atoms.read-tokens-doc quote: 'Recursively parse token list into nested Python structures.' validation.core.atoms.reader-impl-count quote: 'def tokenize(' quote: 'def read_tokens(' quote: 'def atom(' quote: 'def parse(' quote: 'def parse_all(' quote: 'if char == ";":' validation.core.atoms.substitute-doc quote: 'Replace symbols with their bound values in an expression tree.' validation.core.atoms.substitute-splat-doc quote: '``?...name`` bindings are spliced into the parent list rather than\n inserted as a nested list.' validation.core.atoms.substitute-splat-impl quote: 'if (isinstance(sub, Symbol) and str(sub).startswith("?...")\n and sub in bindings):\n val = bindings[sub]\n if isinstance(val, list):\n result.extend(val)' validation.core.atoms.term-display-impl-count quote: '(primitive)' quote: 'to_sexp(self.definition)' validation.core.atoms.term-display-rule quote: 'to_sexp(self.definition) if self.definition is not None else "(primitive)"' validation.core.atoms.term-has-body-display quote: 'to_sexp(self.definition)' validation.core.atoms.term-impl-computed quote: 'to_sexp(self.definition) if self.definition is not None' validation.core.atoms.theorem-impl-wff quote: 'class Theorem:\n """A theorem: a WFF derived from facts, axioms, terms, or other theorems.\n\n Every theorem carries a wff (never None).\n """\n\n name: str\n wff: Any' validation.core.atoms.to-sexp-bool-false quote: 'return "true" if obj else "false"' validation.core.atoms.to-sexp-bool-true quote: 'return "true" if obj else "false"' validation.core.atoms.to-sexp-doc quote: 'Pretty-print a Python object back to s-expression string.' validation.core.atoms.tokenize-doc quote: 'Tokenize s-expression source into atoms and parens.' validation.core.demos.apples-count quote: 'Demo: Parseltongue DSL' validation.core.demos.apples-pltg-count quote: 'Demo: Peano Arithmetic via .pltg' validation.core.demos.apples-pltg-topic quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.' validation.core.demos.biomarkers-count quote: 'Demo: Parseltongue DSL' validation.core.demos.deferred-pltg-count quote: 'Demo: run-on-entry' validation.core.demos.deferred-skips-on-import quote: 'skipped when imported' validation.core.demos.entry-mocks-count quote: 'Demo: run-on-entry as a self-contained unit test' validation.core.demos.entry-mocks-features-impl-count quote: 'run-on-entry as a self-contained unit test with let + mocks' quote: 'rebinds forward-declared primitives' validation.core.demos.entry-mocks-topic quote: 'run-on-entry as a self-contained unit test' validation.core.demos.extensibility-count quote: 'Demo: System Extensibility' validation.core.demos.extensibility-features-impl-count quote: 'System Extensibility' quote: 'load-data' quote: 'Effects are callables that receive (system, *args)' validation.core.demos.extensibility-topic quote: 'System Extensibility' validation.core.demos.extensibility-uses-effects quote: 'pass a' quote: 'load-data' quote: 'effect at construction time' validation.core.demos.pltg-demo-proves-loader-bootstrap quote: 'Demo: Peano Arithmetic via .pltg — Empty-Env Module Loading.\n\nScenario: Same orchard arithmetic as the apples demo, but executed\nentirely through .pltg file loading with an empty initial environment.\nProves that the Loader of modules works correctly to load DSL for\nbootstrapping Peano successor notation, axioms, imports, and derives\nfrom scratch — no Python-side setup.' validation.core.demos.revenue-count quote: 'Demo: Parseltongue DSL in action.' validation.core.demos.revenue-features-impl-count quote: 'Analyzing company performance' quote: 'manual override' validation.core.demos.revenue-topic quote: 'Analyzing company performance' validation.core.demos.self-healing-all-dsl quote: 'The entire flow is written in Parseltongue DSL' validation.core.demos.self-healing-count quote: 'Demo: Self-Healing Probes via Effects' validation.core.demos.self-healing-features-impl-count quote: 'Self-Healing Probes via Effects' quote: 'The entire flow is written in Parseltongue DSL' validation.core.demos.self-healing-topic quote: 'Self-Healing Probes via Effects' validation.core.engine.consistency-checks-three-layers quote: '# 1. Evidence grounding\n unverified = []\n manually_verified = []\n no_evidence = []' quote: '# 2. Fabrication propagation\n fabrications = sorted(\n name\n for name, thm in self.theorems.items()\n if isinstance(thm.origin, str) and "potential fabrication" in thm.origin\n )' quote: '# 3. Diff divergences — evaluated live\n all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' validation.core.engine.diff-evaluated-structurally quote: 'all_diffs = sorted((self.eval_diff(n) for n in self.diffs), key=lambda d: d.name)' quote: 'downstream_divergent = [d for d in all_diffs if not d.empty and not d.diff_contamination_only]' quote: 'value_divergent = [d for d in all_diffs if d.values_diverge and d.empty]' validation.core.engine.eq-has-rewrite-fallback quote: 'if result is False and head == EQ and any(isinstance(a, list) for a in args):' validation.core.engine.expr-references-recurses-lists quote: 'return any(Engine._expr_references(sub, name) for sub in expr)' validation.core.engine_scopes.delegate-counts-depth quote: 'depth = 0\n e = expr\n while isinstance(e, list) and e and e[0] == DELEGATE:\n depth += 1\n e = e[1]' validation.core.engine_scopes.proposal-binds-from-env quote: 'plain = Symbol(vname.lstrip("?"))\n if plain not in env:\n return []\n bindings[var] = env[plain]' validation.core.engine_scopes.proposal-evaluates-body quote: 'bound_body = substitute(body, bindings)\n return self._eval(\n bound_body, env, axiom_scope, restricted)' validation.core.engine_scopes.proposal-peels-delegate-nesting quote: 'while isinstance(e, list) and e and e[0] == DELEGATE:' validation.core.engine_scopes.proposal-returns-empty-on-mismatch quote: 'if not result:\n return []' validation.core.engine_scopes.scope-checks-self quote: 'if name == SELF:' validation.core.engine_scopes.scope-passes-name-to-callable quote: 'return scope_val(name, *resolved)' validation.core.engine_scopes.scope-resolves-name quote: 'scope_val = self._eval(name, env, axiom_scope, restricted)' validation.core.engine_scopes.self-evaluates-all-args quote: 'if head == SELF:\n # (self expr ...) — evaluate all args in the current engine\n result = None\n for arg in expr[1:]:\n result = self._eval(arg, env, axiom_scope, restricted)\n return result' validation.core.lazy_loader.catches-directive-errors quote: 'try:\n _execute_directive(system.engine, node.expr)\n executed.add(node.name)\n if self._result:\n self._result.loaded.add(node)\n return True\n except Exception as e:\n self._failed_names[node.name] = node' validation.core.lazy_loader.catches-effect-errors quote: 'for expr, ord_idx, line in pre_effects:\n try:\n _execute_directive(system.engine, expr)\n except Exception as e:' validation.core.lazy_loader.catches-parse-errors quote: 'try:\n pre_len = len(tokens)\n expr = read_tokens(tokens)' quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None,\n expr=[],\n dep_names=set(),\n kind="error",\n source_file=self._current.current_file,\n source_order=order,\n source_line=expr_line,\n )' validation.core.lazy_loader.has-line-tracking quote: 'tokens, token_lines = tokenize(source, track_lines=True)' validation.core.lazy_loader.parse-errors-dont-crash quote: 'except SyntaxError as e:\n err_node = DirectiveNode(\n name=None, expr=[], dep_names=set(),\n kind="error"' validation.core.lazy_loader.phase-1a-parses-all quote: "# Phase 1a: Parse all expressions, namespace definition names,\n # but DON'T patch body symbols yet (engine is empty)." validation.core.lazy_loader.phase-1c-patches-from-names quote: '# Phase 1c: Now patch body symbols using collected names + aliases,\n # then build DirectiveNodes.' validation.core.lazy_loader.phase-4-topological-exec quote: '# Phase 4: Topological execution of named directives' validation.core.loader.context-resolves-via-registry quote: 'module = self.names_to_modules.get(key_str)' quote: 'if module is not None:' quote: 'ctx = self.modules_contexts[module]' validation.core.loader.effect-behavior-expected quote: 'def print_effect' quote: 'if prop == ":file":' quote: 'if not self._current.is_main:' quote: 'if abs_path in self._file_stack:' quote: 'if abs_path in self._imported:' quote: 'resolved = os.path.normpath' validation.core.loader.effect-import-deduplicates quote: 'if abs_path in self._imported:' quote: 'return True' validation.core.loader.effect-verify-manual-doc quote: 'Effect: (verify-manual name) — manually verify a fact/term/axiom.' validation.core.loader.import-deduplication quote: 'if abs_path in self._imported:' quote: 'log.debug("Module \'%s\' already imported, skipping", module_name)' quote: 'return True' validation.core.loader.import-resolves-dots-to-sep quote: 'module_name.replace(".", os.sep) + ".pltg"' validation.core.loader.loader-namespaces-definitions quote: 'Namespace definition names for non-main modules' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' validation.core.loader.loader-patches-context quote: 'Recursively patch (context :key)' quote: 'patched = f"{self._current.module_name}.{expr[1]}"' validation.core.loader.loader-patches-symbols quote: 'Recursively namespace bare symbols in expression bodies.' quote: 'candidate = f"{self._current.module_name}.{s}"' validation.core.loader.namespacing-only-non-main quote: 'if head in DSL_KEYWORDS or head in SPECIAL_FORMS:' quote: 'if not self._current.is_main:' quote: 'expr[1] = f"{self._current.module_name}.{expr[1]}"' validation.core.system.constructor-params-impl-count quote: 'Composes Engine with default operators' quote: 'overridable: bool = False' quote: 'strict_derive: bool = True' quote: 'effects: dict[str, Callable] | None = None' quote: 'initial_env: dict | None = None' quote: 'docs: dict | None = None' validation.core.system.effects-impl-count quote: 'self.engine.env[Symbol(name)] = lambda *args, _fn=fn: _fn(self, *args)' quote: 'def load_source(system: System, source: str):' validation.core.system.load-source-is-module-fn quote: 'def load_source(system: System, source: str):' validation.core.system.system-docstring quote: 'Composes Engine with default operators, serialization, and introspection.' No evidence provided: core.ast_verifier.stub-source-line-field (origin: TODO: DirectiveNode gained source_line: int = 0 field — quote ast.py and add paired diff) core.atoms.stub-evidence-document-field (origin: TODO: Evidence.document: str — name of registered source document to verify quotes against) core.atoms.stub-evidence-verification-field (origin: TODO: Evidence.verification: list — filled by verifier, list of result dicts with keys: verified, quote, reason, confidence) core.atoms.stub-evidence-verification-result-schema (origin: TODO: Each verification result is a dict with 'verified' (bool), 'quote' (str), 'reason' (str), 'confidence' (dict with 'score', 'level')) core.atoms.stub-track-lines (origin: TODO: tokenize() gained track_lines=True param — returns (tokens, token_lines) tuple for source line tracking) core.domain.manual-control-implies-human (origin: manual verification capability implies human-in-the-loop workflow) core.domain.set-implies-fast (origin: set-based indexing implies fast intersection and lookup) core.engine.stub-delegate-handler (origin: TODO: DELEGATE handler — counts nesting depth, picks from :bind proposal stack) core.engine.stub-delegate-proposal (origin: TODO: _delegate_proposal — peels delegate nesting, binds ?-vars from env + ?_level, evaluates conditional pattern then body) core.engine.stub-project-handler (origin: TODO: PROJECT handler — evaluates in current engine (1 arg) or named basis (2 args)) core.engine.stub-rp (origin: TODO: _rp — project resolution walk inside SCOPE, eagerly evaluates project, posts delegate proposals to :bind stack) core.engine.stub-scope-handler (origin: TODO: SCOPE handler — dispatches to callable or self, resolves project/delegate in args via _rp) core.engine.stub-self-handler (origin: TODO: SELF handler — evaluates all args in current engine (identity scope)) core.engine.stub-suppress-log (origin: TODO: consistency() gained suppress_log: bool = True param — silences log.warning output by default) core.engine_scopes.count-exists (origin: import) core.engine_scopes.stub-scope-error-message (origin: TODO: scope target not callable error message) core.inspect_main.inspect_bench.stub (origin: import) core.inspect_main.inspect_evaluate.stub (origin: import) core.inspect_main.inspect_hologram.stub (origin: import) core.inspect_main.inspect_lens.stub (origin: import) core.inspect_main.inspect_search.stub (origin: import) core.inspect_main.stub (origin: import) core.integrity.count-exists (origin: import) core.integrity.stub (origin: import) core.lang.stub-delegate-lang-docs (origin: TODO: DELEGATE LANG_DOCS entry — :bind stack semantics, ?_level, conditional patterns) core.lang.stub-project-lang-docs (origin: TODO: PROJECT LANG_DOCS entry — evaluate in current or named basis) core.lang.stub-scope-lang-docs (origin: TODO: SCOPE LANG_DOCS entry — dispatches to callable, project resolved eagerly) core.lang.stub-self-lang-docs (origin: TODO: SELF LANG_DOCS entry — identity scope, evaluates in current engine) core.loader.stub-pltg-error (origin: TODO: PltgError exception class added — wraps errors with file:line and import stack trace) core.quote_verifier.stub-original-line (origin: TODO: original_line added to verification result dict — 1-based line number computed from char offset) core.readme.evidence-computes (origin: negation: evidence doesn't compute → false) core.readme.readme-documents-consistency-test-plan (origin: README does not yet document test_parseltongue_core_consistency.py pytest integration for CI) core.readme.readme-documents-core-pltg-plan (origin: README does not yet document core.pltg as top-level orchestrator importing all validation modules) core.readme.readme-documents-introspection-and-self-consistency-plan (origin: README does not yet have an Introspection and Self-Consistency section (provenance walking, state(), self-validation via .pltg modules, the ouroboros)) core.readme.readme-documents-per-module-validators-plan (origin: README does not yet document per-module .pltg verifiers (atoms, lang, engine, system, loader, etc.)) core.readme.readme-documents-self-test-goedel-plan (origin: README does not yet document Gödel incompleteness derive (system cannot prove own consistency)) core.readme.readme-documents-self-test-plan (origin: README does not yet document self_test.pltg (self-referential incompleteness proof)) core.readme.readme-documents-self-test-pytest-plan (origin: README does not yet document system running its own test suite via dangerously-eval) core.readme.readme-documents-self-test-turing-plan (origin: README does not yet document Turing ordinal extension exemplified via axiom→theorem hierarchy) core.readme.readme-documents-validation-framework-plan (origin: README does not yet document the .pltg self-validation system) core.readme.readme-needs-consistency-badge-plan (origin: README should display a self-consistency CI badge from GitLab workflow showing core validation pass/fail status) core.stub (origin: import) core.stub-brief-vs-detailed (origin: TODO: fmt_dsl(brief=True) truncates quotes in structure view; fmt_origin_rows(detailed=True) shows QV line + confidence in detail view) core.stub-inspect-loaded (origin: TODO: inspect_loaded(term, loader) — convenience combining probe + Lens with MDebuggerPerspective) core.stub-lens-api (origin: TODO: Lens class — view, view_layer, view_consumer, view_node, view_inputs, view_subgraph, view_kinds, view_roots, focus) core.stub-mdebugger-perspective (origin: TODO: MDebuggerPerspective takes LazyLoader, annotates output with file:line from AST, uses os.path.relpath) core.stub-perspective-instances (origin: TODO: Perspective instances (not types) — MarkdownPerspective, AsciiPerspective, MDebuggerPerspective) core.stub-probe-structure (origin: TODO: probe(term, engine) → CoreToConsequenceStructure — graph, layers, depths, max_depth) counting.count-exists (origin: variadic existence counter) counting.count-exists-base (origin: base: single argument) counting.count-exists-step (origin: step: peel first, count rest) counting.sum-values (origin: variadic numeric sum) counting.sum-values-base (origin: base: single value) counting.sum-values-step (origin: step: peel first, sum rest) counting.util.export (origin: export command via rewrites) counting.util.export-base (origin: rewrite: identity export — marks a value as intentionally dangling for cross-module use) counting.util.stub (origin: stub) counting.util.stub-base (origin: Stubs allow to make things which don't match anything) epistemics.collapse (origin: collapse a superposed status via observation into a definite status) epistemics.collapse-hypothesised (origin: hypothesised observation collapses superpose to unknown) epistemics.collapse-refuted (origin: refuted observation collapses superpose to hallucinated) epistemics.collapse-witnessed (origin: witnessed observation collapses superpose to exemplifiable) epistemics.count-hallucinated (origin: variadic count of hallucinated statuses) epistemics.count-hallucinated-base (origin: base: single status) epistemics.count-hallucinated-step (origin: step: peel first, count rest) epistemics.exemplifiable (origin: system found a witness — claim is observably grounded) epistemics.hallucinated (origin: system found evidence of failure — claim is demonstrably ungrounded) epistemics.hypothesised (origin: observation: claim proposed but system cannot check either way) epistemics.joint-status (origin: epistemic status of a group — hallucination is contagious) epistemics.joint-status-base (origin: base: single status passes through) epistemics.joint-status-step (origin: step: merge first two, recurse — hallucinated > unknown > exemplifiable) epistemics.joint-superposed (origin: bundle values into a single superposed observation) epistemics.joint-superposed-rewrite (origin: rewrite: joint-superposed wraps all args in strict and superposes them) epistemics.refuted (origin: observation: system found counter-evidence against the claim) epistemics.russell-teapot (origin: Russell's teapot: unwitnessable claims are hallucinated) epistemics.superpose (origin: indeterminate value — one of the listed possibilities) epistemics.unknown (origin: system cannot determine — neither exemplifiable nor provably hallucinated) epistemics.witness (origin: epistemic status labeling — witness a claim's classification) epistemics.witness-base (origin: rewrite: (witness status) returns the status — labels a claim as witnessed) epistemics.witnessed (origin: observation: system found a witness for the claim) lang.count-exists (origin: import) lang.stub-delegate-lang-docs (origin: TODO: DELEGATE LANG_DOCS entry — :bind stack semantics, ?_level, conditional patterns) lang.stub-project-lang-docs (origin: TODO: PROJECT LANG_DOCS entry — evaluate in current or named basis) lang.stub-scope-lang-docs (origin: TODO: SCOPE LANG_DOCS entry — dispatches to callable, project resolved eagerly) lang.stub-self-lang-docs (origin: TODO: SELF LANG_DOCS entry — identity scope, evaluates in current engine) lists.bare-filter (origin: TODO: filter on bare arglist without explicit quote pairs — needs lazy eval) lists.classify (origin: TODO: group items by status using filter — needs lazy eval) lists.concat (origin: variadic list concatenation via double splat) lists.concat-base (origin: base: single list passes through) lists.concat-step (origin: step: merge first two, recurse — needs unquote axiom in :using for 3+ lists) lists.concat-two (origin: two lists: merge via double splat) lists.cons (origin: variadic list constructor — evaluated args to quoted list) lists.cons-base (origin: base: single element to singleton quoted list) lists.cons-prepend (origin: binary prepend — splice element into quoted list head) lists.cons-prepend-rule (origin: rewrite: prepend ?x to list contents) lists.cons-step (origin: step: peel first, recurse tail, prepend via cons-prepend) lists.filter (origin: filter name-value pairs by target match — collect matching names) lists.filter-base (origin: base: single pair — include name if value matches target) lists.filter-step (origin: step: peel pair, include or skip, recurse on rest) lists.fold (origin: left fold — reduce list with binary axiom-function) lists.fold-empty (origin: base: empty list returns accumulator) lists.fold-step (origin: step: apply f to acc and head, recurse on tail) lists.length (origin: count elements via structural recursion) lists.length-base (origin: base: singleton list has length 1) lists.length-step (origin: step: 1 + length of tail) lists.map (origin: apply axiom-function to each element — ?-var head dispatch) lists.map-base (origin: base: singleton — apply and wrap in quoted list) lists.map-step (origin: step: apply to head, prepend to mapped tail) lists.nth (origin: element at index via decrement) lists.nth-base (origin: base: index 0 returns head) lists.nth-step (origin: step: decrement index, recurse on tail) lists.reverse (origin: reverse a list via accumulator) lists.reverse-acc (origin: reverse accumulator helper) lists.reverse-acc-base (origin: base: input exhausted, return accumulator) lists.reverse-acc-step (origin: step: move head to accumulator front) lists.reverse-rule (origin: init: start with empty accumulator) lists.unquote.unquote (origin: rewrite: strip quote wrapper — exposes bare list to splat patterns) lists.uq-concat (origin: concat + unquote bundle — include in :using for variadic list concatenation) unquote.unquote (origin: rewrite: strip quote wrapper — exposes bare list to splat patterns) util.export (origin: export command via rewrites) util.export-base (origin: rewrite: identity export — marks a value as intentionally dangling for cross-module use) util.stub (origin: stub) util.stub-base (origin: Stubs allow to make things which don't match anything) validation.core.ast_verifier.stub-source-line-field (origin: TODO: DirectiveNode gained source_line: int = 0 field — quote ast.py and add paired diff) validation.core.atoms.stub-evidence-document-field (origin: TODO: Evidence.document: str — name of registered source document to verify quotes against) validation.core.atoms.stub-evidence-verification-field (origin: TODO: Evidence.verification: list — filled by verifier, list of result dicts with keys: verified, quote, reason, confidence) validation.core.atoms.stub-evidence-verification-result-schema (origin: TODO: Each verification result is a dict with 'verified' (bool), 'quote' (str), 'reason' (str), 'confidence' (dict with 'score', 'level')) validation.core.atoms.stub-track-lines (origin: TODO: tokenize() gained track_lines=True param — returns (tokens, token_lines) tuple for source line tracking) validation.core.domain.manual-control-implies-human (origin: manual verification capability implies human-in-the-loop workflow) validation.core.domain.set-implies-fast (origin: set-based indexing implies fast intersection and lookup) validation.core.engine.stub-delegate-handler (origin: TODO: DELEGATE handler — counts nesting depth, picks from :bind proposal stack) validation.core.engine.stub-delegate-proposal (origin: TODO: _delegate_proposal — peels delegate nesting, binds ?-vars from env + ?_level, evaluates conditional pattern then body) validation.core.engine.stub-project-handler (origin: TODO: PROJECT handler — evaluates in current engine (1 arg) or named basis (2 args)) validation.core.engine.stub-rp (origin: TODO: _rp — project resolution walk inside SCOPE, eagerly evaluates project, posts delegate proposals to :bind stack) validation.core.engine.stub-scope-handler (origin: TODO: SCOPE handler — dispatches to callable or self, resolves project/delegate in args via _rp) validation.core.engine.stub-self-handler (origin: TODO: SELF handler — evaluates all args in current engine (identity scope)) validation.core.engine.stub-suppress-log (origin: TODO: consistency() gained suppress_log: bool = True param — silences log.warning output by default) validation.core.engine_scopes.count-exists (origin: import) validation.core.engine_scopes.stub-scope-error-message (origin: TODO: scope target not callable error message) validation.core.inspect_main.inspect_bench.stub (origin: import) validation.core.inspect_main.inspect_evaluate.stub (origin: import) validation.core.inspect_main.inspect_hologram.stub (origin: import) validation.core.inspect_main.inspect_lens.stub (origin: import) validation.core.inspect_main.inspect_search.stub (origin: import) validation.core.inspect_main.stub (origin: import) validation.core.integrity.count-exists (origin: import) validation.core.integrity.stub (origin: import) validation.core.lang.stub-delegate-lang-docs (origin: TODO: DELEGATE LANG_DOCS entry — :bind stack semantics, ?_level, conditional patterns) validation.core.lang.stub-project-lang-docs (origin: TODO: PROJECT LANG_DOCS entry — evaluate in current or named basis) validation.core.lang.stub-scope-lang-docs (origin: TODO: SCOPE LANG_DOCS entry — dispatches to callable, project resolved eagerly) validation.core.lang.stub-self-lang-docs (origin: TODO: SELF LANG_DOCS entry — identity scope, evaluates in current engine) validation.core.loader.stub-pltg-error (origin: TODO: PltgError exception class added — wraps errors with file:line and import stack trace) validation.core.quote_verifier.stub-original-line (origin: TODO: original_line added to verification result dict — 1-based line number computed from char offset) validation.core.readme.evidence-computes (origin: negation: evidence doesn't compute → false) validation.core.readme.readme-documents-consistency-test-plan (origin: README does not yet document test_parseltongue_core_consistency.py pytest integration for CI) validation.core.readme.readme-documents-core-pltg-plan (origin: README does not yet document core.pltg as top-level orchestrator importing all validation modules) validation.core.readme.readme-documents-introspection-and-self-consistency-plan (origin: README does not yet have an Introspection and Self-Consistency section (provenance walking, state(), self-validation via .pltg modules, the ouroboros)) validation.core.readme.readme-documents-per-module-validators-plan (origin: README does not yet document per-module .pltg verifiers (atoms, lang, engine, system, loader, etc.)) validation.core.readme.readme-documents-self-test-goedel-plan (origin: README does not yet document Gödel incompleteness derive (system cannot prove own consistency)) validation.core.readme.readme-documents-self-test-plan (origin: README does not yet document self_test.pltg (self-referential incompleteness proof)) validation.core.readme.readme-documents-self-test-pytest-plan (origin: README does not yet document system running its own test suite via dangerously-eval) validation.core.readme.readme-documents-self-test-turing-plan (origin: README does not yet document Turing ordinal extension exemplified via axiom→theorem hierarchy) validation.core.readme.readme-documents-validation-framework-plan (origin: README does not yet document the .pltg self-validation system) validation.core.readme.readme-needs-consistency-badge-plan (origin: README should display a self-consistency CI badge from GitLab workflow showing core validation pass/fail status) validation.core.stub (origin: import) validation.core.stub-brief-vs-detailed (origin: TODO: fmt_dsl(brief=True) truncates quotes in structure view; fmt_origin_rows(detailed=True) shows QV line + confidence in detail view) validation.core.stub-inspect-loaded (origin: TODO: inspect_loaded(term, loader) — convenience combining probe + Lens with MDebuggerPerspective) validation.core.stub-lens-api (origin: TODO: Lens class — view, view_layer, view_consumer, view_node, view_inputs, view_subgraph, view_kinds, view_roots, focus) validation.core.stub-mdebugger-perspective (origin: TODO: MDebuggerPerspective takes LazyLoader, annotates output with file:line from AST, uses os.path.relpath) validation.core.stub-perspective-instances (origin: TODO: Perspective instances (not types) — MarkdownPerspective, AsciiPerspective, MDebuggerPerspective) validation.core.stub-probe-structure (origin: TODO: probe(term, engine) → CoreToConsequenceStructure — graph, layers, depths, max_depth) Potential fabrication: core.ast_verifier.api-paired core.ast_verifier.bound-effects-no-name core.ast_verifier.dep-extraction-count core.ast_verifier.doc-carries-count core.ast_verifier.extract-behavior-count core.ast_verifier.kind-comment-count core.ast_verifier.kind-count core.ast_verifier.node-field-count core.atoms.atom-conv-doc-count core.atoms.bool-false-roundtrip core.atoms.bool-roundtrip-consistent core.atoms.bool-true-roundtrip core.atoms.dsl-helpers-doc-count core.atoms.export-core-types-confirmed core.atoms.export-match-substitute core.atoms.export-parser-stages-count core.atoms.export-splat-confirmed core.atoms.export-substitute-splat core.atoms.export-to-sexp core.atoms.impl-axiom-wff core.atoms.impl-term-computed core.atoms.impl-theorem-wff core.atoms.module-is-stateless core.atoms.module-purity-contract core.atoms.parser-stages-count core.atoms.purity-immutable-bound core.atoms.reader-doc-count core.atoms.splat-doc-count core.atoms.splat-impl-count core.atoms.splat-paired-count core.atoms.term-display-bound core.atoms.term-display-doc-count core.atoms.term-display-full-doc-count core.atoms.to-sexp-exists core.atoms.wff-impl-count core.atoms.wff-paired-count core.demos.apples-features-doc-count core.demos.demo-total-count core.demos.entry-mocks-features-doc-count core.demos.export-extensibility-topic core.demos.export-self-healing-topic core.demos.extensibility-exists core.demos.extensibility-features-doc-count core.demos.pltg-loader-bootstrap-confirmed core.demos.revenue-features-doc-count core.demos.run-on-entry-gating-proven core.demos.self-healing-exists core.demos.self-healing-features-doc-count core.engine.bound-diff-no-evidence core.engine.eval-mechanism-doc-count core.engine.export-diffs-cross-validation core.engine.export-diffs-no-evidence core.engine.export-rewrite-as-functions core.engine.export-three-layers core.engine_scopes.delegate-property-count core.engine_scopes.export-delegate-property-count core.engine_scopes.export-proposal-step-count core.engine_scopes.export-scope-handler-count core.engine_scopes.proposal-step-count core.engine_scopes.scope-handler-count core.engine_scopes.scope-handler-feature-count core.lazy_loader.cascade-produces-skipped core.lazy_loader.export-fault-tolerant core.lazy_loader.export-line-tracking core.lazy_loader.fault-tolerance-count core.lazy_loader.name-collection-enables-patching core.lazy_loader.parse-errors-produce-result core.lazy_loader.phase-count core.lazy_loader.phase-paired core.loader.all-axioms-backed-count core.loader.bound-context-resolves core.loader.bound-import-dedup core.loader.bound-namespacing-only-non-main core.loader.effect-behavior-count core.loader.effect-doc-count core.loader.effect-paired-count core.loader.entry-points-doc-count core.loader.entry-points-impl-count core.loader.export-dot-resolution core.loader.export-import-deduplicates core.loader.export-namespaces core.loader.export-patches-context core.loader.export-patches-symbols core.loader.import-dedup-mechanism core.loader.namespacing-impl-count core.loader.namespacing-stage-count core.loader.safety-axiom-count core.loader.safety-mechanism-count core.namespacing-three-stages-confirmed core.readme-loader-consistent core.splat-impl-confirmed core.system.constructor-params-doc-count core.system.docstring-confirms-composition core.system.effects-doc-count core.system.export-docstring core.system.export-load-source derivation-theorem-count engine-fact-count validation.core.ast_verifier.api-paired validation.core.ast_verifier.bound-effects-no-name validation.core.ast_verifier.dep-extraction-count validation.core.ast_verifier.doc-carries-count validation.core.ast_verifier.extract-behavior-count validation.core.ast_verifier.kind-comment-count validation.core.ast_verifier.kind-count validation.core.ast_verifier.node-field-count validation.core.atoms.atom-conv-doc-count validation.core.atoms.bool-false-roundtrip validation.core.atoms.bool-roundtrip-consistent validation.core.atoms.bool-true-roundtrip validation.core.atoms.dsl-helpers-doc-count validation.core.atoms.export-core-types-confirmed validation.core.atoms.export-match-substitute validation.core.atoms.export-parser-stages-count validation.core.atoms.export-splat-confirmed validation.core.atoms.export-substitute-splat validation.core.atoms.export-to-sexp validation.core.atoms.impl-axiom-wff validation.core.atoms.impl-term-computed validation.core.atoms.impl-theorem-wff validation.core.atoms.module-is-stateless validation.core.atoms.module-purity-contract validation.core.atoms.parser-stages-count validation.core.atoms.purity-immutable-bound validation.core.atoms.reader-doc-count validation.core.atoms.splat-doc-count validation.core.atoms.splat-impl-count validation.core.atoms.splat-paired-count validation.core.atoms.term-display-bound validation.core.atoms.term-display-doc-count validation.core.atoms.term-display-full-doc-count validation.core.atoms.to-sexp-exists validation.core.atoms.wff-impl-count validation.core.atoms.wff-paired-count validation.core.demos.apples-features-doc-count validation.core.demos.demo-total-count validation.core.demos.entry-mocks-features-doc-count validation.core.demos.export-extensibility-topic validation.core.demos.export-self-healing-topic validation.core.demos.extensibility-exists validation.core.demos.extensibility-features-doc-count validation.core.demos.pltg-loader-bootstrap-confirmed validation.core.demos.revenue-features-doc-count validation.core.demos.run-on-entry-gating-proven validation.core.demos.self-healing-exists validation.core.demos.self-healing-features-doc-count validation.core.engine.bound-diff-no-evidence validation.core.engine.eval-mechanism-doc-count validation.core.engine.export-diffs-cross-validation validation.core.engine.export-diffs-no-evidence validation.core.engine.export-rewrite-as-functions validation.core.engine.export-three-layers validation.core.engine_scopes.delegate-property-count validation.core.engine_scopes.export-delegate-property-count validation.core.engine_scopes.export-proposal-step-count validation.core.engine_scopes.export-scope-handler-count validation.core.engine_scopes.proposal-step-count validation.core.engine_scopes.scope-handler-count validation.core.engine_scopes.scope-handler-feature-count validation.core.lazy_loader.cascade-produces-skipped validation.core.lazy_loader.export-fault-tolerant validation.core.lazy_loader.export-line-tracking validation.core.lazy_loader.fault-tolerance-count validation.core.lazy_loader.name-collection-enables-patching validation.core.lazy_loader.parse-errors-produce-result validation.core.lazy_loader.phase-count validation.core.lazy_loader.phase-paired validation.core.loader.all-axioms-backed-count validation.core.loader.bound-context-resolves validation.core.loader.bound-import-dedup validation.core.loader.bound-namespacing-only-non-main validation.core.loader.effect-behavior-count validation.core.loader.effect-doc-count validation.core.loader.effect-paired-count validation.core.loader.entry-points-doc-count validation.core.loader.entry-points-impl-count validation.core.loader.export-dot-resolution validation.core.loader.export-import-deduplicates validation.core.loader.export-namespaces validation.core.loader.export-patches-context validation.core.loader.export-patches-symbols validation.core.loader.import-dedup-mechanism validation.core.loader.namespacing-impl-count validation.core.loader.namespacing-stage-count validation.core.loader.safety-axiom-count validation.core.loader.safety-mechanism-count validation.core.namespacing-three-stages-confirmed validation.core.readme-loader-consistent validation.core.splat-impl-confirmed validation.core.system.constructor-params-doc-count validation.core.system.docstring-confirms-composition validation.core.system.effects-doc-count validation.core.system.export-docstring validation.core.system.export-load-source Diff value divergence: validation.core.ee-computable-directives: validation.core.readme.export-computable-directive-count (5) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.ee-dependents-scan-paired: validation.core.readme.export-diff-scan-paired (5) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.ee-diff-scans-five: validation.core.readme.readme-diff-scans-five-types (True) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.ee-evidence-excluded: validation.core.readme.bound-evidence-excludes-computation (True) vs validation.core.stub (std.counting.util.stub) — values differ validation.core.lang.special-forms-coverage: validation.core.lang.special-forms-doc-count (5) vs validation.core.lang.special-forms-impl-count (9) — values differ validation.core.thm-ast-effects-no-name: validation.core.ast_verifier.bound-effects-no-name (True) vs validation.core.stub-ast-effects-no-name (std.counting.util.stub) — values differ validation.core.thm-ast-extract-behavior: validation.core.ast_verifier.extract-behavior-count (2) vs validation.core.stub-ast-extract-behavior (std.counting.util.stub) — values differ validation.core.thm-ast-graph-behavior: validation.core.ast_verifier.graph-behavior-count (4) vs validation.core.stub-ast-graph-behavior (std.counting.util.stub) — values differ validation.core.thm-ast-identity-paired: validation.core.ast_verifier.identity-paired (1) vs validation.core.stub-ast-identity-paired (std.counting.util.stub) — values differ validation.core.thm-ast-node-identity: validation.core.ast_verifier.node-identity-paired (1) vs validation.core.stub-ast-node-identity (std.counting.util.stub) — values differ validation.core.thm-ast-walk-behavior: validation.core.ast_verifier.walk-behavior-count (2) vs validation.core.stub-ast-walk-behavior (std.counting.util.stub) — values differ validation.core.thm-lazy-effect-rank: validation.core.lazy_loader.export-effect-rank (True) vs validation.core.stub-lazy-effect-rank (std.counting.util.stub) — values differ validation.core.thm-lazy-entry-points: validation.core.lazy_loader.entry-point-count (3) vs validation.core.stub-lazy-entry-points (std.counting.util.stub) — values differ validation.core.thm-lazy-fault-tolerance: validation.core.lazy_loader.fault-tolerance-count (6) vs validation.core.stub-lazy-fault-tolerance (std.counting.util.stub) — values differ validation.core.thm-lazy-line-tracking: validation.core.lazy_loader.export-line-tracking (True) vs validation.core.stub-lazy-line-tracking (std.counting.util.stub) — values differ validation.core.thm-lazy-patch-paired: validation.core.lazy_loader.patch-paired (2) vs validation.core.stub-lazy-patch-paired (std.counting.util.stub) — values differ validation.core.thm-lazy-post-effects: validation.core.lazy_loader.export-post-directive-effects (True) vs validation.core.stub-lazy-post-effects (std.counting.util.stub) — values differ validation.core.thm-lazy-pre-effects: validation.core.lazy_loader.export-pre-directive-effects (True) vs validation.core.stub-lazy-pre-effects (std.counting.util.stub) — values differ validation.core.thm-readme-special-forms: validation.core.readme.export-special-forms-count (4) vs validation.core.lang.special-forms-tuple-size (8) — values differ [warning] Manually verified: c.count-exists, c.count-exists-base, c.count-exists-step, c.sum-values, c.sum-values-base, c.sum-values-step, c.util.export, c.util.export-base, c.util.stub, c.util.stub-base, core.ast_verifier.count-exists, core.atoms.count-exists, core.count-exists, core.default_system_settings.count-exists, core.demos.count-exists, core.engine.count-exists, core.lang.count-exists, core.lazy_loader.count-exists, core.loader.count-exists, core.pyproject.count-exists, core.quote_verifier.count-exists, core.quote_verifier.empty-has-no-content, core.quote_verifier.empty-verified-result, core.quote_verifier.no-transformations, core.quote_verifier.normalized-empty-verified, core.quote_verifier.normalized-has-content, core.quote_verifier.quote-has-content, core.quote_verifier.regular-is-not-dangerous, core.quote_verifier.regular-single-count, core.quote_verifier.regular-word-count, core.quote_verifier.remove-stopwords-enabled, core.quote_verifier.score-after-single-dangerous, core.quote_verifier.single-stopword-verified, core.quote_verifier.single-word-is-single, core.quote_verifier.single-word-is-stopword, core.quote_verifier.sum-values, core.readme.axiom-status, core.readme.count-exists, core.system.count-exists, std.counting.count-exists, std.counting.count-exists-base, std.counting.count-exists-step, std.counting.sum-values, std.counting.sum-values-base, std.counting.sum-values-step, std.counting.util.export, std.counting.util.export-base, std.counting.util.stub, std.counting.util.stub-base, std.epistemics.collapse, std.epistemics.collapse-hypothesised, std.epistemics.collapse-refuted, std.epistemics.collapse-witnessed, std.epistemics.count-hallucinated, std.epistemics.count-hallucinated-base, std.epistemics.count-hallucinated-step, std.epistemics.exemplifiable, std.epistemics.hallucinated, std.epistemics.hypothesised, std.epistemics.joint-status, std.epistemics.joint-status-base, std.epistemics.joint-status-step, std.epistemics.joint-superposed, std.epistemics.joint-superposed-rewrite, std.epistemics.refuted, std.epistemics.russell-teapot, std.epistemics.superpose, std.epistemics.unknown, std.epistemics.witness, std.epistemics.witness-base, std.epistemics.witnessed, std.lists.bare-filter, std.lists.classify, std.lists.concat, std.lists.concat-base, std.lists.concat-step, std.lists.concat-two, std.lists.cons, std.lists.cons-base, std.lists.cons-prepend, std.lists.cons-prepend-rule, std.lists.cons-step, std.lists.filter, std.lists.filter-base, std.lists.filter-step, std.lists.fold, std.lists.fold-empty, std.lists.fold-step, std.lists.length, std.lists.length-base, std.lists.length-step, std.lists.map, std.lists.map-base, std.lists.map-step, std.lists.nth, std.lists.nth-base, std.lists.nth-step, std.lists.reverse, std.lists.reverse-acc, std.lists.reverse-acc-base, std.lists.reverse-acc-step, std.lists.reverse-rule, std.lists.unquote.unquote, std.lists.uq-concat, std.std.higher_order.apply, std.std.higher_order.apply-1, std.std.higher_order.apply-2, std.std.higher_order.apply-3, std.std.higher_order.compose, std.std.higher_order.compose-rule, std.std.higher_order.pipe, std.std.higher_order.pipe-base, std.std.higher_order.pipe-step, std.std.predicates.all, std.std.predicates.all-base, std.std.predicates.all-step, std.std.predicates.any-true, std.std.predicates.any-true-base, std.std.predicates.any-true-step, std.std.predicates.member, std.std.predicates.member-base, std.std.predicates.member-step, std.std.predicates.none, std.std.predicates.none-rule, std.util.export, std.util.export-base, std.util.stub, std.util.stub-base, validation.core.ast_verifier.count-exists, validation.core.atoms.count-exists, validation.core.count-exists, validation.core.default_system_settings.count-exists, validation.core.demos.count-exists, validation.core.engine.count-exists, validation.core.lang.count-exists, validation.core.lazy_loader.count-exists, validation.core.loader.count-exists, validation.core.pyproject.count-exists, validation.core.quote_verifier.count-exists, validation.core.quote_verifier.empty-has-no-content, validation.core.quote_verifier.empty-verified-result, validation.core.quote_verifier.no-transformations, validation.core.quote_verifier.normalized-empty-verified, validation.core.quote_verifier.normalized-has-content, validation.core.quote_verifier.quote-has-content, validation.core.quote_verifier.regular-is-not-dangerous, validation.core.quote_verifier.regular-single-count, validation.core.quote_verifier.regular-word-count, validation.core.quote_verifier.remove-stopwords-enabled, validation.core.quote_verifier.score-after-single-dangerous, validation.core.quote_verifier.single-stopword-verified, validation.core.quote_verifier.single-word-is-single, validation.core.quote_verifier.single-word-is-stopword, validation.core.quote_verifier.sum-values, validation.core.readme.axiom-status, validation.core.readme.count-exists, validation.core.system.count-exists [warning] diff_contamination: validation.core.ast_verifier.kind-vs-dep-extraction, validation.core.atoms.match-splat-pair, validation.core.atoms.substitute-splat-pair, validation.core.atoms.wff-paired-vs-doc, validation.core.atoms.wff-paired-vs-impl, validation.core.default_system_settings.arith-decl-vs-category, validation.core.default_system_settings.arith-decl-vs-docs, validation.core.default_system_settings.arith-docs-vs-category, validation.core.default_system_settings.arith-docs-vs-impl, validation.core.default_system_settings.arith-impl-vs-category, validation.core.default_system_settings.comp-decl-vs-category, validation.core.default_system_settings.comp-decl-vs-docs, validation.core.default_system_settings.comp-docs-vs-category, validation.core.default_system_settings.comp-docs-vs-impl, validation.core.default_system_settings.comp-impl-vs-category, validation.core.default_system_settings.decl-vs-docs-total, validation.core.default_system_settings.docs-vs-impl-total, validation.core.default_system_settings.logic-decl-vs-category, validation.core.default_system_settings.logic-decl-vs-docs, validation.core.default_system_settings.logic-docs-vs-category, validation.core.default_system_settings.logic-docs-vs-impl, validation.core.default_system_settings.logic-impl-vs-category, validation.core.default_system_settings.paired-vs-decl-total, validation.core.default_system_settings.paired-vs-docs-total, validation.core.default_system_settings.paired-vs-impl-total, validation.core.default_system_settings.paired-vs-total, validation.core.default_system_settings.total-decl-vs-total, validation.core.default_system_settings.total-docs-vs-total, validation.core.default_system_settings.total-impl-vs-total, validation.core.demo-count, validation.core.demos.apples-splats-all-gt-doc-vs-impl, validation.core.demos.apples-splats-count-gt-doc-vs-impl, validation.core.demos.apples-splats-doc-vs-impl, validation.core.demos.apples-splats-splat-pair, validation.core.demos.apples-splats-sum-all-doc-vs-impl, validation.core.demos.lazy-label-vs-reality, validation.core.demos.self-healing-doc-vs-impl, validation.core.demos.spec-divergence-doc-vs-impl, validation.core.demos.spec-expiry-doc-vs-impl, validation.core.demos.spec-md5-doc-vs-impl, validation.core.demos.spec-session-doc-vs-impl, validation.core.engine.consistency-layers-coverage, validation.core.engine.defaults-coverage, validation.core.engine.dependents-paired-vs-doc, validation.core.engine.dependents-paired-vs-impl, validation.core.engine.doc-mgmt-paired-vs-doc, validation.core.engine.doc-mgmt-paired-vs-impl, validation.core.engine.eval-diff-contamination-paired-vs-doc, validation.core.engine.eval-diff-contamination-paired-vs-impl, validation.core.engine.unknown-vs-warnings, validation.core.engine.warning-layers-consistent, validation.core.forward-decl, validation.core.lang.directive-vs-keyword-count, validation.core.lazy-count-match, validation.core.lazy_loader.phase-impl-vs-paired, validation.core.lazy_loader.result-doc-vs-impl, validation.core.loader.consistency-facts-vs-axioms, validation.core.loader.effect-doc-vs-impl, validation.core.loader.effect-doc-vs-total, validation.core.loader.effect-impl-vs-total, validation.core.loader.effect-paired-vs-doc, validation.core.loader.effect-paired-vs-impl, validation.core.loader.effect-paired-vs-total, validation.core.misc-evidence-first-class, validation.core.mod-lazy-result-errors, validation.core.mod-lazy-result-loaded, validation.core.mod-lazy-result-ok, validation.core.mod-lazy-result-partial, validation.core.mod-lazy-result-skipped, validation.core.quote_verifier.axiom-paired-vs-doc, validation.core.quote_verifier.axiom-paired-vs-impl, validation.core.quote_verifier.flag-paired-vs-config, validation.core.quote_verifier.flag-paired-vs-doc, validation.core.quote_verifier.flag-paired-vs-init, validation.core.quote_verifier.level-paired-vs-doc, validation.core.quote_verifier.level-paired-vs-enum, validation.core.quote_verifier.level-paired-vs-usage, validation.core.quote_verifier.match-paired-vs-doc, validation.core.quote_verifier.match-paired-vs-enum, validation.core.quote_verifier.match-paired-vs-usage, validation.core.quote_verifier.medium-vs-default-threshold, validation.core.quote_verifier.paired-vs-config, validation.core.quote_verifier.paired-vs-usage, validation.core.quote_verifier.penalty-config-vs-usage, validation.core.quote_verifier.result-paired-vs-api, validation.core.quote_verifier.result-paired-vs-doc, validation.core.quote_verifier.result-paired-vs-impl, validation.core.readme-vs-ast-kinds, validation.core.readme-vs-directive-node, validation.core.readme-vs-lazy-phases, validation.core.readme-vs-loader-effect-count, validation.core.readme-vs-qv-hypotheticals, validation.core.readme.readme-ast-fields-vs-stated, validation.core.readme.readme-demo-listing-vs-count, validation.core.readme.readme-demo-paired-vs-listing, validation.core.readme.readme-diff-scan-paired-vs-computable, validation.core.readme.readme-diff-scan-paired-vs-scan, validation.core.readme.readme-directive-listing-vs-stated, validation.core.readme.readme-issue-types-vs-stated, validation.core.readme.readme-lazy-phases-vs-stated, validation.core.readme.readme-manual-categories-vs-stated, validation.core.readme.readme-special-forms-vs-stated, validation.core.readme.readme-warning-types-vs-stated, validation.core.special-forms-count, validation.core.splat-readme-vs-demo, validation.core.splat-readme-vs-impl, validation.core.sys-retract, validation.core.sys-serialization, validation.core.thm-import-circular, validation.core.thm-readme-issue-types, validation.core.thm-readme-warning-types

We hope this was an interesting deep dive into how Parseltongue works. Please don't hesitate to write us if you have any questions — or would like to improve it.

[1]core.engine.hallucinated-is-error = true
[2]core.engine.unknown-is-warning = true
[3]core.readme.parseltongue-makes-axioms-exemplifiable = true
[4]core.engine.isomorphism-hallucinations-errors-unknowns-warnings = true
[5]core.thm-epistemics-cross-check = true = true
[6]core.engine.consistency-layer-1 = Evidence grounding
[7]core.engine.consistency-layer-2 = Fabrication propagation
[8]core.engine.bound-evidence-attachable = true
[9]core.engine.bound-derive-inherits = true
[10]core.engine.bound-diff-no-evidence = true
[11]derivation-theorem-count = 3
[12]core.engine.derivation-mechanism-coverage = 5 = 5
[13]core.engine.consistency-layer-3 = Diff agreement
[14]core.engine.dependents-scans-facts = true
[15]core.engine.dependents-scans-terms = true
[16]core.engine.dependents-scans-axioms = true
[17]core.engine.dependents-scans-theorems = true
[18]core.engine.dependents-scans-diffs = true
[19]core.engine.dependents-checks-derivation-list = true
[20]core.engine.dependents-is-transitive = true
[21]dependents-scan-count = 5
[22]core.engine.dependents-paired-vs-doc = 5 = 5
[23]core.engine.dependents-paired-vs-impl = 5 = 5
[24]core.engine.diff-evaluated-structurally = true
[25]core.engine.diff-mechanism-doc-count = 3
[26]core.engine.diff-mechanism-coverage = 3 = 3
[27]core.engine.consistency-layer-count = 3
[28]core.engine.consistency-layers-coverage = 3 = 3
[29]core.engine.consistency-states-total = 7
[30]core.engine.causes-error-count = 5
[31]core.engine.causes-warning-count = 2
[32]core.engine.manual-causes-warning = validation.core.engine.consistency-warning
[33]core.engine.contamination-all-are-diff-refs = true
[34]core.engine.contamination-is-empty = false
[35]core.engine.contamination-causes-warning = validation.core.engine.consistency-warning
[36]witness-count = 5
[37]core.engine.witness-evidence-hallucinated = std.epistemics.hallucinated
[38]core.engine.witness-no-evidence-hallucinated = std.epistemics.hallucinated
[39]core.engine.witness-fabrication-does-not-hold = std.epistemics.hallucinated
[40]core.engine.witness-fabrication-ungrounded-source = std.epistemics.hallucinated
[41]core.engine.witness-evidence-unknown = std.epistemics.unknown
[42]core.readme.evidence-is-departure = true
[43]core.readme.parseltongue-axiom-status = std.epistemics.exemplifiable
[44]core.thm-consistency-states-total = 7 = 7
[45]core.thm-engine-error-cross-check = 5 = 5
[46]core.thm-engine-warning-cross-check = 2 = 2
[47]core.thm-fabrication = true = true
[48]core.thm-fact-cites-quote = true = true
[49]core.thm-diffs-detect = true = true
[50]cross-module-count = 7
[51]core.engine.doc-mgmt-paired-count = 3
[52]core.engine.doc-mgmt-paired-vs-doc = 3 = 3
[53]core.engine.doc-mgmt-paired-vs-impl = 3 = 3
[54]engine-fact-count = 8
[55]core.engine.derive-doc = Derive a theorem from existing axioms/terms.
[56]core.engine.consistency-doc = Check full consistency state of the system.
[57]core.engine.axiom-requires-free-vars = true
Diagnostics606 errors · 268 warnings · 2334 info
error 606 ▸
warning 268 ▸
info 2334 ▸
System 2156 facts 373 terms 274 axioms 1393 theorems 3208 issues

?
Developed by sci2sci
Need to convert data and documents to knowledge safely at enterprise scale?
Try VectorCat!