diff --git a/research/clifford-reversible-coefficient-readout/BRUHAT.md b/research/clifford-reversible-coefficient-readout/BRUHAT.md new file mode 100644 index 0000000000..b3ec65f259 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/BRUHAT.md @@ -0,0 +1,17 @@ +# Producing the factored input from a symplectic matrix + +The tape consumes a factorization $N=i^g M_L^* H_b^\sharp M_R$. Every four-qubit binary symplectic map admits this format. The accompanying classical compiler accepts eight columns, in low-$Z$, high-$X$ order, and optionally a particular $16\times16$ Gaussian-dyadic matrix. It prepares a record once; its work is separate from each reversible query. When only the binary action is supplied, the compiler chooses one deterministic gauge. Supplying the absolute matrix preserves its Pauli translation and scalar phase. + +Let $Z$ be the diagonal Pauli space and project $S Z$ to its upper four $X$ bits. Select a basis of this image of dimension $h$, keeping one lift $s_i$ of each selected basis vector. Extend the image basis to a basis of the full nibble. Let $A$ take this full basis to the standard basis. The symplectic basis change acts by $(z,x)\mapsto(A^{-T}z,Ax)$. In these coordinates $S Z$ contains precisely the diagonal directions $e_{h+1},\ldots,e_4$. The low $h$ components of the transformed $z_i$ for $s_i$ form the columns of a symmetric $h\times h$ matrix, by isotropy. Extend that matrix by zero on other axes to obtain $Q$. Adding $Qx$ to $z$ clears these $h$ diagonal components. Components beyond $h$ are already in the diagonal subspace and do not affect the resulting Lagrangian. + +Compose this shear after $A$ to obtain $P_L$. It takes $SZ$ to the coordinate Lagrangian generated by $X_1,\ldots,X_h,Z_{h+1},\ldots,Z_4$. The partial Hadamard $H_b$ in the first $h$ bits maps it to $Z$. Hence $P_R=H_bP_L S$ preserves $Z$. Such a map has the form +$$ + (z,x)\longmapsto (A_R^{-T}(z+C_Rx),A_Rx) +$$ +where $A_R$ is invertible, and $C_R$ is symmetric by the symplectic pairing. The monomial $M|v\rangle=i^{q(v)}|Av\rangle$ realizes this map when the coefficients of $v_i$ in $q$ have parity $C_{ii}$ and the coefficients of $v_iv_j$ are $2C_{ij}$ modulo four. For the left side the input-coordinate shear is $A^T Q A$. Consequently $M_L^* H_b^\sharp M_R$ induces exactly $S$. Here $H^\sharp=\frac{1+i}{2}\bigl(\begin{smallmatrix}1&1\\1&-1\end{smallmatrix}\bigr)$, so all lift entries and their denominators use Gaussian integers and powers of two. + +For a supplied absolute lift $U$, the quotient of $U$ by the constructed lift has trivial symplectic action. Its signs on the Weyl basis are a character of the binary Pauli label space, hence match a Pauli displacement by nondegeneracy of the pairing. After removing this displacement the operator commutes with all Weyls and is scalar. A scalar of modulus one in $\mathbb Z[i,1/2]$ is a power of $i$, by unique factorization or the sum-of-two-squares identity for powers of two. Thus $U=i^g X^xZ^z N$ for a unique $x,z,g$. The implementation tests exact entries after cross-multiplication by the supplied powers of two. It rejects a table with no match. It absorbs the displacement into the left monomial: in $M_L (X^xZ^z)^*$, the row permutation receives shift $Ax$, and the new phase polynomial is $q(v+x)+2z\cdot(v+x)$ with its constant removed. The conjugate of this constant phase enters $g$. The resulting input still allows the caller to choose an independent queried Pauli label. + +`bruhat.py request.json` accepts `symplectic` and optional `entries`, `denominator_bits`. Absolute entries are 256 pairs of signed integer numerators in **row-major** order. The output supplies `left`, `right`, `mask`, and `phase`; the tape query also needs `x`, `z`, `terms`, and `precision`. The absolute-table step tests at most $256\cdot4$ corrections and at most 256 entries per correction. In the named four-qubit model the only unbounded input here is integer precision. [Classical factorization](bruhat.py) + +The independent check recovers outgoing Pauli modulations from character signs and tests the binary identity on all 720 elements of an embedded two-qubit symplectic group. Fifty native four-qubit gate words cover the five possible Hadamard ranks, global units and Pauli corrections. Their 12,800 exact matrix entries were generated gate by gate and compared with the compiled absolute lift. [Verification](check_bruhat.py) diff --git a/research/clifford-reversible-coefficient-readout/PROOF.md b/research/clifford-reversible-coefficient-readout/PROOF.md new file mode 100644 index 0000000000..1903937912 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/PROOF.md @@ -0,0 +1,48 @@ +# From repeated matrix units to a clean canonical readout + +## Inputs, lift and target + +In the four-qubit dictionary of width 13, use the normalized columns $(\operatorname{vec}(W_pU)/4)^{\otimes13}$, where $W_p=X^xZ^z$. An observation is explicitly supplied as an $m$-record sum +$$y=\sum_{\nu=1}^m i^{t_\nu}\bigl(\operatorname{vec} |r_\nu\rangle\langle c_\nu|\bigr)^{\otimes13}.$$ +All rows, columns, Gaussian-unit weights and target fields are runtime inputs. Records may repeat and cancel. The output is the real and imaginary coefficient of $A^\dagger y$ for the queried label, each rounded to the nearest multiple of $2^{-p}$ with ties resolved to even. The circuit family is determined only by $m\ge1$ and $p\ge0$. + +A monomial Clifford field $M$ maps $|v\rangle$ to $i^{q_M(v)}|Av+u\rangle$ on four-bit vectors. The phase polynomial is +$$q_M(v)=\sum_{a=0}^3 l_a v_a+2\sum_{a0$ in such a route the two sweeps use exactly $2(d+1)$ CNOT gates, in addition to the central gate. The two tracks accommodate the maximum two controls. Head prices include travel between the two routes and between separate gates. The literal replay meters every elementary gate. A second metering method uses just the first and last anchors on each monotone sweep and agrees exactly. [Local lowering](physical.py) + +The conversion block uses the adjacent-site bit program from #7820, embedded at the end of the tape. For each lane, load the magnitude into the appropriate divisor input positions, run nearest-even division of the signed magnitude by $H$ to the requested precision, copy the rounded magnitude to the outputs, and reverse the divider and the load. Compute the output sign as the exact sign gated by a nonzero *rounded* magnitude and clean its work. After both lanes, erase the modulus and reverse the entire numerator program. Each step is a reversible gate sequence. Hence zero-initialized work is restored exactly, including all division remainders, sign flags and input copies, while the inputs and two signed outputs remain. The external CLI prints the stored magnitudes and signs as integers. No rational, nonlinear or random-access arithmetic operation is counted as a single physical gate. [Readout and resource meter](readout.py) · [Retained division gates](retained/divider.py) · [Divider proof](https://github.com/apoursh/integer-mult-bounds/blob/20a5532ea99b8ade78755486a6b92aa8071dc076/research/clifford-shared-denominator-tape/PROOF.md) + +For an exact per-size receipt the generator uses $s=\max(19-p,0)$, $n=\max(B,s+1)$, quotient length $q=n+p-19+1$ and $k=\operatorname{bitlength}(7852360022325)=43$. If $A$ logical bit addresses have been allocated in the producer, output and sign work together, the physical tape has $\lceil A/8\rceil+q+k+\max(s,1)+2$ sites. In four fixed qubits, the coordinate and phase circuits per record are bounded, each signed accumulator uses $O(B)$ gates per record, and the output sign calculation uses $O(q)$ gates and wires. Hence the sites $S$ are $O(m(1+\log m)+p+1)$. Local lowering needs at most $O(S)$ elementary gates and head moves per nonlocal gate. Together with four local divider traversals this gives $O(S^2)$ elementary gates and head moves. These are conservative upper bounds for this explicit layout. Runtime values never change its schedule; every input with the same $m,p$ has the same receipt. + +At $m=3,p=48$, the supplied nonidentity example has two active terms and one zero. The active terms are $(a,-a)$ and $(-a,-a)$ with $a=777583/257306133211545600$. Real parts cancel and the imaginary parts sum to $-777583/128653066605772800$. The exact final rounded integer is $-1701$ in the imaginary lane, while separate per-record rounding would give $-1702$ (check the signed values with the replay). The complete example uses 458 ten-track sites, 97,574 NOT, 849,046 CNOT and 171,478 Toffoli gates and 1,353,992 head moves. All inputs and every other bit are checked at the endpoint. [Local replay and negative control](check_local.py) · [Input](example.json) diff --git a/research/clifford-reversible-coefficient-readout/README.md b/research/clifford-reversible-coefficient-readout/README.md new file mode 100644 index 0000000000..6997e83de4 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/README.md @@ -0,0 +1,34 @@ +# A clean physical canonical-coefficient readout at width 13 + +Given an explicit list of repeated computational matrix units with Gaussian-unit weights and a runtime four-qubit Clifford/Pauli target, this circuit returns the real and imaginary parts of the full width-13 Moore–Penrose coefficient, rounded once to any prescribed binary precision. The routine computes the target matrix entry and phase, chooses its shell, accumulates the signed complex numerator and performs the terminal division. It preserves the inputs, clears the workspace and returns the head home. Every Clifford class is covered by the supplied absolute-factor interface. [Equations, gate construction and costs](PROOF.md) · [Optional normal-form compiler](BRUHAT.md) + +The least common component denominator for this observation family is **$H=7852360022325\cdot2^{19}$**. A single four-Hadamard coefficient attains that denominator in lowest terms. The proof also determines, at each target, the entire attainable Gaussian lattice and the fewest unit-weight records needed to realize each of its elements. The prior general inverse kernel has a different denominator. The observation interface here is a list of repeated matrix units and the numerical target is one named coefficient. [Arithmetic certificate](check_arithmetic.py) · [Upstream canonical weights](https://github.com/apoursh/integer-mult-bounds/blob/eead545a4ba6c50010fcac0919a9fdc6b14bd673/research/clifford-compact-adjoint-fibres/CANONICAL.md) + +A three-record example cancels in the real component. At 48 fractional bits the complex grid output is $(0,-1701)$; rounding individual terms first gives $(0,-1702)$. The end-to-end reversible calculation takes **458 ten-track sites** and **1,353,992 adjacent head moves**, including register cleanup and return to the input end. Its primitive gate invoice is 97,574 NOTs, 849,046 CNOTs and 171,478 Toffolis. These costs are uniform over all target and record fields at the stated list length and precision. [Published input](example.json) · [Literal elementary replay](check_local.py) + +## Input and replay + +From the repository root use Python 3.12 and the standard library. + +~~~sh +python3.12 -B scripts/research_package.py --package research/clifford-reversible-coefficient-readout +~~~ + +From the package directory run the following example. The CLI returns the signed integers in units of $2^{-\mathrm{precision}}$, the workspace size and the gate/motion invoice. Omitting the literal option executes equivalent reversible gates with the clean propagation routes metered by their lengths. + +~~~sh +python3.12 -B readout.py example.json --literal +~~~ + +Each request provides left and right monomials. Their four binary row masks, translation nibble, four coefficients modulo four, and six cross-term bits define affine basis maps with quadratic phases. The cross bits follow ordered pairs $(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)$. The four-bit mask chooses partial Gaussian Hadamards, the two-bit phase chooses a central Gaussian unit, and the two nibbles $x,z$ specify $X^xZ^z$. Each list item is $[r,c,t]$ for weight $i^t$ on a computational matrix unit repeated over 13 sites. The precision is a nonnegative integer. Register allocation assumes the labels have been supplied at the documented fixed-width input positions. Building the external observation or translating another target representation can have additional costs. [Machine-readable example](example.json) · [Input encoding and wire layout](readout.py) + +Four reproducible checks cover the rational scales and component lattice, exact complex sums against dense Gaussian matrices for all partial-Hadamard masks, actual elementary tape execution including modulus setup and output cleanup, and the constructive Bruhat compiler. Each checker also runs with optimized Python. [Dense oracle](check_values.py) · [Factorization check](check_bruhat.py) · [Registered commands](VERIFY.json) + +## Open next questions + +1. Can a moving-head compiler accept a symplectic matrix and its signed lift generators on tape, carry out the Bruhat reduction reversibly, and retain an interface of comparable cost for many queries? +2. For many named outputs, can the packet of returned coefficients share arithmetic and movement while preserving a clean output layout? Give a complete cost for an entire 256-label fibre and include placement of the outputs. + +## Attribution + +The five canonical weights and the repeated-site theorem are from apoursh's #7821, using the width-13 conditioning calculation by Ali Romman, with the Clifford and character work of alephnan and Nick Petalas. The local quotient and nearest-even gates are taken from apoursh's #7820. This extension derives the smaller exact denominator and record metric, supplies normal-form coverage and connects runtime target and observation labels to a clean local numerical readout. Prepared by apoursh with substantial OpenAI Codex assistance under Apache-2.0. The selected conditional multiplication exponent remains 0.00363005817. [Retained source hashes](SOURCE-PINS.json) · [Coordination claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19757301) diff --git a/research/clifford-reversible-coefficient-readout/SOURCE-PINS.json b/research/clifford-reversible-coefficient-readout/SOURCE-PINS.json new file mode 100644 index 0000000000..f3a0c06f64 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/SOURCE-PINS.json @@ -0,0 +1,18 @@ +[ + { + "local": "retained/divider.py", + "repository": "apoursh/integer-mult-bounds", + "commit": "20a5532ea99b8ade78755486a6b92aa8071dc076", + "path": "research/clifford-shared-denominator-tape/tape.py", + "git_blob": "2a48ea56711c95c3017ce141bb3ebd63b0a2b7b6", + "sha256": "f076bca638b27b1abe668563f5208315a1b5e6aeae5b31fe4bcb1ce9dbc2ed13" + }, + { + "local": "retained/width13-spectrum.json", + "repository": "aliromman/integer-mult-bounds", + "commit": "1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2", + "path": "research/clifford-threshold-conditioning/RESULT.json", + "git_blob": "039f22ba0bfec63c02fb3a97959766b8ec3a1bfa", + "sha256": "d032d5e63820f4ffe246d21adcd8d272f04dfd635a6fc519c4a81a366ca41d49" + } +] diff --git a/research/clifford-reversible-coefficient-readout/SOURCES.json b/research/clifford-reversible-coefficient-readout/SOURCES.json new file mode 100644 index 0000000000..cb446667a5 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/SOURCES.json @@ -0,0 +1,69 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ], + "cited_research": [ + { + "pr": 7772, + "head": "1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2", + "author": "aliromman", + "title": "Determine sharp four-qubit Clifford threshold conditioning", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7772" + }, + { + "pr": 7800, + "head": "fdc90699f4a64139ed6d84cdbf9a606ff0ccd32e", + "author": "apoursh", + "title": "Compile the width-13 Clifford decoder into 4,265 Bell reads and certify its dense input cost (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7800" + }, + { + "pr": 7805, + "head": "d3df403a13bee082a8cef62f190024aaf0cd08dd", + "author": "apoursh", + "title": "Determine the exact odd denominator of the canonical width-13 Clifford decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7805" + }, + { + "pr": 7809, + "head": "7efc2c67b32e305d20e484dc3afa9229ab119269", + "author": "apoursh", + "title": "Prove sharp 52- and 51-pass bounds for width-13 Clifford decoding", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7809" + }, + { + "pr": 7816, + "head": "7e7e62c62fcccd11f5c8e22677b4523863a48f4b", + "author": "apoursh", + "title": "Apply the width-13 Clifford Gram and its inverse to requested fibres", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7816" + }, + { + "pr": 7820, + "head": "20a5532ea99b8ade78755486a6b92aa8071dc076", + "author": "apoursh", + "title": "Price reversible shared odd division for canonical Clifford readouts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7820" + }, + { + "pr": 7821, + "head": "eead545a4ba6c50010fcac0919a9fdc6b14bd673", + "author": "apoursh", + "title": "Compute compact Clifford adjoints and canonical readouts on repeated stabilizer sites", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7821" + } + ] +} diff --git a/research/clifford-reversible-coefficient-readout/TASK.json b/research/clifford-reversible-coefficient-readout/TASK.json new file mode 100644 index 0000000000..f30b9708d9 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/TASK.json @@ -0,0 +1,93 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "selection_nonce": "a6c4b1c591522003ac523ca7ae993e92", + "scope_key": "cdee6027333168fe48af", + "scope_status": "changed", + "actual_scope": "Build a clean reversible nearest-neighbour producer and rounded readout for runtime queries of four-qubit width-13 canonical coefficients on a sum of repeated matrix units.", + "scope_change_reason": "The terminal divider accepts already-produced numerators and the recent mathematical readout supplies the canonical weights. The missing link was producing signed components from varying absolute Clifford and observation labels with all transport accounted.", + "bottleneck_link": "Connects a concrete numerator supplier to terminal rounding on a fully staged local tape, with an executable nonidentity cost and exact input interface.", + "stop_rule": "Check native matrix entries against runtime factorizations, prove complete symplectic/absolute lift coverage, regenerate the shared scalar table, and verify exact local gates, clean uncomputation, signed rounding and home-to-home movement.", + "outcome": "completed", + "evidence": "The package README, proof and registered verification commands describe the exact scope and controls.", + "author": "apoursh", + "ai_assistance": "Substantial OpenAI Codex assistance with mathematical derivation, verification and review.", + "open_questions": [ + { + "question": "Can the reversible readout exploit repeated structure across a batch of source and target labels?", + "why_it_matters": "The present accounting implements one requested target and a single signed sum per query, including preparation from the factored labels.", + "first_step": "Choose a compact producer that supplies multiple targets in an explicit order, then price shared preparation, output and cleanup.", + "blocked_by": "The supplied Bruhat data and unit-weight term interface must be replaced with an equally precise batch input contract." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19757301", + "overlap": "Read #1163, recent #1166 handoffs, active #7111 work and recent PRs; checked relevant all-state PR searches. The local overlap cache and sparse inventory have limited coverage. Compared recent #7819–#7821, the #1166 handoffs, the current #7111 research thread and all-state PR searches to the claimed scope.", + "upstream_refresh": { + "date_utc": "2026-11-19", + "canonical_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "selected_orientation": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "selected": "The selected result is #7000. The revision-8 catalogue refers to the earlier #5599.", + "before_submission": "Fetched canonical main again and checked the current work against the live PR queue." + } +} diff --git a/research/clifford-reversible-coefficient-readout/VERIFY.json b/research/clifford-reversible-coefficient-readout/VERIFY.json new file mode 100644 index 0000000000..954caea101 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/VERIFY.json @@ -0,0 +1,117 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_arithmetic.py" + ], + "timeout_seconds": 120, + "checks": "Recover all five weights from the published quotient spectrum, common denominator witness and exact record arithmetic" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_arithmetic.py" + ], + "timeout_seconds": 120, + "checks": "Recover all five weights from the published quotient spectrum, common denominator witness and exact record arithmetic under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_values.py" + ], + "timeout_seconds": 120, + "checks": "Compare the runtime label, phase and signed coefficient formulas with independent literal Gaussian matrices" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_values.py" + ], + "timeout_seconds": 120, + "checks": "Compare the runtime label, phase and signed coefficient formulas with independent literal Gaussian matrices under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_local.py" + ], + "timeout_seconds": 120, + "checks": "Local reversible gates, motion and cleanup on a nonidentity combined readout, with independent exact rounding" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_local.py" + ], + "timeout_seconds": 120, + "checks": "Local reversible gates, motion and cleanup on a nonidentity combined readout, with independent exact rounding under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_bruhat.py" + ], + "timeout_seconds": 120, + "checks": "Constructive symplectic factorization and absolute lift entry equality, including all 720 embedded two-qubit symplectic elements" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_bruhat.py" + ], + "timeout_seconds": 120, + "checks": "Constructive symplectic factorization and absolute lift entry equality, including all 720 embedded two-qubit symplectic elements under optimized Python" + } + ] +} diff --git a/research/clifford-reversible-coefficient-readout/bruhat.py b/research/clifford-reversible-coefficient-readout/bruhat.py new file mode 100644 index 0000000000..ef33da4358 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/bruhat.py @@ -0,0 +1,147 @@ +"""Convert a four-qubit binary symplectic map and optional absolute lift to the tape's normal form.""" +from itertools import combinations +import argparse +import json +from pathlib import Path + +PAIRS = tuple(combinations(range(4),2)) +BASIS = (1,2,4,8) + + +def columns_apply(columns, value): + result = 0 + for i,col in enumerate(columns): + if value & (1 << i): + result ^= col + return result + + +def parity(x): + return x.bit_count() & 1 + + +def pairing(v,w): + return parity(((v >> 4) & w & 15) ^ ((w >> 4) & v & 15)) + + +def transpose(columns): + return [sum(((v >> i) & 1) << j for j,v in enumerate(columns)) for i in range(4)] + + +def quadratic(data,v): + return (sum(a for i,a in enumerate(data["linear"]) if v & (1 << i)) + + 2*sum((data["cross"] >> k)&1 for k,(i,j) in enumerate(PAIRS) + if v&(1<>i)&1 for i,col in enumerate(form_columns)], + cross=sum(((form_columns[i]>>j)&1)<>4 + if x not in space: + basis.append(x) + chosen.append(s) + space |= {v^x for v in space} + h=len(chosen) + mask=(1<>4] + z = columns_apply(transpose(basis),p&15) ^ columns_apply(form,x) + swap = (x^z)&mask + return ((x^swap)<<4) | (z^swap) + # The right factor H_mask P_left S preserves Z. + right_columns=list(map(transform,sym)) + if any(col>>4 for col in right_columns[:4]): + raise ValueError("Lagrangian reduction") + matrix = [col>>4 for col in right_columns[4:]] + right=mono(matrix,[columns_apply(transpose(matrix),col&15) for col in right_columns[4:]]) + return dict(left=left,right=right,mask=mask,phase=0) + + +def rotate(pair,power): + a,b=pair + return ((a,b),(-b,a),(-a,-b),(b,-a))[power%4] + + +def entry_numerator(form,r,c): + """Absolute matrix element, with common denominator 2**popcount(mask).""" + left,right,mask=form["left"],form["right"],form["mask"] + a,b=linear(left,r)^left["shift"],linear(right,c)^right["shift"] + if (a^b)&~mask: + return (0,0) + amplitude=(1,0) + for _ in range(mask.bit_count()): + u,v=amplitude + amplitude=(u-v,u+v) + return rotate(amplitude,form["phase"]+quadratic(right,c)-quadratic(left,r)+2*parity(a&b&mask)) + + +def compile_lift(sym,entries=None,denominator_bits=0): + form=factor(sym) + if entries is None: + return form + if type(denominator_bits) is not int or denominator_bits<0 or len(entries)!=256 or any( + len(v)!=2 or any(type(a) is not int for a in v) for v in entries): + raise ValueError("Supply 256 Gaussian integer pairs in row-major order and a dyadic scale") + h=form["mask"].bit_count() + wanted=[(a<>4,p&15 + shear=sum((((m["linear"][i]&1)*((x>>i)&1))<>i)&1: + shear ^= (((x>>a)&1)<>b)&1)<>4)^r)&f["mask"] + need(project_mono(f["left"],s)==(r^swap^(swap<<4)),"Bruhat binary identity") + return f["mask"].bit_count() + + +def update_col(p,g): + op,i,j=g + x,z=p>>4,p&15 + if op=="H": + k=((x^z)>>i)&1 + x^=k<>j)&1)<>i)&1)<>i)&1 + for c in range(16): + value=mat[16*r+c] + if kind=="H": + a,b=mat[16*(r&~(1<>i&1: + exponent+=data['linear'][i] + for k,(i,j) in enumerate(combinations(range(4),2)): + if ((data['cross']>>k)&(column>>i)&(column>>j)&1): + exponent+=2 + return out,(1j)**(exponent%4) + + +def matrix(req): + """Expand every normalized Hadamard path on integer numerators; accumulate its phase.""" + cols=[] + for c in range(16): + mid,phase=mono_state(req['right'],c) + v=[0j]*16 + v[mid]=phase + for i in range(4): + if (req['mask']>>i)&1: + old=v + v=[(1+1j)*(old[r&~(1<>i&1 else 1)*old[r|(1<>i&1 else 1)*sum(((state[w]>>i)&1)<a else -1 + pairs = range(a,b,d) + if not back: + yield w,TRACKS*a+t + for k in reversed(pairs) if back else pairs: + yield TRACKS*k+t,TRACKS*(k+d)+t + if back: + yield w,TRACKS*a+t + + +def lower(gate): + routes,middle = segments(gate) + for route in routes: + yield from route_gates(route,False) + yield middle + for route in reversed(routes): + yield from route_gates(route,True) + + +class Meter: + def __init__(self): + self.gates = Counter() + self.moves = 0 + self.head = 0 + + def visit(self,first,last): + self.moves += abs(self.head-first)+abs(last-first) + self.head=last + + def local(self,g): + sites = [w//TRACKS for w in g] + if max(sites)-min(sites)>1 or len(set(g))!=len(g): + raise ValueError("Invalid local gate") + self.visit(min(sites),min(sites)) + self.gates[len(g)]+=1 + + def run_route(self,route,back): + _,a,b,_ = route + lo = a if a>j&1 else self.complement(b) for j,b in enumerate(bits)) + + def add(self,a,b,carry=0): + answer = [] + for left,right in zip(a,b,strict=True): + pair = self.xor(left,right) + answer.append(self.xor(pair,carry)) + if len(answer)>i&1)) + for i in range(bits+1)] + for record in I['terms']: + flags = term_flags(n,I,record,jbits,shell) + for lane,(pos,neg) in enumerate(flags): + live = n.xor(pos,neg) + operand = [n.xor(n.both(v,live),neg) for v in scale] + numer[lane] = n.add(numer[lane],operand,neg) + signs = [v[-1] for v in numer] + magnitudes = [n.add([n.xor(s,v) for v in vector[:-1]],[0]*bits,s) + for s,vector in zip(signs,numer,strict=True)] + return n,I,magnitudes,signs diff --git a/research/clifford-reversible-coefficient-readout/readout.py b/research/clifford-reversible-coefficient-readout/readout.py new file mode 100644 index 0000000000..4cd483d298 --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/readout.py @@ -0,0 +1,138 @@ +"""Clean nearest-neighbour readout of a width-13 complex canonical coefficient.""" +import argparse +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +sys.path[:0]=[str(HERE),str(HERE/'retained')] +from divider import Layout, program as divide +from physical import Meter, TRACKS, loc, lower +from producer import ODD, SHIFT, producer + + +def shape_mono(m): + if len(m['rows'])!=4 or len(m['linear'])!=4: + raise ValueError("Expected four binary rows and four phase coefficients") + images = {0} + for row in m['rows']: + images |= {v^row for v in images} + if len(images)!=16: + raise ValueError("The four affine-map rows must be independent") + + +def bind(registers,value,state): + if type(value) is not int or not 0<=value<1<>i & 1 + + +def encode(I,request,state): + for key in ('phase','mask','x','z'): + bind(I[key],request[key],state) + for key in ('left','right'): + m=request[key] + shape_mono(m) + for field in ('shift','cross'): + bind(I[key][field],m[field],state) + for field in ('rows','linear'): + for regs,val in zip(I[key][field],m[field],strict=True): + bind(regs,val,state) + for registers,values in zip(I['terms'],request['terms'],strict=True): + for regs,val in zip(registers,values,strict=True): + bind(regs,val,state) + + +def mapped(gates): + return [tuple(map(loc,g)) for g in gates] + + +class Plan: + def __init__(self,m,precision): + net,self.input,mags,signs=producer(m,precision) + self.prepare=mapped(net.gates) + magbits=len(mags[0]) + padded=max(magbits,SHIFT-precision+1) + div=Layout(padded,ODD.bit_length(),SHIFT,precision) + self.result=[(net.wires(div.m),net.wires(1)[0]) for _ in range(2)] + self.sign_ops=[] + for (digits,sign_out),negative in zip(self.result,signs,strict=True): + start=len(net.gates) + nz=net.complement(net.every([net.complement(d) for d in digits])) + flag=net.both(nz,negative) + gates=mapped(net.gates[start:]) + self.sign_ops.append(gates+[(loc(flag),loc(sign_out))]+gates[::-1]) + self.base=(net.size+7)//8 + self.sites=self.base+div.sites + def dw(site,track=0): + return TRACKS*(self.base+site)+track + self.modulus=[(dw(div.k-i,1),) for i in range(div.k) if ODD>>i&1] + self.division=[tuple(dw(v//8,v%8) for v in g) for g in divide(div)] + self.loads=[[(loc(w),dw(div.k+div.bits-i)) for i,w in enumerate(mag)] for mag in mags] + self.copies=[[(dw(div.m-1-i),loc(w)) for i,w in enumerate(regs)] for regs,_ in self.result] + self.numerator=mags,signs + self.precision=precision + + def operations(self): + yield from self.prepare + yield from self.modulus + for load,copy,sign in zip(self.loads,self.copies,self.sign_ops,strict=True): + yield from load + yield from self.division + yield from copy + yield from reversed(self.division) + yield from reversed(load) + yield from sign + yield from reversed(self.modulus) + yield from reversed(self.prepare) + + +def toggle(g,state): + value=1 + for w in g[:-1]: + value &= state[w] + state[g[-1]] ^= value + + +def raw_read(bits,state): + return sum(state[loc(b)]< max(e-p,0)") + + @property + def s(self): + return max(self.e-self.p,0) + + @property + def m(self): + return self.bits+self.p-self.e+1 + + @property + def sites(self): + return self.m+self.k+max(self.s,1)+2 + + +def program(layout, nearest=True): + for i in range(layout.m): + yield from step(i,layout.k) + if nearest: + yield from rounded(layout.m,layout.k,layout.s) + # Return the supplied modulus to its original site positions. + for lo in range(layout.m-1,-1,-1): + for j in range(lo,lo+layout.k+1): + yield from swap(wire(j,D),wire(j+1,D)) + + +def word(value,width): + if not 0 <= value < 1 << width: + raise ValueError("value does not fit") + return [(value >> i)&1 for i in reversed(range(width))] + + +def initial(layout, divisor, numerator): + if divisor%2 != 1 or divisor.bit_length()!=layout.k: + raise ValueError("expected a positive odd modulus of the declared length") + state = [0]*(8*layout.sites) + for i, b in enumerate(word(divisor,layout.k),1): + state[wire(i,D)] = b + for i, b in enumerate(word(numerator,layout.bits),layout.k+1): + state[wire(i,X)] = b + return state + + +def read(state,start,length,track): + value = 0 + for i in range(start,start+length): + value = 2*value+state[wire(i,track)] + return value + + +def run(gates,state): + head = 0 + counts = Counter() + for gate in gates: + sites = [w//8 for w in gate] + anchor = min(sites) + if max(sites)>anchor+1 or len(set(gate))!=len(gate) or min(gate)<0: + raise ValueError("gate locality or alias") + counts["moves"] += abs(head-anchor) + head = anchor + a = gate[-1] + if len(gate)==1: + state[a] ^= 1 + elif len(gate)==2: + state[a] ^= state[gate[0]] + elif len(gate)==3: + state[a] ^= state[gate[0]] & state[gate[1]] + else: + raise ValueError("unknown gate") + counts[len(gate)] += 1 + counts["moves"] += head + return counts diff --git a/research/clifford-reversible-coefficient-readout/retained/width13-spectrum.json b/research/clifford-reversible-coefficient-readout/retained/width13-spectrum.json new file mode 100644 index 0000000000..039f22ba0b --- /dev/null +++ b/research/clifford-reversible-coefficient-readout/retained/width13-spectrum.json @@ -0,0 +1,1519 @@ +{ + "source_files": 18, + "projective_order": 12128668876800, + "width": 13, + "rows": [ + { + "row": 1, + "quotient_degree": 1, + "multiplicity": 651, + "clifford_degree": 16, + "regular_dimension": 256, + "eigenvalue": [ + 470624175, + 4294967296 + ] + }, + { + "row": 2, + "quotient_degree": 35, + "multiplicity": 1518660, + "clifford_degree": 560, + "regular_dimension": 313600, + "eigenvalue": [ + 7841980575, + 1073741824 + ] + }, + { + "row": 3, + "quotient_degree": 51, + "multiplicity": 1611753, + "clifford_degree": 816, + "regular_dimension": 665856, + "eigenvalue": [ + 22846598775, + 4294967296 + ] + }, + { + "row": 4, + "quotient_degree": 85, + "multiplicity": 3148145, + "clifford_degree": 1360, + "regular_dimension": 1849600, + "eigenvalue": [ + 26774973225, + 4294967296 + ] + }, + { + "row": 5, + "quotient_degree": 119, + "multiplicity": 118482, + "clifford_degree": 1904, + "regular_dimension": 3625216, + "eigenvalue": [ + 359889075, + 2147483648 + ] + }, + { + "row": 6, + "quotient_degree": 135, + "multiplicity": 211575, + "clifford_degree": 2160, + "regular_dimension": 4665600, + "eigenvalue": [ + 1132984125, + 4294967296 + ] + }, + { + "row": 7, + "quotient_degree": 238, + "multiplicity": 5425992, + "clifford_degree": 3808, + "regular_dimension": 14500864, + "eigenvalue": [ + 4120362675, + 1073741824 + ] + }, + { + "row": 8, + "quotient_degree": 510, + "multiplicity": 620620, + "clifford_degree": 8160, + "regular_dimension": 66585600, + "eigenvalue": [ + 439864425, + 2147483648 + ] + }, + { + "row": 9, + "quotient_degree": 595, + "multiplicity": 620620, + "clifford_degree": 9520, + "regular_dimension": 90630400, + "eigenvalue": [ + 188513325, + 1073741824 + ] + }, + { + "row": 10, + "quotient_degree": 595, + "multiplicity": 2637635, + "clifford_degree": 9520, + "regular_dimension": 90630400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 11, + "quotient_degree": 918, + "multiplicity": 9570847, + "clifford_degree": 14688, + "regular_dimension": 215737344, + "eigenvalue": [ + 15074084025, + 8589934592 + ] + }, + { + "row": 12, + "quotient_degree": 1190, + "multiplicity": 4765475, + "clifford_degree": 19040, + "regular_dimension": 362521600, + "eigenvalue": [ + 5790052125, + 8589934592 + ] + }, + { + "row": 13, + "quotient_degree": 1275, + "multiplicity": 4765475, + "clifford_degree": 20400, + "regular_dimension": 416160000, + "eigenvalue": [ + 2702024325, + 4294967296 + ] + }, + { + "row": 14, + "quotient_degree": 1512, + "multiplicity": 28353468, + "clifford_degree": 24192, + "regular_dimension": 585252864, + "eigenvalue": [ + 27113003775, + 8589934592 + ] + }, + { + "row": 15, + "quotient_degree": 1785, + "multiplicity": 22608300, + "clifford_degree": 28560, + "regular_dimension": 815673600, + "eigenvalue": [ + 2289090375, + 1073741824 + ] + }, + { + "row": 16, + "quotient_degree": 1785, + "multiplicity": 3878875, + "clifford_degree": 28560, + "regular_dimension": 815673600, + "eigenvalue": [ + 1570944375, + 4294967296 + ] + }, + { + "row": 17, + "quotient_degree": 2295, + "multiplicity": 38434110, + "clifford_degree": 36720, + "regular_dimension": 1348358400, + "eigenvalue": [ + 6053372325, + 2147483648 + ] + }, + { + "row": 18, + "quotient_degree": 2856, + "multiplicity": 4592588, + "clifford_degree": 45696, + "regular_dimension": 2088124416, + "eigenvalue": [ + 2324997675, + 8589934592 + ] + }, + { + "row": 19, + "quotient_degree": 2856, + "multiplicity": 36173280, + "clifford_degree": 45696, + "regular_dimension": 2088124416, + "eigenvalue": [ + 2289090375, + 1073741824 + ] + }, + { + "row": 20, + "quotient_degree": 2975, + "multiplicity": 28260375, + "clifford_degree": 47600, + "regular_dimension": 2265760000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 21, + "quotient_degree": 2975, + "multiplicity": 42578965, + "clifford_degree": 47600, + "regular_dimension": 2265760000, + "eigenvalue": [ + 10346688495, + 4294967296 + ] + }, + { + "row": 22, + "quotient_degree": 3213, + "multiplicity": 6330324, + "clifford_degree": 51408, + "regular_dimension": 2642782464, + "eigenvalue": [ + 356080725, + 1073741824 + ] + }, + { + "row": 23, + "quotient_degree": 3213, + "multiplicity": 49512177, + "clifford_degree": 51408, + "regular_dimension": 2642782464, + "eigenvalue": [ + 11140239825, + 4294967296 + ] + }, + { + "row": 24, + "quotient_degree": 3400, + "multiplicity": 7757750, + "clifford_degree": 54400, + "regular_dimension": 2959360000, + "eigenvalue": [ + 6597966375, + 17179869184 + ] + }, + { + "row": 25, + "quotient_degree": 3570, + "multiplicity": 15825810, + "clifford_degree": 57120, + "regular_dimension": 3262694400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 26, + "quotient_degree": 3570, + "multiplicity": 7757750, + "clifford_degree": 57120, + "regular_dimension": 3262694400, + "eigenvalue": [ + 1570944375, + 4294967296 + ] + }, + { + "row": 27, + "quotient_degree": 3570, + "multiplicity": 45216600, + "clifford_degree": 57120, + "regular_dimension": 3262694400, + "eigenvalue": [ + 2289090375, + 1073741824 + ] + }, + { + "row": 28, + "quotient_degree": 3808, + "multiplicity": 42503604, + "clifford_degree": 60928, + "regular_dimension": 3712221184, + "eigenvalue": [ + 64552348575, + 34359738368 + ] + }, + { + "row": 29, + "quotient_degree": 4200, + "multiplicity": 12412400, + "clifford_degree": 67200, + "regular_dimension": 4515840000, + "eigenvalue": [ + 1068242175, + 2147483648 + ] + }, + { + "row": 30, + "quotient_degree": 4760, + "multiplicity": 10550540, + "clifford_degree": 76160, + "regular_dimension": 5800345600, + "eigenvalue": [ + 3204726525, + 8589934592 + ] + }, + { + "row": 31, + "quotient_degree": 5712, + "multiplicity": 29089346, + "clifford_degree": 91392, + "regular_dimension": 8352497664, + "eigenvalue": [ + 29452962825, + 34359738368 + ] + }, + { + "row": 32, + "quotient_degree": 5950, + "multiplicity": 56520750, + "clifford_degree": 95200, + "regular_dimension": 9063040000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 33, + "quotient_degree": 5950, + "multiplicity": 39564525, + "clifford_degree": 95200, + "regular_dimension": 9063040000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 34, + "quotient_degree": 7140, + "multiplicity": 51622285, + "clifford_degree": 114240, + "regular_dimension": 13050777600, + "eigenvalue": [ + 20907025425, + 17179869184 + ] + }, + { + "row": 35, + "quotient_degree": 8160, + "multiplicity": 67824900, + "clifford_degree": 130560, + "regular_dimension": 17045913600, + "eigenvalue": [ + 48070897875, + 34359738368 + ] + }, + { + "row": 36, + "quotient_degree": 8925, + "multiplicity": 26376350, + "clifford_degree": 142800, + "regular_dimension": 20391840000, + "eigenvalue": [ + 1068242175, + 2147483648 + ] + }, + { + "row": 37, + "quotient_degree": 8925, + "multiplicity": 62172825, + "clifford_degree": 142800, + "regular_dimension": 20391840000, + "eigenvalue": [ + 5035998825, + 4294967296 + ] + }, + { + "row": 38, + "quotient_degree": 8960, + "multiplicity": 106392000, + "clifford_degree": 143360, + "regular_dimension": 20552089600, + "eigenvalue": [ + 34336355625, + 17179869184 + ] + }, + { + "row": 39, + "quotient_degree": 9639, + "multiplicity": 42729687, + "clifford_degree": 154224, + "regular_dimension": 23785042176, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 40, + "quotient_degree": 10200, + "multiplicity": 113041500, + "clifford_degree": 163200, + "regular_dimension": 26634240000, + "eigenvalue": [ + 16023632625, + 8589934592 + ] + }, + { + "row": 41, + "quotient_degree": 11900, + "multiplicity": 52752700, + "clifford_degree": 190400, + "regular_dimension": 36252160000, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 42, + "quotient_degree": 11900, + "multiplicity": 79129050, + "clifford_degree": 190400, + "regular_dimension": 36252160000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 43, + "quotient_degree": 13056, + "multiplicity": 33761728, + "clifford_degree": 208896, + "regular_dimension": 43637538816, + "eigenvalue": [ + 7477695225, + 17179869184 + ] + }, + { + "row": 44, + "quotient_degree": 13600, + "multiplicity": 82897100, + "clifford_degree": 217600, + "regular_dimension": 47349760000, + "eigenvalue": [ + 35251991775, + 34359738368 + ] + }, + { + "row": 45, + "quotient_degree": 14280, + "multiplicity": 63303240, + "clifford_degree": 228480, + "regular_dimension": 52203110400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 46, + "quotient_degree": 14280, + "multiplicity": 137910630, + "clifford_degree": 228480, + "regular_dimension": 52203110400, + "eigenvalue": [ + 27926902575, + 17179869184 + ] + }, + { + "row": 47, + "quotient_degree": 14688, + "multiplicity": 48532484, + "clifford_degree": 235008, + "regular_dimension": 55228760064, + "eigenvalue": [ + 19109665575, + 34359738368 + ] + }, + { + "row": 48, + "quotient_degree": 16065, + "multiplicity": 55390335, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 2492565075, + 4294967296 + ] + }, + { + "row": 49, + "quotient_degree": 16065, + "multiplicity": 65940875, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 2967339375, + 4294967296 + ] + }, + { + "row": 50, + "quotient_degree": 16065, + "multiplicity": 87041955, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 3916887975, + 4294967296 + ] + }, + { + "row": 51, + "quotient_degree": 16065, + "multiplicity": 169562250, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 3815150625, + 2147483648 + ] + }, + { + "row": 52, + "quotient_degree": 16065, + "multiplicity": 118693575, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 53, + "quotient_degree": 17850, + "multiplicity": 52752700, + "clifford_degree": 285600, + "regular_dimension": 81567360000, + "eigenvalue": [ + 1068242175, + 2147483648 + ] + }, + { + "row": 54, + "quotient_degree": 17850, + "multiplicity": 124345650, + "clifford_degree": 285600, + "regular_dimension": 81567360000, + "eigenvalue": [ + 5035998825, + 4294967296 + ] + }, + { + "row": 55, + "quotient_degree": 18360, + "multiplicity": 93447640, + "clifford_degree": 293760, + "regular_dimension": 86294937600, + "eigenvalue": [ + 3679500825, + 4294967296 + ] + }, + { + "row": 56, + "quotient_degree": 19040, + "multiplicity": 73853780, + "clifford_degree": 304640, + "regular_dimension": 92805529600, + "eigenvalue": [ + 22433085675, + 34359738368 + ] + }, + { + "row": 57, + "quotient_degree": 23800, + "multiplicity": 195938600, + "clifford_degree": 380800, + "regular_dimension": 145008640000, + "eigenvalue": [ + 5951634975, + 4294967296 + ] + }, + { + "row": 58, + "quotient_degree": 23800, + "multiplicity": 226083000, + "clifford_degree": 380800, + "regular_dimension": 145008640000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 59, + "quotient_degree": 26775, + "multiplicity": 254343375, + "clifford_degree": 428400, + "regular_dimension": 183526560000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 60, + "quotient_degree": 26775, + "multiplicity": 118693575, + "clifford_degree": 428400, + "regular_dimension": 183526560000, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 61, + "quotient_degree": 28560, + "multiplicity": 158258100, + "clifford_degree": 456960, + "regular_dimension": 208812441600, + "eigenvalue": [ + 16023632625, + 17179869184 + ] + }, + { + "row": 62, + "quotient_degree": 28917, + "multiplicity": 250273881, + "clifford_degree": 462672, + "regular_dimension": 214065379584, + "eigenvalue": [ + 6256847025, + 4294967296 + ] + }, + { + "row": 63, + "quotient_degree": 30464, + "multiplicity": 231508992, + "clifford_degree": 487424, + "regular_dimension": 237582155776, + "eigenvalue": [ + 1373454225, + 1073741824 + ] + }, + { + "row": 64, + "quotient_degree": 32130, + "multiplicity": 131881750, + "clifford_degree": 514080, + "regular_dimension": 264278246400, + "eigenvalue": [ + 2967339375, + 4294967296 + ] + }, + { + "row": 65, + "quotient_degree": 32130, + "multiplicity": 166171005, + "clifford_degree": 514080, + "regular_dimension": 264278246400, + "eigenvalue": [ + 7477695225, + 8589934592 + ] + }, + { + "row": 66, + "quotient_degree": 32130, + "multiplicity": 237387150, + "clifford_degree": 514080, + "regular_dimension": 264278246400, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 67, + "quotient_degree": 34425, + "multiplicity": 118693575, + "clifford_degree": 550800, + "regular_dimension": 303380640000, + "eigenvalue": [ + 2492565075, + 4294967296 + ] + }, + { + "row": 68, + "quotient_degree": 34425, + "multiplicity": 254343375, + "clifford_degree": 550800, + "regular_dimension": 303380640000, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 69, + "quotient_degree": 34560, + "multiplicity": 158878720, + "clifford_degree": 552960, + "regular_dimension": 305764761600, + "eigenvalue": [ + 830855025, + 1073741824 + ] + }, + { + "row": 70, + "quotient_degree": 38080, + "multiplicity": 168808640, + "clifford_degree": 609280, + "regular_dimension": 371222118400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 71, + "quotient_degree": 38556, + "multiplicity": 170918748, + "clifford_degree": 616896, + "regular_dimension": 380560674816, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 72, + "quotient_degree": 42525, + "multiplicity": 314188875, + "clifford_degree": 680400, + "regular_dimension": 462944160000, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 73, + "quotient_degree": 42525, + "multiplicity": 314188875, + "clifford_degree": 680400, + "regular_dimension": 462944160000, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 74, + "quotient_degree": 43520, + "multiplicity": 265270720, + "clifford_degree": 696320, + "regular_dimension": 484861542400, + "eigenvalue": [ + 35251991775, + 34359738368 + ] + }, + { + "row": 75, + "quotient_degree": 47600, + "multiplicity": 316516200, + "clifford_degree": 761600, + "regular_dimension": 580034560000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 76, + "quotient_degree": 48195, + "multiplicity": 213648435, + "clifford_degree": 771120, + "regular_dimension": 594626054400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 77, + "quotient_degree": 51408, + "multiplicity": 322846524, + "clifford_degree": 822528, + "regular_dimension": 676552310784, + "eigenvalue": [ + 18160116975, + 17179869184 + ] + }, + { + "row": 78, + "quotient_degree": 53550, + "multiplicity": 356080725, + "clifford_degree": 856800, + "regular_dimension": 734106240000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 79, + "quotient_degree": 57120, + "multiplicity": 316516200, + "clifford_degree": 913920, + "regular_dimension": 835249766400, + "eigenvalue": [ + 16023632625, + 17179869184 + ] + }, + { + "row": 80, + "quotient_degree": 65536, + "multiplicity": 381308928, + "clifford_degree": 1048576, + "regular_dimension": 1099511627776, + "eigenvalue": [ + 67299257025, + 68719476736 + ] + }, + { + "row": 81, + "quotient_degree": 68850, + "multiplicity": 356080725, + "clifford_degree": 1101600, + "regular_dimension": 1213522560000, + "eigenvalue": [ + 7477695225, + 8589934592 + ] + } + ], + "distinct_levels": [ + { + "eigenvalue": [ + 470624175, + 4294967296 + ], + "rows": [ + 1 + ], + "eigenspace_dimension": 256 + }, + { + "eigenvalue": [ + 359889075, + 2147483648 + ], + "rows": [ + 5 + ], + "eigenspace_dimension": 3625216 + }, + { + "eigenvalue": [ + 188513325, + 1073741824 + ], + "rows": [ + 9 + ], + "eigenspace_dimension": 90630400 + }, + { + "eigenvalue": [ + 439864425, + 2147483648 + ], + "rows": [ + 8 + ], + "eigenspace_dimension": 66585600 + }, + { + "eigenvalue": [ + 1132984125, + 4294967296 + ], + "rows": [ + 6 + ], + "eigenspace_dimension": 4665600 + }, + { + "eigenvalue": [ + 2324997675, + 8589934592 + ], + "rows": [ + 18 + ], + "eigenspace_dimension": 2088124416 + }, + { + "eigenvalue": [ + 356080725, + 1073741824 + ], + "rows": [ + 22 + ], + "eigenspace_dimension": 2642782464 + }, + { + "eigenvalue": [ + 1570944375, + 4294967296 + ], + "rows": [ + 16, + 26 + ], + "eigenspace_dimension": 4078368000 + }, + { + "eigenvalue": [ + 3204726525, + 8589934592 + ], + "rows": [ + 30 + ], + "eigenspace_dimension": 5800345600 + }, + { + "eigenvalue": [ + 6597966375, + 17179869184 + ], + "rows": [ + 24 + ], + "eigenspace_dimension": 2959360000 + }, + { + "eigenvalue": [ + 7477695225, + 17179869184 + ], + "rows": [ + 43 + ], + "eigenspace_dimension": 43637538816 + }, + { + "eigenvalue": [ + 1068242175, + 2147483648 + ], + "rows": [ + 29, + 36, + 53 + ], + "eigenspace_dimension": 106475040000 + }, + { + "eigenvalue": [ + 19109665575, + 34359738368 + ], + "rows": [ + 47 + ], + "eigenspace_dimension": 55228760064 + }, + { + "eigenvalue": [ + 2492565075, + 4294967296 + ], + "rows": [ + 48, + 67 + ], + "eigenspace_dimension": 369450201600 + }, + { + "eigenvalue": [ + 2702024325, + 4294967296 + ], + "rows": [ + 13 + ], + "eigenspace_dimension": 416160000 + }, + { + "eigenvalue": [ + 22433085675, + 34359738368 + ], + "rows": [ + 56 + ], + "eigenspace_dimension": 92805529600 + }, + { + "eigenvalue": [ + 5790052125, + 8589934592 + ], + "rows": [ + 12 + ], + "eigenspace_dimension": 362521600 + }, + { + "eigenvalue": [ + 2967339375, + 4294967296 + ], + "rows": [ + 49, + 64 + ], + "eigenspace_dimension": 330347808000 + }, + { + "eigenvalue": [ + 3204726525, + 4294967296 + ], + "rows": [ + 10, + 25, + 39, + 41, + 45, + 60, + 70, + 71, + 76 + ], + "eigenspace_dimension": 1645529044992 + }, + { + "eigenvalue": [ + 830855025, + 1073741824 + ], + "rows": [ + 69 + ], + "eigenspace_dimension": 305764761600 + }, + { + "eigenvalue": [ + 3679500825, + 4294967296 + ], + "rows": [ + 55 + ], + "eigenspace_dimension": 86294937600 + }, + { + "eigenvalue": [ + 29452962825, + 34359738368 + ], + "rows": [ + 31 + ], + "eigenspace_dimension": 8352497664 + }, + { + "eigenvalue": [ + 7477695225, + 8589934592 + ], + "rows": [ + 65, + 81 + ], + "eigenspace_dimension": 1477800806400 + }, + { + "eigenvalue": [ + 3916887975, + 4294967296 + ], + "rows": [ + 50 + ], + "eigenspace_dimension": 66069561600 + }, + { + "eigenvalue": [ + 16023632625, + 17179869184 + ], + "rows": [ + 61, + 79 + ], + "eigenspace_dimension": 1044062208000 + }, + { + "eigenvalue": [ + 67299257025, + 68719476736 + ], + "rows": [ + 80 + ], + "eigenspace_dimension": 1099511627776 + }, + { + "eigenvalue": [ + 35251991775, + 34359738368 + ], + "rows": [ + 44, + 74 + ], + "eigenspace_dimension": 532211302400 + }, + { + "eigenvalue": [ + 18160116975, + 17179869184 + ], + "rows": [ + 77 + ], + "eigenspace_dimension": 676552310784 + }, + { + "eigenvalue": [ + 9614179575, + 8589934592 + ], + "rows": [ + 33, + 42, + 75, + 78 + ], + "eigenspace_dimension": 1359456000000 + }, + { + "eigenvalue": [ + 5035998825, + 4294967296 + ], + "rows": [ + 37, + 54 + ], + "eigenspace_dimension": 101959200000 + }, + { + "eigenvalue": [ + 20907025425, + 17179869184 + ], + "rows": [ + 34 + ], + "eigenspace_dimension": 13050777600 + }, + { + "eigenvalue": [ + 5341210875, + 4294967296 + ], + "rows": [ + 52, + 66, + 68, + 72, + 73 + ], + "eigenspace_dimension": 1559616768000 + }, + { + "eigenvalue": [ + 1373454225, + 1073741824 + ], + "rows": [ + 63 + ], + "eigenspace_dimension": 237582155776 + }, + { + "eigenvalue": [ + 5951634975, + 4294967296 + ], + "rows": [ + 57 + ], + "eigenspace_dimension": 145008640000 + }, + { + "eigenvalue": [ + 48070897875, + 34359738368 + ], + "rows": [ + 35 + ], + "eigenspace_dimension": 17045913600 + }, + { + "eigenvalue": [ + 6256847025, + 4294967296 + ], + "rows": [ + 62 + ], + "eigenspace_dimension": 214065379584 + }, + { + "eigenvalue": [ + 6867271125, + 4294967296 + ], + "rows": [ + 20, + 32, + 58, + 59 + ], + "eigenspace_dimension": 339864000000 + }, + { + "eigenvalue": [ + 27926902575, + 17179869184 + ], + "rows": [ + 46 + ], + "eigenspace_dimension": 52203110400 + }, + { + "eigenvalue": [ + 15074084025, + 8589934592 + ], + "rows": [ + 11 + ], + "eigenspace_dimension": 215737344 + }, + { + "eigenvalue": [ + 3815150625, + 2147483648 + ], + "rows": [ + 51 + ], + "eigenspace_dimension": 66069561600 + }, + { + "eigenvalue": [ + 16023632625, + 8589934592 + ], + "rows": [ + 40 + ], + "eigenspace_dimension": 26634240000 + }, + { + "eigenvalue": [ + 64552348575, + 34359738368 + ], + "rows": [ + 28 + ], + "eigenspace_dimension": 3712221184 + }, + { + "eigenvalue": [ + 34336355625, + 17179869184 + ], + "rows": [ + 38 + ], + "eigenspace_dimension": 20552089600 + }, + { + "eigenvalue": [ + 2289090375, + 1073741824 + ], + "rows": [ + 15, + 19, + 27 + ], + "eigenspace_dimension": 6166492416 + }, + { + "eigenvalue": [ + 10346688495, + 4294967296 + ], + "rows": [ + 21 + ], + "eigenspace_dimension": 2265760000 + }, + { + "eigenvalue": [ + 11140239825, + 4294967296 + ], + "rows": [ + 23 + ], + "eigenspace_dimension": 2642782464 + }, + { + "eigenvalue": [ + 6053372325, + 2147483648 + ], + "rows": [ + 17 + ], + "eigenspace_dimension": 1348358400 + }, + { + "eigenvalue": [ + 27113003775, + 8589934592 + ], + "rows": [ + 14 + ], + "eigenspace_dimension": 585252864 + }, + { + "eigenvalue": [ + 4120362675, + 1073741824 + ], + "rows": [ + 7 + ], + "eigenspace_dimension": 14500864 + }, + { + "eigenvalue": [ + 22846598775, + 4294967296 + ], + "rows": [ + 3 + ], + "eigenspace_dimension": 665856 + }, + { + "eigenvalue": [ + 26774973225, + 4294967296 + ], + "rows": [ + 4 + ], + "eigenspace_dimension": 1849600 + }, + { + "eigenvalue": [ + 7841980575, + 1073741824 + ], + "rows": [ + 2 + ], + "eigenspace_dimension": 313600 + } + ], + "minimum": [ + 470624175, + 4294967296 + ], + "maximum": [ + 7841980575, + 1073741824 + ], + "minimum_dimension": 256, + "maximum_dimension": 313600, + "gram_condition": [ + 101244, + 1519 + ], + "inverse_squared_norm": [ + 4294967296, + 470624175 + ], + "second_moment": [ + 930080652310818734947227759375, + 72057594037927936 + ], + "one_qubit_calibration": { + "projective_elements": 24, + "closure_products": 576, + "quotient_character_counts": [ + [ + -64, + 12 + ], + [ + 1, + 8 + ], + [ + 4096, + 4 + ] + ], + "multiplicities": [ + 651, + 715, + 1365 + ], + "eigenvalues": [ + [ + 1953, + 2048 + ], + [ + 2145, + 2048 + ], + [ + 4095, + 4096 + ] + ], + "eigenspace_dimensions": [ + 4, + 4, + 16 + ], + "gram_second_moment": [ + 25184259, + 1048576 + ], + "literal_cubic_annihilator": true, + "normalization_controls": 3 + } +}