Zero Silent Inconsistencies

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:

  1. "It's real", or in precise terms: there is correspondence to things observable in reality
  2. "There are no factual errors in the claims", or in precise terms: the claim is valid in logical sense and conclusion follows from premises, and premises are true. Note that consumers do not expect "no errors anywhere, ever" — that's why warranties, incidents and support processes exist. What they do expect is that the claims themselves are not misleading.
  3. "There are no issues with the logical basis which used in the claim", or in precise terms: the claim is consistent within the system it was made in, no contradictions arise
  4. "There are no tricks", or in precise terms: the claim is sound relative to application of the claim
  5. "Limitations are clearly communicated", or in precise terms: the claim's scope, applicability and limitations in verification are visible and verifiable

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.

pltg
Load
(import (quote .src.zero_silent zs))
zs.criteria-count
Out
5

We define 5 [2] criteria above. We now will show that any statement in Integrity Cortex satisfies such criteria, via the following procedure:

  1. We will map each of those criteria to epistemic statuses defined by the engine of the system
  2. We will show that each of those statuses is always available to check for any claim
  3. We will show that none of the statuses is silent in the engine and that the classification is exhaustive relative to our definitions above, rejecting silence as a null hypothesis

Mapping criteria to epistemic states

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.

pltg
Mapping
zs.mapped-criteria-count
Out
5

5 [8] criteria are mapped to epistemic states.

From epistemic states to detection

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: detectors cover all states

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.

Transfer and result

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]

pltg
Result
zs.silent-inconsistency-count
Out
0

Silent inconsistency count: 5 [2] criteria − 5 [12] proven detections = 0. [13] The marketing claim is 0 [14][1].

Limitations

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.

Checks

CheckResultRule
src.zero_silent.zero-silent-groundedHOLDSsrc.zero_silent.marketing-claim-zero (0) must equal src.zero_silent.silent-inconsistency-count (0)

References

#NameKindValueGrounding
1src.zero_silent.zero-silent-groundeddiff0 = 0
2src.zero_silent.criteria-countcalc5derived: (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)
3src.zero_silent.correspondence-statetheoremstd.epistemics.exemplifiablederived: (src.zero_silent.criterion-state src.zero_silent.correspondence)
4src.zero_silent.validity-statetheoremstd.epistemics.hallucinatedderived: (src.zero_silent.criterion-state src.zero_silent.validity)
5src.zero_silent.consistency-statetheoremstd.epistemics.hallucinatedderived: (src.zero_silent.criterion-state src.zero_silent.internal-consistency)
6src.zero_silent.soundness-statetheoremstd.epistemics.hallucinatedderived: (src.zero_silent.criterion-state src.zero_silent.soundness)
7src.zero_silent.limitations-statetheoremstd.epistemics.unknownderived: (src.zero_silent.criterion-state src.zero_silent.limitations-visible)
8src.zero_silent.mapped-criteria-countcalc5derived: (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)
9src.zero_silent.hallucinated-produces-errorscalctruederived: engine.hallucinated-is-error
10src.zero_silent.unknown-produces-warningscalctruederived: engine.unknown-is-warning
11src.zero_silent.isomorphism-holdscalctruederived: engine.isomorphism-hallucinations-errors-unknowns-warnings
12src.zero_silent.proven-detection-counttheorem5derived: (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)
13src.zero_silent.silent-inconsistency-countcalc0derived: (- src.zero_silent.criteria-count src.zero_silent.proven-detection-count)
14src.zero_silent.marketing-claim-zerofact0IMPACT tile definition from the landing page source code: "num: "0", label: "SILENT INCONSISTENCIES", desc: "pre-existing or AI-introduced"" (cards, verified)

Lineage

GroupKindNodeDescription
Parseltongue (OSS)rawcore/validation/core.pltg, std/counting.pltg (imported by every proof)
Parseltongue (OSS)rawcore/std/epistemics.pltg
Parseltongue (OSS)rawcore/demos/data_governance_pltg: generate.py, checker.pltg, resources/governance_policy.md
Parseltongue (OSS)rawcore/inspect/perspectives/visualisation/taints.py
Parseltongue (OSS)rawcore/quote_verifier/index.py
Parseltongue (OSS)rawcore/README.md
Websiterawvectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles)
Proof notebooksrawzero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmd
Proof notebooksrawresources/integrity-cortex.md
Proof modulesfactssrc/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 modulesfactssrc/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 modulesfactssrc/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 modulesfactssrc/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 modulesfactssrc/reproducible.pltg"Reproducible =" by existence: the proof pages exist and each executes a deterministic parseltongue computation. Closes with diff reproducible-grounded.
Proof pagesfinalproofs/zero-silent.html
Proof pagesfinalproofs/truth-grounded.html
Proof pagesfinalproofs/sub-minute.html
Proof pagesfinalproofs/unbounded.html
Proof pagesfinalproofs/reproducible.html
Proof pagesfinalproofs/integrity-cortex.html (every proof, imported)
FromToHow
core/validation/core.pltg, std/counting.pltg (imported by every proof)src/zero_silent.pltgimport
core/validation/core.pltg, std/counting.pltg (imported by every proof)src/truth_grounded.pltgimport
core/validation/core.pltg, std/counting.pltg (imported by every proof)src/sub_minute.pltgimport
core/validation/core.pltg, std/counting.pltg (imported by every proof)src/unbounded.pltgimport
core/validation/core.pltg, std/counting.pltg (imported by every proof)src/reproducible.pltgimport
core/std/epistemics.pltgsrc/zero_silent.pltgimport
core/demos/data_governance_pltg: generate.py, checker.pltg, resources/governance_policy.mdsrc/sub_minute.pltgload-document
core/inspect/perspectives/visualisation/taints.pysrc/sub_minute.pltgload-document
core/quote_verifier/index.pysrc/truth_grounded.pltgload-document
core/README.mdsrc/unbounded.pltgload-document
zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmdsrc/reproducible.pltgload-document (all five)
zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmdsrc/zero_silent.pltgload-document (its own notebook)
zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmdsrc/truth_grounded.pltgload-document (its own notebook)
zero-silent.pgmd, truth-grounded.pgmd, sub-minute.pgmd, unbounded.pgmd, reproducible.pgmdsrc/unbounded.pltgload-document (its own notebook)
vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles)src/zero_silent.pltgquotes the 0 tile
vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles)src/truth_grounded.pltgquotes the 100% tile
vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles)src/sub_minute.pltgquotes the <1 min tile
vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles)src/unbounded.pltgquotes the ∞ tile
vectorcat-website src/components/react/IntegrityCortexCards.jsx (the IMPACT tiles)src/reproducible.pltgquotes the A=A tile
src/zero_silent.pltgproofs/zero-silent.htmldiff zero-silent-grounded
src/truth_grounded.pltgproofs/truth-grounded.htmldiff truth-grounded-proved
src/sub_minute.pltgproofs/sub-minute.htmldiffs weeks-grounded, sub-minute-grounded
src/unbounded.pltgproofs/unbounded.htmldiff unbounded-grounded
src/reproducible.pltgproofs/reproducible.htmldiff reproducible-grounded
src/zero_silent.pltgproofs/integrity-cortex.html (every proof, imported)import
src/truth_grounded.pltgproofs/integrity-cortex.html (every proof, imported)import
src/sub_minute.pltgproofs/integrity-cortex.html (every proof, imported)import
src/unbounded.pltgproofs/integrity-cortex.html (every proof, imported)import
src/reproducible.pltgproofs/integrity-cortex.html (every proof, imported)import
resources/integrity-cortex.mdproofs/integrity-cortex.html (every proof, imported)load-document