Graph → QPC circuit → IBM Fez → measure → reconstruct graph. Validates that relational structure can be recovered from quantum measurement on real hardware.
The RICT encode–decode test checks whether QPC can encode a relational network (graph) into a quantum circuit, run it on real hardware, and decode the graph from the measurement outcomes. Success here means the full loop works: structure in → structure out.
Take a random graph A (nodes and edges), encode it into phases and entanglement (edges encoding), run the circuit on IBM Fez, collect shots, then reconstruct an estimated graph A′ from the measurement correlation matrix. Compare A′ to A using edge precision, recall, and F1.
PRCBS (RICT, CPRP, PCRT) shows that QPC circuits produce high diversity and entropy on hardware. This test goes one step further: it asks whether the relational structure is actually recoverable. If we can decode the graph above chance, QPC is not only generating complex output but preserving structural information in a way that can be read back.
Customers often ask: what does “encode a graph and decode it” have to do with practical tasks? In short: we put a structure (who is connected to whom) into the quantum run, and we read that structure back from the measurement. That same idea applies wherever you need to recover relationships or structure from limited or noisy data.
In holography, a 3D scene is encoded into an interference pattern (a “flat” recording). When you shine light through it, you recover the full 3D structure. Here we do something similar: the graph (the “scene” of relationships) is encoded into the quantum state; the measurement gives us a kind of interference pattern. Decoding is recovering the relationship structure from that pattern. So the test shows that QPC can, in principle, support tasks where you store rich structural information in a distributed way and reconstruct it later—useful for imaging, compressed sensing, or any setting where the full structure is encoded in a mixed or lower-dimensional signal.
Many real problems are about relationships rather than single items: who influences whom, which suppliers feed which factories, which nodes in a network depend on each other. You often don’t see the links directly—you see aggregate or noisy data. Encoding/decoding here means: we put a network of links into the quantum process, run it, and then try to recover that network from the outcomes. The test proves that recovery is possible above chance on real hardware. So it’s relevant for supply chains, social or contact networks, infrastructure dependencies, or any domain where “who is connected to whom” must be inferred from indirect or noisy measurements.
Sometimes you have many signals (sensors, agents, variables) and you want to know which ones are really linked—not just correlated by chance. The quantum run encodes relationship structure; the measurement outcomes give us correlations. Decoding is turning those correlations back into an estimated structure (who is linked to whom). So the test is a proof of concept for tasks where you have to infer structure from correlation data—e.g. sensor networks, fault propagation, financial or biological networks—when that structure was “hidden” inside a quantum or high-dimensional process.
Bottom line: Encoding = putting a relationship graph into the computation. Decoding = reading that graph back from the results. The test shows this works on real quantum hardware. The same idea applies to any real-world task where you need to store or recover who is connected to whom from limited or noisy data.
Production configuration: 20 nodes, edges encoding, 3 ensemble runs on Fez, simulator baseline for comparison.
./run_rict_production.sh or python3 qpc_rict_decode_test.py --nodes 20 --shots 4096 --encoding edges --ensemble 3 --compare-simulator -o rict_production.json
Production run on IBM Fez: 3 jobs merged, simulator baseline for ideal comparison.
| Metric | Value |
|---|---|
| Edge F1 | 41.84% |
| Edge precision | 28.57% |
| Edge recall | 75.93% |
| Element accuracy | 48.00% |
| Simulator F1 (ideal) | 43.30% |
| Backend | ibm_fez |
| Ensemble | 3 runs, 4096 shots each |
How the RICT encode–decode test fits with PQST-64, Crash Detection, and PRCBS.
PQST-64 shows polycontextural supremacy-style output (64Q, high uniqueness). QPC Crash Detection shows cascade detection on 128Q Torino. PRCBS (RICT, CPRP, PCRT) shows maximum diversity and entropy at 128Q–156Q on Torino and Fez. All three run successfully on real hardware.
This test answers: Can we get the structure back? PRCBS RICT shows that relational encoding produces 4096/4096 unique outcomes and high entropy. The encode–decode test shows that from those outcomes we can partially reconstruct the original graph (F1 ~42%, above random). So the full pipeline is validated: encode relational structure → run on Fez → decode structure from measurement. It is a direct proof that QPC relational encoding is not only complex but decodable on current hardware.
Removing the separate “verification” test (e.g. Transjunctions 130Q simulator) avoids mixing simulator-only checks with the three hardware-validated tests. The RICT encode–decode production test is the right addition: it runs on the same stack (Fez), uses the same PRCBS-style encoding, and demonstrates end-to-end relational decode. Together, PQST-64, Crash Detection, PRCBS, and RICT Encode–Decode give a consistent story: supremacy-style output, crash detection, maximum diversity, and recoverable relational structure.