QPC Boundaries Test Report

Main conclusion (read this first). The first strict “quality boundary” we demonstrated under a tighter engineering rule set (notably maximum compiled circuit depth) appears when the IBM-transpiled circuit becomes very deep—for example at Q=128, K=2, T=1, Cyc=9 the compiled depth reached 1922 layers, exceeding the chosen depth cap (1000), so the run is marked Quality FAIL even though the quantum job still returned full bitstring data (Exec PASS).

This is not evidence that QPC has reached its intrinsic theoretical limit. It is strong evidence of an IBM hardware / noise / depth barrier: real devices accumulate errors as circuits get longer. On a noise-free machine, the same abstract QPC program would not be limited in the same way by that physical error stack—though other practical limits (time, connectivity, shots) would still exist.

Therefore: because today’s quantum computers are noisy, the absolute outer limits of QPC’s computational capability cannot yet be pinned down precisely from hardware runs alone. What we can report is a measured operational envelope on IBM Fez plus a conservative strict gate that flags when the hardware is being pushed into a regime where structured quality is no longer trustworthy.

What this test measures (simple terms)

Each experiment is described by four numbers:

Q — number of qubits (circuit width).
K — contextures (how the qubits are partitioned into parallel “slices” in this benchmark circuit).
T — transjunction layers (cross-slice coupling depth per cycle).
Cyc — how many times the main block repeats (this grows circuit depth quickly).

After running on IBM Fez we label each point:

Exec PASS/FAIL — Did IBM return usable measurement counts?
Quality PASS/FAIL — Do successful runs pass agreed numeric checks (correlations, diversity of outcomes, dominance of one outcome, and—when using the strict profile—maximum compiled depth)?

Test steps (what we actually did)

Build the QPC-style boundary benchmark circuit for each (Q, K, T, Cyc).
Transpile for ibm_fez (IBM’s compiler maps logical gates to native gates; this produces the compiled depth and two-qubit gate counts).
Execute on IBM Quantum Runtime (Sampler), typically 1024 shots per point.
Extract bitstring statistics and compute diagnostics: mean pairwise correlation, uniqueness ratio, top outcome share, structure proxies, and a composite score.
Classify each point with Exec/Quality using the chosen threshold profile.
Campaign phases: qubit ladder (16→128) at minimal load (K=2, T=1, Cyc=1); contexture and transjunction sweeps at 32Q; deep cycle ladder at 128Q (Cyc 2–8); higher transjunction at 128Q (T=2,3,4); optional strict fail-hunt with a lower depth cap to locate the first conservative Quality FAIL.
Merge all JSON result files into one customer table (see repository scripts qpc_boundary_build_customer_report.py).

Backend and standard quality settings

Backend: IBM Quantum ibm_fez (pay-as-you-go instance in these runs).

Standard merged report thresholds (operational envelope): min_mean_pair_corr = 0.018, min_unique_ratio = 0.20, max_depth = 2200, max_top1_prob = 0.85, with correlation/top-1 floors scaled by Q to match the boundary script.

Strict profile (conservative engineering): same merge tool can re-run with e.g. min_mean_pair_corr = 0.03 and max_depth = 1000 to surface earlier FAILs that reflect depth/noise pressure.

Evidence: successful runs (QPC computational power)

The table below is the merged standard-envelope verdict over all saved boundary JSON runs. Every row shown here has Exec PASS and Quality PASS under the standard thresholds—this is direct evidence that QPC-style workloads execute end-to-end on IBM Fez across a wide range of complexity, including 128 qubits and demanding combinations of cycles and transjunction depth.

Table A — Merged results (standard thresholds)

Source: merged from project files qpc_boundary*.json → QPC_BOUNDARY_CUSTOMER_TABLE.csv (regenerate with python qpc_boundary_build_customer_report.py).

Q	K	T	Cyc	Exec	Quality	Mean corr	Uniq ratio	Top1	Depth	2Q gates	Job ID (representative)
16	2	1	1	PASS	PASS	0.0261	0.9922	0.0020	20	16	d71v53mqdfbc73d1fafg
16	2	2	1	PASS	PASS	0.0259	0.9912	0.0029	43	36	d71v16eqdfbc73d1f5ug
16	4	1	1	PASS	PASS	0.0236	0.9941	0.0020	62	48	d71v18mqdfbc73d1f61g
16	4	2	1	PASS	PASS	0.0270	0.9912	0.0020	73	60	d71v1auqdfbc73d1f640
32	2	1	1	PASS	PASS	0.0275	1.0000	0.0010	24	32	d723gp6qdfbc73d1lbg0
32	2	2	1	PASS	PASS	0.0244	1.0000	0.0010	102	115	d723h34scmvs73abe7tg
32	2	4	1	PASS	PASS	0.0246	1.0000	0.0010	102	110	d723h9eqdfbc73d1lc4g
32	4	1	1	PASS	PASS	0.0221	1.0000	0.0010	69	79	d7233iuqdfbc73d1kt60
32	8	1	1	PASS	PASS	0.0217	1.0000	0.0010	108	98	d723gspamkec73a0ndtg
48	2	1	1	PASS	PASS	0.0228	1.0000	0.0010	32	48	d723fomqdfbc73d1la70
64	2	1	1	PASS	PASS	0.0227	1.0000	0.0010	40	64	d72325eqdfbc73d1krj0
96	2	1	1	PASS	PASS	0.0274	1.0000	0.0010	56	96	d723m1hamkec73a0njbg
128	2	1	1	PASS	PASS	0.0243	1.0000	0.0010	527	476	d723ntev3u3c73ei4260
128	2	1	2	PASS	PASS	0.0271	1.0000	0.0010	515	1042	d723ok9amkec73a0nlu0
128	2	1	3	PASS	PASS	0.0209	1.0000	0.0010	802	1575	d723p64scmvs73abego0
128	2	1	4	PASS	PASS	0.0233	1.0000	0.0010	837	1961	d723ptmqdfbc73d1ll30
128	2	1	5	PASS	PASS	0.0278	1.0000	0.0010	715	2386	d723qppamkec73a0noa0
128	2	1	6	PASS	PASS	0.0288	1.0000	0.0010	1283	2844	d723ripamkec73a0np90
128	2	1	7	PASS	PASS	0.0335	1.0000	0.0010	1043	3032	d723t2cscmvs73abekt0
128	2	1	8	PASS	PASS	0.0288	1.0000	0.0010	1036	3607	d723umhamkec73a0nsi0
128	2	1	9	PASS	PASS	0.0285	1.0000	0.0010	1922	4503	d724aj9amkec73a0ob60
128	2	2	1	PASS	PASS	0.0337	1.0000	0.0010	410	457	d72416kscmvs73abepjg
128	2	3	1	PASS	PASS	0.0281	1.0000	0.0010	490	510	d7242gcscmvs73aber6g
128	2	4	1	PASS	PASS	0.0234	1.0000	0.0010	450	452	d72456ev3u3c73ei4gk0

Strict depth cap: where Quality FAIL first appears (IBM depth / noise story)

If we tighten the rules to max compiled depth = 1000 (and in the merged strict table also min mean correlation = 0.03, which mainly affects smaller‑Q rows), then several high‑depth 128Q cycle points become Quality FAIL even though IBM still returns data.

Takeaway: those FAIL lines are dominated by transpiled circuit depth—a practical proxy for “how long the state must survive on noisy hardware.” That is an IBM execution / noise barrier, not a certificate that QPC theory has reached its final edge.

Table B — 128Q cycle ladder under strict profile (excerpt)

Regenerated classification: qpc_boundary_build_customer_report.py --min-mean-pair-corr 0.03 --max-depth 1000 → QPC_BOUNDARY_CUSTOMER_TABLE_STRICT_FAILHUNT.csv

Q	K	T	Cyc	Exec	Quality (strict)	Depth	Quality note
128	2	1	1	PASS	PASS	527	—
128	2	1	2	PASS	PASS	515	—
128	2	1	3	PASS	PASS	802	—
128	2	1	4	PASS	PASS	837	—
128	2	1	5	PASS	PASS	715	—
128	2	1	6	PASS	FAIL	1283	depth > 1000
128	2	1	7	PASS	FAIL	1043	depth > 1000
128	2	1	8	PASS	FAIL	1036	depth > 1000
128	2	1	9	PASS	FAIL	1922	depth > 1000

Dedicated fail-hunt run file: qpc_boundary_push_128_cycles_failhunt.json (confirms Cyc=9 at depth 1922 under the same strict depth rule).

Final wording for customers (computational power of QPC)

1. Evidence of power. QPC workloads ran successfully on IBM Fez from small widths up to 128 qubits, including multi-cycle and multi-transjunction configurations, with Exec PASS and Quality PASS under the standard envelope (Table A).

2. Where “failure” appears first under conservative rules. When we intentionally tighten the depth ceiling, Quality FAIL appears as soon as the IBM-compiled circuit becomes too deep (Table B from Cyc=6 onward at 128Q in the strict merge). The hardware still returns outputs; the FAIL is a trust / quality statement, not “the computer returned nothing.”

3. Interpretation. That boundary is dominated by IBM hardware noise and compiled depth. It does not establish a final intrinsic ceiling of QPC as an architecture.

4. Honest bottom line. Until quantum hardware is far less noisy (or error-corrected at scale), the true outer limits of QPC’s computational capability cannot be fixed to a single number from Fez alone. What we can publish today is a strong demonstrated operating range plus a conservative safety line for when results should be treated as no longer reliable for structured QPC interpretation.

Reproducibility

Scripts in this release folder: qpc_boundary_stress_ibm_v2_fez_ready.py, qpc_boundary_build_customer_report.py, qpc_boundary_push_break_limits.sh. Output artifacts: QPC_BOUNDARY_CUSTOMER_TABLE.csv, QPC_BOUNDARY_CUSTOMER_SUMMARY.txt, and strict variants with the _STRICT_FAILHUNT suffix.

These boundary results are classified from raw Sampler counts using this campaign’s built-in diagnostics (correlation, uniqueness, depth, etc.); they do not use the separate QPC Universal Noise Reducer module. Other QPC workloads (e.g. the Crisis Task) do run through that optional post-processing pipeline—see QPC Noise Reducer — public report.