This page computes the proof that silent inconsistency count equals zero. The numbers and statuses you see below are live — computed by the same engine that runs inside the product. Start by clicking on the main result 0 = 0 [1] to open it in the side panel, then use Focus in Graph to see the knowledge graph behind it, or Focus in Layers to see the full computation chain. You can also click Taints to see the inconsistencies we're currently aware of — mostly documentation that hasn't caught up with the code yet.
On our marketing page we declared that our system has zero silent inconsistencies. Since we're obliged to ensure that our marketing materials are not misleading, we are demonstrating it on this page.
Since the mathematical notion of consistency is quite narrow, and misleading claims are interpreted by any related law quite broadly, we will specify consistency in its naive view which is used in common, non-mathematical language.
Expectations of consumers when something is claimed to be consistent are, according to common usage of the word:
We think that this reasonably covers the sufficient criteria which most people would expect from consistent statements.
An important limitation: we cannot guarantee that the evidence actually supports the claim in 100% of cases. It is possible to state "2+2=5" with evidence reading "two plus two equals four" — the evidence exists and is attached, but does not support the claim. We address this via few separate mechanisms: independent fact extraction with additional validation, cross-checks between claims and the derivations made from them, and their results of interaction with facts and calculations derived from other sources. However, this specific issue is fundamentally tied to completeness — and completeness is something we cannot guarantee. There can exist a scenario where we haven't yet ingested the fact or cross-check into the system which would expose a future inconsistent state. What we can guarantee is that once such a fact is ingested, the inconsistency will be detected. We think this doesn't contradict our claim, since we didn't advertise our system as an oracle capable of predicting the future.
(import (quote .src.zero_silent zs))
zs.criteria-count
We define 5 [2] criteria above. We now will show that any statement in Integrity Cortex satisfies such criteria, via the following procedure:
The engine classifies every claim into one of three epistemic states — exemplifiable, hallucinated, or unknown — from the system's perspective, based on what the consistency checker can determine by itself. These three states form a lattice with a total order: hallucinated > unknown > exemplifiable. Russell's teapot closes the lattice: an unwitnessable claim is hallucinated, not merely unproven.
Our 5 [2] criteria correspond exactly to the states this lattice describes:
Correspondence maps to std.epistemics.exemplifiable. [3] A claim that corresponds to observable reality is one where the system found a witness — a verified quote in a source document, a passing derivation, a confirmed code path. This is what exemplifiable means: the system can point at the evidence.
Validity maps to std.epistemics.hallucinated [4] when violated. An invalid claim — conclusion doesn't follow from premises, or premises are false — is one where the system found evidence of failure. A derivation from unverified sources, a quote not in the document. Russell's teapot: the burden of proof is on the claimant, and it was not met.
Internal consistency maps to std.epistemics.hallucinated [5] when violated. A contradiction — two independent paths to the same value that disagree — is direct evidence of failure. The diff mechanism surfaces this.
Soundness maps to std.epistemics.hallucinated [6] when violated. An unsound claim — one that tricks by hiding or exaggerating — is a fabrication: the derivation chain leads to unverified ground. Taint propagation surfaces this transitively.
Limitations visible maps to std.epistemics.unknown. [7] When the system cannot verify a claim — because it requires human judgment, because verification would be self-referential, because a definition is consumed by nothing — it classifies the claim as unknown. The limitation IS the displayed status, not a hidden gap. The system acknowledges the claim but cannot witness it.
zs.mapped-criteria-count
5 [8] criteria are mapped to epistemic states.
The mapping above establishes *what* each criterion means in epistemic terms. But naming a state is not the same as detecting it. We now show that the engine actually detects each state — this is the engine's own proof, not ours.
The engine proves that hallucinated states produce errors[9]. This is not an assertion — it is a theorem derived from the engine's own source code, cross-checked four ways by the isomorphism. Every form of hallucination (unverified evidence, no evidence, fabrication, divergence, value mismatch) has a corresponding causes-error derivation.
The engine proves that unknown states produce warnings[10]. Every form of unknowability (manual verification, diff contamination) has a corresponding causes-warning derivation.
Exemplifiable states need no detector — they are the success case.
The isomorphism theorem[11] proves the final link: every error type has a detector, and every warning type has a detector. The classification is exhaustive. No error or warning type exists without a corresponding signal in the consistency checker.
The chain is complete: criteria → epistemic states → errors/warnings → detectors. The transfer axiom gates the 5 [8] mapped criteria through all three conditions. The proven detection count is 5. [12]
zs.silent-inconsistency-count
Silent inconsistency count: 5 [2] criteria − 5 [12] proven detections = 0. [13] The marketing claim is 0 [14][1].
We don't claim that there is no possible failure mode or reinterpretation which introduces additional criteria and is simultaneously consistent with the ones established by us.
We also don't claim that any opinion on the stated criteria is impossible, while we can claim that those opinions can fail our stated criteria, and since our criteria correspond to generally applicable naive views, those opinions can be from our classification perspective misleading.
Speaking plainly: you would need to offer some kind of evidence of how exactly your opinion is supported, for the following example — if a person says "this marketing is consistent with the product", and the meaning of it somehow violates our premises above, so the person means "the claims in marketing are not real; or: it contains errors; or: their logic is invalid; or: they are tricking me hiding the truth or by exaggerating; or: they don't state limitations clearly". From our perspective it's quite a challenge to find evidence for such double-thinking, but one may try and we don't reject the possibility they will succeed — but we claim that this success might be misleading.
| Check | Result | Rule |
|---|---|---|
| src.zero_silent.zero-silent-grounded | HOLDS | src.zero_silent.marketing-claim-zero (0) must equal src.zero_silent.silent-inconsistency-count (0) |
| # | Name | Kind | Value | Grounding |
|---|---|---|---|---|
| 1 | src.zero_silent.zero-silent-grounded | diff | 0 = 0 | |
| 2 | src.zero_silent.criteria-count | calc | 5 | derived: (std.counting.count-exists src.zero_silent.correspondence src.zero_silent.validity src.zero_silent.internal-consistency src.zero_silent.soundness src.zero_silent.limitations-visible) |
| 3 | src.zero_silent.correspondence-state | theorem | std.epistemics.exemplifiable | derived: (src.zero_silent.criterion-state src.zero_silent.correspondence) |
| 4 | src.zero_silent.validity-state | theorem | std.epistemics.hallucinated | derived: (src.zero_silent.criterion-state src.zero_silent.validity) |
| 5 | src.zero_silent.consistency-state | theorem | std.epistemics.hallucinated | derived: (src.zero_silent.criterion-state src.zero_silent.internal-consistency) |
| 6 | src.zero_silent.soundness-state | theorem | std.epistemics.hallucinated | derived: (src.zero_silent.criterion-state src.zero_silent.soundness) |
| 7 | src.zero_silent.limitations-state | theorem | std.epistemics.unknown | derived: (src.zero_silent.criterion-state src.zero_silent.limitations-visible) |
| 8 | src.zero_silent.mapped-criteria-count | calc | 5 | derived: (std.counting.count-exists src.zero_silent.correspondence-state src.zero_silent.validity-state src.zero_silent.consistency-state src.zero_silent.soundness-state src.zero_silent.limitations-state) |
| 9 | src.zero_silent.hallucinated-produces-errors | calc | true | derived: engine.hallucinated-is-error |
| 10 | src.zero_silent.unknown-produces-warnings | calc | true | derived: engine.unknown-is-warning |
| 11 | src.zero_silent.isomorphism-holds | calc | true | derived: engine.isomorphism-hallucinations-errors-unknowns-warnings |
| 12 | src.zero_silent.proven-detection-count | theorem | 5 | derived: (src.zero_silent.detection-transferable src.zero_silent.mapped-criteria-count src.zero_silent.hallucinated-produces-errors src.zero_silent.unknown-produces-warnings src.zero_silent.isomorphism-holds) |
| 13 | src.zero_silent.silent-inconsistency-count | calc | 0 | derived: (- src.zero_silent.criteria-count src.zero_silent.proven-detection-count) |
| 14 | src.zero_silent.marketing-claim-zero | fact | 0 | IMPACT tile definition from the landing page source code: "num: "0", label: "SILENT INCONSISTENCIES", desc: "pre-existing or AI-introduced"" (cards, verified) |
| Group | Kind | Node | Description |
|---|---|---|---|
| Parseltongue (OSS) | raw | core/validation/core.pltg, std/counting.pltg (imported by every proof) | |
| Parseltongue (OSS) | raw | core/std/epistemics.pltg | |
| Parseltongue (OSS) | raw | core/demos/data_governance_pltg: generate.py, checker.pltg, resources/governance_policy.md | |
| Parseltongue (OSS) | raw | core/inspect/perspectives/visualisation/taints.py | |
| Parseltongue (OSS) | raw | core/quote_verifier/index.py | |
| Parseltongue (OSS) | raw | core/README.md | |
| Website | raw | vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles) | |
| Proof notebooks | raw | zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmd | |
| Proof notebooks | raw | resources/integrity-cortex.md | |
| Proof modules | facts | src/zero_silent.pltg | "0 silent inconsistencies" by construction: five naive consistency criteria map to the epistemic lattice, which the engine proves maps to errors and warnings, which have detectors; the count of silent ones is 0. Closes with diff zero-silent-grounded (the tile's 0 against silent-inconsistency-count). |
| Proof modules | facts | src/truth_grounded.pltg | "100% truth-grounded" by construction: a baseline of 100 (every item has a grounding state) times the loss factor of each of five pipeline stages. Closes with diff truth-grounded-proved (the tile's 100 against truth-grounded-coverage). |
| Proof modules | facts | src/sub_minute.pltg | "<1 min instead of weeks" by construction: the demo checker's compliance derives, counted as a document, give the manual scale in weeks; the per-edge cost of the taint BFS gives the parseltongue time. Closes with diffs weeks-grounded and sub-minute-grounded. |
| Proof modules | facts | src/unbounded.pltg | "∞ nodes and connections" by induction on system size (zero/succ): a zero-node system is valid, and validity at N gives validity at succ(N) with no guard on N. Closes with diff unbounded-grounded (the tile's ∞ against node-limit). |
| Proof modules | facts | src/reproducible.pltg | "Reproducible =" by existence: the proof pages exist and each executes a deterministic parseltongue computation. Closes with diff reproducible-grounded. |
| Proof pages | final | proofs/zero-silent.html | |
| Proof pages | final | proofs/truth-grounded.html | |
| Proof pages | final | proofs/sub-minute.html | |
| Proof pages | final | proofs/unbounded.html | |
| Proof pages | final | proofs/reproducible.html | |
| Proof pages | final | proofs/integrity-cortex.html (every proof, imported) |
| From | To | How |
|---|---|---|
| core/validation/core.pltg, std/counting.pltg (imported by every proof) | src/zero_silent.pltg | import |
| core/validation/core.pltg, std/counting.pltg (imported by every proof) | src/truth_grounded.pltg | import |
| core/validation/core.pltg, std/counting.pltg (imported by every proof) | src/sub_minute.pltg | import |
| core/validation/core.pltg, std/counting.pltg (imported by every proof) | src/unbounded.pltg | import |
| core/validation/core.pltg, std/counting.pltg (imported by every proof) | src/reproducible.pltg | import |
| core/std/epistemics.pltg | src/zero_silent.pltg | import |
| core/demos/data_governance_pltg: generate.py, checker.pltg, resources/governance_policy.md | src/sub_minute.pltg | load-document |
| core/inspect/perspectives/visualisation/taints.py | src/sub_minute.pltg | load-document |
| core/quote_verifier/index.py | src/truth_grounded.pltg | load-document |
| core/README.md | src/unbounded.pltg | load-document |
| zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmd | src/reproducible.pltg | load-document (all five) |
| zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmd | src/zero_silent.pltg | load-document (its own notebook) |
| zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmd | src/truth_grounded.pltg | load-document (its own notebook) |
| zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmd | src/unbounded.pltg | load-document (its own notebook) |
| vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles) | src/zero_silent.pltg | quotes the 0 tile |
| vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles) | src/truth_grounded.pltg | quotes the 100% tile |
| vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles) | src/sub_minute.pltg | quotes the <1 min tile |
| vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles) | src/unbounded.pltg | quotes the ∞ tile |
| vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles) | src/reproducible.pltg | quotes the A=A tile |
| src/zero_silent.pltg | proofs/zero-silent.html | diff zero-silent-grounded |
| src/truth_grounded.pltg | proofs/truth-grounded.html | diff truth-grounded-proved |
| src/sub_minute.pltg | proofs/sub-minute.html | diffs weeks-grounded, sub-minute-grounded |
| src/unbounded.pltg | proofs/unbounded.html | diff unbounded-grounded |
| src/reproducible.pltg | proofs/reproducible.html | diff reproducible-grounded |
| src/zero_silent.pltg | proofs/integrity-cortex.html (every proof, imported) | import |
| src/truth_grounded.pltg | proofs/integrity-cortex.html (every proof, imported) | import |
| src/sub_minute.pltg | proofs/integrity-cortex.html (every proof, imported) | import |
| src/unbounded.pltg | proofs/integrity-cortex.html (every proof, imported) | import |
| src/reproducible.pltg | proofs/integrity-cortex.html (every proof, imported) | import |
| resources/integrity-cortex.md | proofs/integrity-cortex.html (every proof, imported) | load-document |