Beyond the Graph: Why QCA Builds Belief Clusters From Co-Occurrence Evidence Instead of Structural Edges
QCA's joint-belief intelligence layer now constructs its clusters from empirical co-occurrence evidence rather than from the structural edges of a belief graph. This article explains what changed, why we made the change, what the new quantum computation path does, and what remains open. The work landed in commit a62018e on 2026-10-13 as four new modules and 21 integration tests (QI1–QI20).
The seam we were trying to close
QCA reasons over belief clusters — sets of beliefs whose joint probability distribution is computed together each cognitive cycle. In the previous design, clusters were formed as connected components over SUPPORT/CONTRADICT graph edges. That meant a belief had to participate in a structurally encoded relationship to be considered for joint computation.
The limitation [OBSERVED]: beliefs that showed strong empirical correlation in the data were nonetheless excluded from joint reasoning whenever no SUPPORT/CONTRADICT edge happened to connect them. The graph topology, not the evidence, decided who got to be in the room. For a system whose entire premise is reasoning under correlated uncertainty, letting edge bookkeeping gate the computation is a real defect [INFERRED].
The topology-free cluster builder
The new builder (quantum_cluster_builder.py) forms clusters directly from co-occurrence evidence. For each pair of beliefs it looks at the deviation from independence, |P_ij − P_i·P_j| — the gap between the observed joint frequency and what you would expect if the two beliefs were independent. Pairs whose deviation is meaningful are grouped together, regardless of whether any graph edge exists between them [OBSERVED].
This inverts the old dependency. Rather than "do we have an edge, and if so compute the joint," the question becomes "does the evidence say these beliefs move together, and if so compute the joint." Structural edges can still carry semantic meaning elsewhere in QCA, but they no longer act as a gate on joint computation.
Quantum computation over the active clusters
Once a cluster is formed, QCA constructs a joint probability distribution over it using a quantum circuit. The circuit builder (quantum_circuit_builder.py) encodes the cluster's pairwise correlation structure into a circuit; the backend (quantum_backend.py) executes it on Qiskit's Aer statevector simulator.
We use statevector simulation deliberately: it is exact and carries zero shot noise [OBSERVED]. At this stage we want the quantum-derived distribution to be a faithful computation of the encoded correlations, not a sampled approximation with its own error budget. That makes the results directly comparable against a classical oracle, which is how we validated the layer (below).
After the circuit executes, propagate_quantum_posteriors() (quantum_propagation.py) writes the quantum-derived posteriors back into BeliefNode.confidence values. This is the crucial integration point [OBSERVED]: the quantum computation does not live in a side channel. It revises the shared belief state, and every downstream consumer — trading tick reasoning, gap investigation, business reasoning — inherits the revised state automatically on the next read. No subsystem decides whether to invoke quantum; there is no opt-in flag at the consumer level [OBSERVED]. The reasoning layer is uniform by construction.
What we validated
The headline correctness result: the k=2 exact circuit matches the classical ExactJointDistribution oracle to within KL divergence < 0.001 nats across all three tested correlation scenarios [OBSERVED]. KL divergence here measures how far the quantum-derived distribution sits from the known-correct classical one; a value that small means the two are, for practical purposes, the same distribution. This is covered by the QI1–QI20 integration suite in tests/agent/mps/test_quantum_integration.py.
What this establishes [INFERRED]: at k=2, the quantum path is a faithful reimplementation of the joint computation, not an approximation we are hoping is close enough. That is the right order of operations — prove equivalence against an oracle on small clusters before trusting the path on clusters too large to check classically.
What it does not yet establish [UNKNOWN]: whether the equivalence holds as cluster size k grows, and whether the co-occurrence-driven clusters produce better downstream decisions than the old edge-driven clusters. The present evidence is about computational fidelity, not decision quality or profitability. We make no profitability or performance-improvement claim here, because we have not measured one.
The hardware escalation path
The architecture names qiskit-ibm-runtime 0.43 (IBM Quantum Runtime) as the path to real quantum hardware [OBSERVED]. The trigger conditions are specific: when cluster k consistently exceeds 15, or when classical statevector simulation becomes the throughput bottleneck [OBSERVED]. Statevector simulation cost grows exponentially in k, so at some cluster size the simulator stops being the convenient exact oracle and starts being the constraint [INFERRED].
Two honest caveats [UNKNOWN]: we have not run on IBM hardware, so we have no first-party data on whether real-device noise keeps the KL fidelity we see in simulation, and we have not yet observed clusters in production that consistently exceed k=15. The escalation path is architected and named, not exercised.
What we learned
The durable lesson is architectural rather than quantum [INFERRED]. The valuable change was decoupling cluster membership from graph topology — letting correlation evidence, not edge bookkeeping, decide what gets reasoned about jointly. The quantum circuit is the computation engine for the joint distribution, and at k=2 we have proven it computes the right thing. Whether quantum computation earns its place over the classical path at scale is an open question that only larger clusters and hardware execution will answer [UNKNOWN].
For now: the seam is closed, the belief state is uniform across all consumers, and the computation is validated against a classical oracle to KL < 0.001 nats at k=2.
---
Evidence: commit a62018e (2026-10-13); tests/agent/mps/test_quantum_integration.py QI1–QI20; modules quantum_backend.py, quantum_circuit_builder.py, quantum_cluster_builder.py, quantum_propagation.py.