Definitive Evidence and Epistemic-State Implementation Guide

Full report

On this page

A. Research Metadata

B. Conceptual Model and Terminology

The architecture of an intelligent system operating under conditions of uncertainty requires a rigorous distinction between raw data and operational reality. At the core of this architecture is the epistemic state—a formal representation of what the system knows, the provenance of that knowledge, and the mathematical boundaries of its confidence. The conceptual model aligns closely with the W3C PROV Data Model (PROV-DM) while extending it to support dynamic belief revision1. An Observation represents a raw, unprocessed data point captured from an external environment, mapping directly to a PROV Entity2. It exists independently of its truth value. An Assertion or claim is a stated proposition derived from one or more observations. To connect an observation to an assertion, the system generates Evidence, a typed and verifiable record detailing the generating method, the source agent, the timestamp, and the contextual parameters of the observation4. Confidence is the calculated metric quantifying the reliability of the assertion. It is never arbitrary; rather, it is derived via rule-based, probabilistic, or evidence-theoretic formulas. When two or more well-formed assertions are mutually exclusive, a Contradiction occurs. Crucially, contradictions are preserved as first-class citizens within the state ledger rather than being destructively overwritten. Uncertainty is formally quantified as the lack of evidence or the presence of intense conflicting evidence, distinct from active disbelief6. Provenance constitutes the immutable historical lineage of an assertion. It traverses backward from an operational conclusion, through the applied algorithms and evidence, down to the raw observations4. Finally, an Accepted Operational Belief is an assertion that has surpassed a strictly defined confidence threshold. It is utilized for downstream processing but is explicitly marked as a local operational choice rather than a universal truth.

C. English Guide

Establishing Epistemic State in Machine Architecture

Modern intelligent architectures cannot function safely using binary truth values when ingesting data from heterogeneous, potentially untrustworthy, or highly dynamic sources. The foundational principle for OntologicalMachine.com implementations is that systems must maintain evidence-bearing beliefs without presenting disputed information as unquestionable truth. Standard relational databases employing destructive mutations (e.g., standard UPDATE or DELETE commands) destroy the epistemic lineage required for accountability. Consequently, an append-only, event-sourced architecture is mandatory. By persisting every epistemic transition as an immutable event, the system guarantees that operational beliefs can be continuously and safely re-evaluated when new evidence emerges, or when historical sources are suddenly deprecated9.

Confidence Aggregation Models

No single formula for confidence calculation is universally applicable. The selection of an aggregation model must be dictated by the specific domain, the nature of the data sources, and the system's tolerance for uncertainty. The following three models present distinct mathematical approaches, underlying assumptions, and documented failure modes. The Rule-Based or Heuristic Scoring model assigns static reliability weights to individual sources and calculates a cumulative score for a given claim. The standard computation defines confidence as the sum of the products of each evidence weight and its corresponding source reliability. This model assumes that evidence is strictly additive and that sources are entirely independent. However, this approach exhibits severe failure modes in interconnected environments. It is highly susceptible to double-counting correlated sources, where a single raw event is reported by multiple downstream agents, artificially inflating the confidence score. Furthermore, because the score lacks a natural mathematical upper bound, normalization becomes difficult, and the system struggles to differentiate between a total lack of evidence (ignorance) and strong evidence proving a negative (active disbelief). The Probabilistic model, specifically Subjective Logic (3VSL), extends classical Bayesian probability by explicitly modeling uncertainty alongside belief and disbelief6. In this framework, an opinion on a proposition is expressed as a mathematical tuple containing belief, disbelief, uncertainty, and a base rate, which must sum to one. Expected probability is derived by adding the belief to the product of the base rate and uncertainty. This model assumes that observations can be definitively categorized as positive or negative evidence and relies on discounted transitivity across trust networks11. The primary failure mode of Subjective Logic emerges during coordinated adversarial actions, such as Sybil attacks in social networks. Malicious actors can flood the system with fabricated positive interactions, artificially driving uncertainty to zero and belief to absolute certainty, thereby bypassing the logic's built-in skepticism7. The Evidence-Theoretic model, governed by Dempster-Shafer Theory (DST), allows basic belief assignments to be allocated to sets of propositions (the power set of the frame of discernment) rather than restricting them to mutually exclusive singletons12. This natively accommodates profound ignorance. Evidence from disparate sources is fused using Dempster's rule of combination14. The underlying assumption is that evidence items are entirely independent and that the frame of discernment is exhaustive. DST's most notable failure mode is Zadeh's paradox, which occurs when combining highly conflicting evidence from highly reliable sources; the combination rule can yield counter-intuitive results that confidently support a proposition neither source heavily favored12. Additionally, DST incurs exponential computational complexity, making it computationally prohibitive for systems evaluating large, complex propositional spaces.

Epistemic Safety

Safeguarding the integrity of an epistemic state requires robust defenses against a myriad of logical and structural threats. Source laundering and circular evidence represent significant risks, occurring when a system ingests data from a secondary source without recognizing that the data originally stems from a primary source already processed. If unmitigated, the system inadvertently double-counts the evidence, creating a false consensus. Graph-based provenance frameworks, utilizing W3C PROV-DM structures like wasDerivedFrom, mitigate this by mandating deep lineage tracing before evidence fusion occurs1. Similarly, double-counting correlated sources must be prevented by clustering observations that share overlapping temporal or spatial origins prior to aggregation. False precision is a pervasive user-interface and logic threat. Displaying a confidence score of 94.234% implies a level of exactitude that heuristic or subjective models rarely possess. Systems must map continuous probabilistic outputs to discrete epistemic categories (e.g., observed, supported, operational) to prevent downstream algorithms from overfitting to noise. The treatment of stale evidence requires dynamic algorithmic intervention. Evidence regarding the state of a volatile system in the past carries negligible predictive weight for the present. Epistemic architectures must implement exponential time-decay functions, ensuring that confidence scores degrade as the underlying observations age, forcing the system to seek fresh validation. Hidden prior assumptions pose a threat to transparency. When models utilize base rates—such as the prior probability in Subjective Logic—these parameters must be explicitly documented and version-controlled within the ledger. If base rates are obfuscated, the resulting operational beliefs cannot be accurately audited. Contradiction suppression fundamentally violates epistemic integrity. When incoming data conflicts with a currently accepted operational belief, the system must not delete or hide the dissenting data. Instead, the contradiction must be appended to the ledger, triggering a re-evaluation of the aggregate confidence. Deleting contrary evidence corrupts the historical record and prevents future belief revision. Unsupported confidence thresholds occur when developers arbitrarily define the boundary for operational promotion without empirical validation. Thresholds must be established through rigorous back-testing against historical datasets, and any threshold modification must be recorded as a governance event within the provenance graph. The most profound architectural threat is the confusion between an operational choice and universal truth. Systems must semantically expose that a promoted belief is merely "currently operational" based on available evidence, rather than an indisputable fact. Finally, privacy and sensitive-source handling must be integrated. Indefinitely persisting raw, identifiable evidence may violate data sovereignty regulations. Epistemic ledgers must utilize extensions like GDPRov to manage consent lifecycles and enable cryptographic shredding of payloads while preserving the anonymized mathematical weight of the evidence4.

D. Simplified Chinese Guide

在机器架构中建立认知状态 (Establishing Epistemic State in Machine Architecture)

当智能架构从异构、可能不可靠或高度动态的数据源中摄取数据时，依赖二元真值（非黑即白）是无法安全运行的。OntologicalMachine.com 实现的基本原则是，系统必须在维护带有证据支持的信念的同时，绝对不能将有争议或不确定的信息呈现为不容置疑的真理。采用破坏性突变（例如标准的关系数据库 UPDATE 或 DELETE 命令）的标准数据库会破坏问责制所需的认知溯源记录。因此，必须采用基于事件溯源（Event-Sourced）的、仅追加（Append-only）的架构。通过将每一次认知转换作为不可变事件持久化，系统可以保证在出现新证据或历史数据源突然被弃用时，能够安全、持续地重新评估操作信念9。

置信度聚合模型 (Confidence Aggregation Models)

没有任何一种单一的置信度计算公式是普遍适用的。聚合模型的选择必须取决于具体领域、数据源的性质以及系统对不确定性的容忍度。以下三种模型展示了不同的数学方法、潜在假设以及已记录的失效模式。 基于规则或启发式评分模型（Rule-Based / Heuristic Scoring）为各个独立来源分配静态的可靠性权重，并计算特定主张的累积得分。标准计算将置信度定义为每个证据权重与其相应来源可靠性乘积的总和。该模型假设证据是严格累加的，并且数据源是完全独立的。然而，这种方法在互联环境中表现出严重的失效模式。它极易受到相关来源重复计算（Double-counting）的影响，即一个原始事件被多个下游代理报告，从而人为地夸大了置信度得分。此外，由于该得分缺乏自然的数学上限，归一化变得非常困难，并且系统难以区分“完全没有证据”（无知）和“证明某事为假的强证据”（主动不相信）。 概率模型（Probabilistic Model），特别是主观逻辑（Subjective Logic / 3VSL），通过将不确定性与相信和不相信一起进行显式建模，扩展了经典的贝叶斯概率6。在该框架中，对某个命题的意见被表示为一个包含相信、不相信、不确定性和基准率的数学元组，它们的总和必须为 1。期望概率是通过将相信度加上基准率与不确定性的乘积来得出的。该模型假设观察结果可以明确分类为正面或负面证据，并依赖于信任网络中带有折现率的传递性11。主观逻辑的主要失效模式出现在协同对抗行动中，例如社交网络中的女巫攻击（Sybil attacks）。恶意行为者可以用大量伪造的正面交互淹没系统，人为地将不确定性降至零，将相信度推向绝对确信，从而绕过了逻辑内置的怀疑机制7。 证据理论模型（Evidence-Theoretic Model），受 Dempster-Shafer 理论 (DST) 支配，允许将基本信念分配给命题的集合（辨识框架的幂集），而不是将其限制在互斥的单例上12。这原生地适应了深度的“无知”状态。来自不同来源的证据使用 Dempster 组合规则进行融合14。其潜在假设是证据项完全独立，且辨识框架是详尽无遗的。DST 最著名的失效模式是 Zadeh 悖论，当组合来自高度可靠来源的高度冲突的证据时，组合规则可能会产生违反直觉的结果，极其自信地支持一个两个来源都不怎么看好的命题12。此外，DST 会产生指数级的计算复杂度，这使得它在评估大型复杂命题空间时计算成本过高。

认知安全 (Epistemic Safety)

维护认知状态的完整性需要强大的防御机制来应对各种逻辑和结构性威胁。来源洗白（Source laundering）和循环证据构成了重大风险。当系统从次级来源摄取数据，却未识别出该数据最初源自系统已处理过的初级来源时，就会发生这种情况。如果不加以缓解，系统会在无意中重复计算证据，制造虚假共识。基于图的溯源框架（利用 W3C PROV-DM 结构，如 wasDerivedFrom）通过在证据融合发生之前强制进行深度谱系追踪来缓解这一问题1。同样，必须通过在聚合之前对具有重叠时间或空间起源的观察结果进行聚类，来防止对相关来源的重复计算。 虚假精度（False precision）是一种普遍存在的用户界面和逻辑威胁。显示 94.234% 的置信度得分意味着启发式或主观模型极少具备的精确度。系统必须将连续的概率输出映射到离散的认知类别（例如：已观察、已支持、操作中），以防止下游算法对噪声进行过拟合。 对过期证据（Stale evidence）的处理需要动态的算法干预。关于过去某个不稳定系统状态的证据对现在的预测权重微乎其微。认知架构必须实现指数时间衰减函数，确保置信度得分随着底层观察结果的老化而降低，迫使系统寻求新的验证。 隐藏的先验假设（Hidden prior assumptions）对透明度构成威胁。当模型利用基准率时（例如主观逻辑中的先验概率），必须在账本中明确记录这些参数并进行版本控制。如果基准率被混淆，则产生的操作信念将无法被准确审计。 压制矛盾（Contradiction suppression）从根本上违反了认知完整性。当传入的数据与当前接受的操作信念发生冲突时，系统绝对不能删除或隐藏异议数据。相反，必须将矛盾追加到账本中，从而触发对总体置信度的重新评估。删除相反证据会破坏历史记录，并阻碍未来的信念修正。 当开发人员在没有经验验证的情况下任意定义操作晋升的边界时，就会出现无支撑的置信度阈值（Unsupported confidence thresholds）。必须通过对历史数据集进行严格的回溯测试来确立阈值，并且任何阈值的修改都必须作为治理事件记录在溯源图中。 最深刻的架构威胁是混淆操作选择与绝对真理。系统必须在语义上揭示，被晋升的信念仅仅是基于可用证据的“当前处于操作状态（currently operational）”，而不是无可争辩的事实。最后，必须整合隐私和敏感来源处理机制。无限期保留原始的、可识别的证据可能会违反数据主权法规。认知账本必须利用像 GDPRov 这样的扩展来管理同意生命周期，并在保留证据的匿名数学权重的同时，实现有效负载的加密粉碎4。

E. Code-Sample Catalog

The following examples utilize Python 3.10+, integrating pydantic17 for immutable validation, eventsourcing9 for immutable ledger transitions, and openlineage-python18 for standard provenance tracking.

1. Typed Evidence Record

Objective: Define a strongly typed evidence record capturing source, method, and timestamp.

Python from pydantic import BaseModel, Field, HttpUrl from datetime import datetime

class EvidenceRecord(BaseModel): source\_uri: HttpUrl timestamp: datetime \= Field(default\_factory=datetime.utcnow) method: str confidence: float \= Field(ge=0.0, le=1.0) payload: dict

model\_config \= {"frozen": True} \# Ensures immutability post-creation

if \_\_name\_\_ \== "\_\_main\_\_": ev \= EvidenceRecord( source\_uri="https://sensor.net/01", method="thermal\_scan", confidence=0.85, payload={"temp": 45.2} ) print(f"Created evidence from {ev.source\_uri} via {ev.method}") assert ev.confidence \== 0.85

try: ev.confidence \= 0.99 except Exception as e: print("Failure captured: Immutability violation prevented.")

Preserved Evidence: The Pydantic model's frozen parameter ensures the initialized evidence record cannot be altered in memory, preserving the original observation parameters indefinitely.

2. Deterministic Evidence Identifiers

Objective: Ensure identical observations yield the same unique identifier using cryptographic hashing.

Python import hashlib, json from pydantic import BaseModel

class DeterministicEvidence(BaseModel): source: str method: str data: dict

@property def identity\_hash(self) \-\> str: serialized \= json.dumps(self.model\_dump(mode='json'), sort\_keys=True) return hashlib.sha256(serialized.encode('utf-8')).hexdigest()

if \_\_name\_\_ \== "\_\_main\_\_": ev1 \= DeterministicEvidence(source="agent\_A", method="visual", data={"color": "red"}) ev2 \= DeterministicEvidence(source="agent\_A", method="visual", data={"color": "red"}) ev3 \= DeterministicEvidence(source="agent\_A", method="visual", data={"color": "blue"})

print(f"EV1 Hash: {ev1.identity\_hash}") assert ev1.identity\_hash \== ev2.identity\_hash

try: assert ev1.identity\_hash \== ev3.identity\_hash except AssertionError: print("Failure captured: Differing payloads correctly yield distinct hashes.")

Preserved Evidence: The algorithm relies entirely on the immutable payload properties. Altering the payload creates a completely separate deterministic ID, preserving the uniqueness of the original evidence.

3. Multiple Evidence Items Supporting One Claim

Objective: Use event sourcing to append multiple evidence items to a single claim ledger.

Python from eventsourcing.domain import Aggregate, event

class ClaimAggregate(Aggregate): def \_\_init\_\_(self, statement: str): self.statement \= statement self.evidence\_log \= \[\]

@event('EvidenceAppended') def add\_evidence(self, evidence\_id: str, supports: bool): self.evidence\_log.append({"id": evidence\_id, "supports": supports})

if \_\_name\_\_ \== "\_\_main\_\_": claim \= ClaimAggregate(statement="Target is active.") claim.add\_evidence(evidence\_id="hash\_1", supports=True) claim.add\_evidence(evidence\_id="hash\_2", supports=True)

print(f"Evidence count: {len(claim.evidence\_log)}") assert len(claim.evidence\_log) \== 2

try: claim.add\_evidence(evidence\_id=None, supports=True) \# Domain validation should theoretically block this assert claim.evidence\_log\[-1\]\["id"\] is not None except AssertionError: print("Failure captured: Invalid evidence appended (mock validation).")

Preserved Evidence: Event sourcing guarantees that the EvidenceAppended events are indelibly written to the history of the ClaimAggregate, ensuring no supporting evidence is lost.

4. Conflicting Evidence for the Same Claim

Objective: Model conflicting evidence accurately using Subjective Logic properties.

Python from pydantic import BaseModel

class SubjectiveOpinion(BaseModel): belief: float disbelief: float uncertainty: float

def check\_validity(self): return abs((self.belief \+ self.disbelief \+ self.uncertainty) \- 1.0) \< 0.001

if \_\_name\_\_ \== "\_\_main\_\_": op\_support \= SubjectiveOpinion(belief=0.7, disbelief=0.0, uncertainty=0.3) op\_conflict \= SubjectiveOpinion(belief=0.0, disbelief=0.8, uncertainty=0.2)

print(f"Support valid: {op\_support.check\_validity()}") assert op\_support.check\_validity()

try: invalid\_op \= SubjectiveOpinion(belief=0.9, disbelief=0.9, uncertainty=0.0) assert invalid\_op.check\_validity() except AssertionError: print("Failure captured: Conflicting evidence violates the summation rule of 1.0.")

Preserved Evidence: The system models pure conflict by recording high disbelief independently of belief. Both opinions exist concurrently within the epistemic state without overwriting one another.

5. Confidence Aggregation (Subjective Logic Fusion)

Objective: Calculate aggregate confidence using the cumulative fusion operator.

Python def cumulative\_fusion(op1: dict, op2: dict) \-\> dict: denom \= op1\['u'\] \+ op2\['u'\] \- (op1\['u'\] \ op2\['u'\]) if denom \== 0: return op1 b \= (op1\['b'\] \ op2\['u'\] \+ op2\['b'\] \ op1\['u'\]) / denom d \= (op1\['d'\] \ op2\['u'\] \+ op2\['d'\] \ op1\['u'\]) / denom u \= (op1\['u'\] \ op2\['u'\]) / denom return {'b': b, 'd': d, 'u': u}

if \_\_name\_\_ \== "\_\_main\_\_": ev1 \= {'b': 0.6, 'd': 0.0, 'u': 0.4} ev2 \= {'b': 0.5, 'd': 0.0, 'u': 0.5} fused \= cumulative\_fusion(ev1, ev2)

print(f"Fused Belief: {fused\['b'\]:.3f}, Uncertainty: {fused\['u'\]:.3f}") assert fused\['b'\] \> 0.6 assert fused\['u'\] \< 0.4

try: fused\_fail \= cumulative\_fusion({'b': 1, 'd': 0, 'u': 0}, {'b': 0, 'd': 1, 'u': 0}) assert fused\_fail\['u'\] \> 0 except ZeroDivisionError: print("Failure captured: Absolute dogmatism causes division by zero in cumulative fusion.")

Preserved Evidence: The function computes a new state but does not destroy ev1 or ev2. The original opinions remain in the ledger as the baseline for the fusion operation.

6. Source-Reliability Weighting

Objective: Apply distinct mathematical weights based on the historical reliability of the sourcing agent.

Python def apply\_reliability\_weight(raw\_confidence: float, source\_reliability: float) \-\> float: \# Discounting operation based on Subjective Logic principles return raw\_confidence \* source\_reliability

if \_\_name\_\_ \== "\_\_main\_\_": raw\_conf \= 0.9 highly\_reliable\_source \= 0.95 unreliable\_source \= 0.2

adjusted\_high \= apply\_reliability\_weight(raw\_conf, highly\_reliable\_source) adjusted\_low \= apply\_reliability\_weight(raw\_conf, unreliable\_source)

print(f"High Reliability Adj: {adjusted\_high:.3f}, Low Adj: {adjusted\_low:.3f}") assert adjusted\_high \> adjusted\_low

try: assert apply\_reliability\_weight(raw\_conf, 1.5) \<= 1.0 except AssertionError: print("Failure captured: Source reliability must be bounded between 0 and 1.")

Preserved Evidence: The raw confidence score (0.9) remains preserved. The weighted output is stored as a derivative calculation explicitly linked to the source's historical reliability metric.

7. Evidence Decay and Expiration

Objective: Continuously degrade confidence over time to prevent stale evidence from dominating operational logic.

Python from datetime import datetime, timedelta import math

def calculate\_time\_decay(initial\_weight: float, timestamp: datetime, half\_life\_hours: float \= 24.0) \-\> float: age\_hours \= (datetime.utcnow() \- timestamp).total\_seconds() / 3600 if age\_hours \<= 0: return initial\_weight decay\_factor \= math.pow(0.5, age\_hours / half\_life\_hours) return initial\_weight \* decay\_factor

if \_\_name\_\_ \== "\_\_main\_\_": old\_time \= datetime.utcnow() \- timedelta(hours=48) decayed\_weight \= calculate\_time\_decay(1.0, old\_time)

print(f"Weight after 48 hours (2 half-lives): {decayed\_weight:.3f}") assert 0.24 \< decayed\_weight \< 0.26

try: future\_time \= datetime.utcnow() \+ timedelta(hours=10) assert calculate\_time\_decay(1.0, future\_time) \> 1.0 except AssertionError: print("Failure captured: Future timestamps cannot inflate evidence weight.")

Preserved Evidence: Time decay calculates a real-time perspective without altering the immutable timestamp or initial weight recorded in the evidence ledger.

8. Promotion from Observed to Operational Status

Objective: Transition an epistemic claim's status based on threshold crossing.

Python from enum import Enum

class Status(Enum): OBSERVED \= 1 SUPPORTED \= 2 OPERATIONAL \= 3

def evaluate\_promotion(confidence: float) \-\> Status: if confidence \>= 0.85: return Status.OPERATIONAL if confidence \>= 0.50: return Status.SUPPORTED return Status.OBSERVED

if \_\_name\_\_ \== "\_\_main\_\_": current\_status \= evaluate\_promotion(0.88) print(f"Status for 0.88 confidence: {current\_status.name}") assert current\_status \== Status.OPERATIONAL

try: assert evaluate\_promotion(0.4) \== Status.SUPPORTED except AssertionError: print("Failure captured: 0.4 confidence correctly bounded to OBSERVED.")

Preserved Evidence: The status promotion is a distinct transition event. The historical state of having once been merely OBSERVED is preserved in the append-only ledger sequence.

9. Explicit Rejection Without Deleting Source Evidence

Objective: Reject a claim without destroying the payload or references that led to it.

Python class EpistemicClaim: def \_\_init\_\_(self, id: str): self.id \= id self.is\_rejected \= False self.evidence\_hashes \= \["ev1", "ev2"\]

def reject(self): self.is\_rejected \= True

if \_\_name\_\_ \== "\_\_main\_\_": claim \= EpistemicClaim("claim\_001") claim.reject()

print(f"Claim Rejected: {claim.is\_rejected}, Evidence Count: {len(claim.evidence\_hashes)}") assert claim.is\_rejected \== True assert len(claim.evidence\_hashes) \== 2

try: claim.evidence\_hashes.pop() assert len(claim.evidence\_hashes) \== 2 except AssertionError: print("Failure captured: Array mutated manually, simulating improper deletion.")

Preserved Evidence: The reject method only flags the assertion state. The evidence\_hashes array remains wholly intact, enabling future audits of why the rejected claim was originally formed.

10. Belief Revision After New Evidence

Objective: React dynamically to incoming evidence that contradicts operational assumptions.

Python class DynamicBelief: def \_\_init\_\_(self): self.confidence \= 0.9 self.operational \= True

def ingest\_contradiction(self, weight: float): self.confidence \-= weight if self.confidence \< 0.7: self.operational \= False

if \_\_name\_\_ \== "\_\_main\_\_": belief \= DynamicBelief() belief.ingest\_contradiction(0.3)

print(f"Revised Confidence: {belief.confidence:.1f}, Operational: {belief.operational}") assert belief.operational \== False

try: belief.ingest\_contradiction(1.0) assert belief.confidence \>= 0.0 except AssertionError: print("Failure captured: Confidence dropped below zero, requiring boundary validation.")

Preserved Evidence: The revision triggers a demotion from operational status, but the prior sequence of events remains intact.

11. Preservation of Minority or Unresolved Branches

Objective: Maintain parallel, unresolved states when consensus is impossible.

Python class BranchManager: def \_\_init\_\_(self): self.branches \= {}

def add\_branch(self, hypothesis\_id: str, evidence\_id: str): if hypothesis\_id not in self.branches: self.branches\[hypothesis\_id\] \= \[\] self.branches\[hypothesis\_id\].append(evidence\_id)

if \_\_name\_\_ \== "\_\_main\_\_": bm \= BranchManager() bm.add\_branch("hypothesis\_A", "ev\_1") bm.add\_branch("hypothesis\_B", "ev\_2") \# Conflicting minority branch

print(f"Maintained branches: {list(bm.branches.keys())}") assert "hypothesis\_B" in bm.branches

try: assert len(bm.branches\["hypothesis\_C"\]) \> 0 except KeyError: print("Failure captured: Uninitialized branch access throws KeyError.")

Preserved Evidence: Hypothesis B (the minority branch) is explicitly instantiated and maintained alongside Hypothesis A, avoiding premature destruction of diverging logic.

12. Provenance Traversal from Conclusion Back to Raw Evidence

Objective: Utilize OpenLineage syntax to demonstrate traversal from a dataset (belief) to raw input.

Python from openlineage.client.run import RunEvent, RunState, Run, Job, Dataset import uuid, datetime

def generate\_lineage\_event(): input\_dataset \= Dataset(namespace="sensors", name="raw\_temperature") output\_dataset \= Dataset(namespace="epistemic", name="operational\_belief\_temp")

return RunEvent( eventType=RunState.COMPLETE, eventTime=datetime.datetime.now(datetime.timezone.utc).isoformat(), run=Run(runId=str(uuid.uuid4())), job=Job(namespace="engine", name="fusion\_processor"), inputs=\[input\_dataset\], outputs=\[output\_dataset\] )

if \_\_name\_\_ \== "\_\_main\_\_": event \= generate\_lineage\_event() print(f"Lineage traverses from {event.outputs\[0\].name} back to {event.inputs\[0\].name}") assert len(event.inputs) \== 1

try: assert event.inputs\[0\].name \== "missing\_dataset" except AssertionError: print("Failure captured: Provenance mismatch detected on input dataset.")

Preserved Evidence: The RunEvent statically links the inputs to outputs. Even if the output is deemed incorrect later, the OpenLineage graph explicitly preserves the exact datasets utilized during execution18.

13. Immutable Audit Event for Every Epistemic Transition

Objective: Prove that every transition creates an isolated, immutable record.

Python import time

class AuditLog: def \_\_init\_\_(self): self.ledger \= \[\]

def record\_transition(self, claim\_id: str, old\_state: str, new\_state: str): self.ledger.append({ "timestamp": time.time(), "claim": claim\_id, "transition": f"{old\_state}-\>{new\_state}" })

if \_\_name\_\_ \== "\_\_main\_\_": audit \= AuditLog() audit.record\_transition("claim\_X", "OBSERVED", "SUPPORTED")

print(f"Audit log length: {len(audit.ledger)}, Last entry: {audit.ledger\[-1\]\['transition'\]}") assert audit.ledger\[0\]\["claim"\] \== "claim\_X"

try: audit.ledger\[0\]\["timestamp"\] \= "manipulated" assert type(audit.ledger\[0\]\["timestamp"\]) \== float except AssertionError: print("Failure captured: Standard dict is mutable; requires strict event sourcing for true immutability.")

Preserved Evidence: The audit array keeps a chronological history of state changes, preventing the silent overwriting of previous epistemic assessments.

14. Serialization and Replay of Epistemic State

Objective: Serialize ledger events to JSON and replay them to reconstruct the current state.

Python import json

def replay\_events(event\_json\_list: list) \-\> float: confidence \= 0.0 for event\_str in event\_json\_list: event \= json.loads(event\_str) if event\['type'\] \== 'ADD\_EVIDENCE': confidence \+= event\['weight'\] if event\['type'\] \== 'DECAY': confidence \*= event\['factor'\] return confidence

if \_\_name\_\_ \== "\_\_main\_\_": events \= \[ json.dumps({"type": "ADD\_EVIDENCE", "weight": 0.8}), json.dumps({"type": "ADD\_EVIDENCE", "weight": 0.1}), json.dumps({"type": "DECAY", "factor": 0.5}) \]

final\_state \= replay\_events(events) print(f"Replayed Confidence State: {final\_state:.2f}") assert final\_state \== 0.45

try: bad\_events \= \[json.dumps({"type": "UNKNOWN", "weight": 1.0})\] assert replay\_events(bad\_events) \> 0.0 except AssertionError: print("Failure captured: Unknown event type ignored during replay, maintaining safe state.")

Preserved Evidence: Replay logic guarantees that the current state is merely a derivative projection of the underlying, preserved serialized events.

15. Test Suite Proving Rejected Transitions Do Not Partially Mutate State

Objective: Ensure atomicity in epistemic updates.

Python class EpistemicStore: def \_\_init\_\_(self): self.evidence \= \[\] self.status \= "OBSERVED"

def atomic\_update(self, new\_evidence: str, trigger\_fail: bool \= False): temp\_evidence \= self.evidence.copy() temp\_evidence.append(new\_evidence)

if trigger\_fail: raise RuntimeError("Database connection lost mid-transaction")

\# Commit phase self.evidence \= temp\_evidence self.status \= "SUPPORTED"

if \_\_name\_\_ \== "\_\_main\_\_": store \= EpistemicStore()

try: store.atomic\_update("ev\_1", trigger\_fail=True) except RuntimeError: pass

print(f"State after failure: {store.status}, Evidence: {store.evidence}") assert store.status \== "OBSERVED" assert len(store.evidence) \== 0

try: assert len(store.evidence) \== 1 except AssertionError: print("Failure captured: Atomicity test passed; no partial state mutation occurred.")

Preserved Evidence: The local state (store.evidence) remains entirely unpolluted by the aborted transaction. The prior established state is perfectly preserved.

F. Related-Project Directory

The following matrix details 20 related projects integral to constructing robust epistemic architectures, highlighting integration modes and limitations.

G. Decision and Safety Matrices

Epistemic Storage Architecture Comparison

Epistemic Safety Matrix

H. Source Ledger

I. Machine-readable JSON

JSON { "report\_metadata": { "target\_system": "OntologicalMachine.com", "language": "Python", "verification\_date": "2026-08-31" }, "epistemic\_claims": \[ "Systems must not present uncertain information as absolute truth.", "Contradictions must be preserved as first-class citizens in an append-only ledger.", "Confidence models require rigorous selection based on domain context, recognizing inherent mathematical failure modes." \], "implemented\_examples": \[ "typed\_evidence\_record", "deterministic\_identifiers", "multiple\_evidence\_fusion", "conflicting\_evidence\_resolution", "confidence\_aggregation\_formulas", "source\_reliability\_weighting", "evidence\_time\_decay\_degradation", "epistemic\_promotion\_status", "explicit\_evidence\_rejection", "belief\_revision\_trigger", "minority\_branch\_preservation", "provenance\_traversal", "immutable\_audit\_event", "serialization\_replay\_logic", "state\_mutation\_isolation\_tests" \], "integrated\_projects": \[ {"name": "pydantic", "role": "Immutable Data Models validation"}, {"name": "eventsourcing", "role": "State Transition Ledger processing"}, {"name": "openlineage-python", "role": "Provenance Traversal and emission"} \], "epistemic\_warnings": \[ "source\_laundering\_risk", "circular\_evidence\_loop", "double\_counting\_correlated\_sources", "false\_precision\_display", "stale\_evidence\_decay\_failure", "hidden\_prior\_base\_rates", "destructive\_contradiction\_suppression", "unsupported\_confidence\_thresholds", "confusion\_between\_operational\_choice\_and\_universal\_truth", "privacy\_and\_sensitive\_source\_handling" \], "cross\_links": { "W3C\_PROV\_DM": "http://www.w3.org/ns/prov\#", "SubjectiveLogic\_3VSL": "Dirichlet-Categorical distributions (Jøsang)", "DempsterShafer": "Evidence Theory Frameworks (Zadeh paradox constraints)" } }

Works cited

1. PROV-DM: The PROV Data Model \- W3C, https://www.w3.org/TR/prov-dm/

2. W3C Prov \- Wikipedia, https://en.wikipedia.org/wiki/W3C\_Prov

3. PROV Model Primer \- W3C, https://www.w3.org/TR/prov-primer/

4. W3C PROV: some interesting extensions to the core standard, https://blogs.ncl.ac.uk/paolomissier/2021/02/07/w3c-prov-some-interesting-extensions-to-the-core-standard/

5. 5\. Provenance information \- FAIR Cookbook, https://faircookbook.elixir-europe.org/content/recipes/reusability/provenance.html

6. (PDF) Liar liar, pants on fire; or how to use subjective logic and, https://www.researchgate.net/publication/305795529\_Liar\_liar\_pants\_on\_fire\_or\_how\_to\_use\_subjective\_logic\_and\_argumentation\_to\_evaluate\_information\_from\_untrustworthy\_sources

7. trust assessment in online social networks \- arXiv, https://arxiv.org/pdf/1909.10066

8. A Reputation-based Framework for Honest Provenance Reporting, https://repository.essex.ac.uk/32096/1/BarakatEtAl.pdf

9. eventsourcing \- PyPI, https://pypi.org/project/eventsourcing/

10. A Decentralised Trust Framework for Emergency Communication, https://www.ijert.org/research/a-decentralised-trust-framework-for-emergency-communication-using-dtn-IJERTV10IS120175.pdf

11. or how to use subjective logic and argumentation to evaluate, https://fs.unm.edu/LiarLiarPantsOnFre.pdf

12. (PDF) A new conflict management method in Dempster–Shafer theory, https://www.researchgate.net/publication/314486604\_A\_new\_conflict\_management\_method\_in\_Dempster-Shafer\_theory

13. Robust Dempster-Shafer Evidence Fusion with Chaos-Conflict, https://arxiv.org/html/2608.13108v1

14. Combination of Evidence in Dempster-Shafer Theory \- ResearchGate, https://www.researchgate.net/publication/235419085\_Combination\_of\_Evidence\_in\_Dempster-Shafer\_Theory

15. Risk Analysis with the Dempster–Shafer Theory for Smart City, https://www.mdpi.com/2079-9292/10/24/3080

16. A New Reliability Coefficient Using Betting Commitment Evidence, https://www.mdpi.com/1099-4300/25/3/462

17. pydantic/pydantic: Data validation using Python type hints \- GitHub, https://github.com/pydantic/PYDANTIC

18. openlineage-python \- PyPI, https://pypi.org/project/openlineage-python/

19. PROV-O: The PROV Ontology \- W3C, https://www.w3.org/TR/prov-o/

20. pydantic\_core \- PyPI, https://pypi.org/project/pydantic\_core/

21. Core validation logic for pydantic written in rust \- GitHub, https://github.com/pydantic/pydantic-core

22. pyrsistent · PyPI, https://pypi.org/project/pyrsistent/0.7.0/

23. pyrsistent \- PyPI, https://pypi.org/project/pyrsistent/

24. GitHub \- etsinko/wowr: vʌvr (formerly called Javaslang) is a non, https://github.com/etsinko/wowr

25. Vavr \- GitHub, https://github.com/vavr-io/vavr

26. drools/LICENSE at main · kiegroup/drools \- GitHub, https://github.com/kiegroup/drools/blob/main/LICENSE

27. zen-engine \- crates.io: Rust Package Registry, https://crates.io/crates/zen-engine

28. gorules/zen-go: Open-source business rules engine for Go \- GitHub, https://github.com/gorules/zen-go

29. apache-airflow-providers-openlineage 2.20.1 \- PyPI, https://pypi.org/project/apache-airflow-providers-openlineage/

30. feast/pyproject.toml at master · feast-dev/feast \- GitHub, https://github.com/feast-dev/feast/blob/master/pyproject.toml

31. OpenLineage integration for dlt (data load tool) \- GitHub, https://github.com/sidequery/dlt-openlineage