diff --git a/research/full-clifford-one-qubit/.gitattributes b/research/full-clifford-one-qubit/.gitattributes new file mode 100644 index 0000000000..8243dc42fc --- /dev/null +++ b/research/full-clifford-one-qubit/.gitattributes @@ -0,0 +1,2 @@ +# Preserve the frozen Windows verification output byte for byte. +RESULT.json -text whitespace=cr-at-eol diff --git a/research/full-clifford-one-qubit/README.md b/research/full-clifford-one-qubit/README.md new file mode 100644 index 0000000000..e71833693e --- /dev/null +++ b/research/full-clifford-one-qubit/README.md @@ -0,0 +1,94 @@ +# Sharp one-qubit full-Clifford tensor threshold + +This scoped algebraic result gives pointwise tensor independence from width **5** +for the full one-qubit Gaussian-dyadic Clifford group modulo its four scalar +phases. The group has 96 exact lifts and 24 projective classes. The exact Gram +ranks at widths 1 through 9 are `4,10,20,23,24,24,24,24,24`. + +This sharpens the n=1 sufficient pointwise threshold 8 in Ali Romman's +[PR #5526](https://github.com/CrocSwap/integer-mult-bounds/pull/5526), at exact head +`45f7de73b168721cdf7ec8c1769b1b594493716a`, especially +[`PROOF.md` Sections 1 and 5](https://github.com/aliromman/integer-mult-bounds/blob/45f7de73b168721cdf7ec8c1769b1b594493716a/research/clifford-pointwise-faithfulness/PROOF.md). +The scope refines the formal-interface question to this smallest full-Clifford +alphabet. It does not change the selected result or supply a new kappa, +physical implementation, paid invoice or multiplication theorem. + +## Argument and evidence + +The exact generators are `S=diag(1,i)` and +`V=((1+i,1-i),(1-i,1+i))/2`. Both normalize the Pauli group. The enumerated +24 projective classes exhaust the one-qubit Clifford group: X has six signed +Pauli images, Z has four anticommuting signed Pauli images, and this action +determines a projective matrix. The exact scalar kernel in `Z[i,1/2]` consists +of the four Gaussian units, as in the predecessor. + +For the enumerated representatives define +`H_f(g,h)=(tr(U_g* U_h)/2)^f`, the normalized tensor Gram matrix. +Exact Gaussian rational elimination gives `rank(H_4)=23` and `rank(H_5)=24`. +The latter Gram matrix is positive definite. Since +`H_(f+1)=H_f Hadamard H_1`, the Schur product theorem propagates this: +`H_f >= lambda I` implies `H_(f+1) >= lambda (I Hadamard H_1)=lambda I`. +Here `H_1` is positive semidefinite with diagonal one. Thus every width at +least 5 works; the explicit width-4 null vector in [RESULT.json](RESULT.json) +proves sharpness. The verifier computes unnormalized trace powers, which +differ from `H_f` by the nonzero scalar `2^f` and have identical ranks/kernels. + +For one fixed residual in the 96-element group algebra, the predecessor's +four-residue Fourier argument therefore makes widths **5,6,7,8** sufficient +to decide vanishing at every positive width. The width-4 null vector times +the central residue-zero filter vanishes at widths 1 through 7 but not 8. +The saved witness is checked at both widths 4 and 8. Consequently no universal +test using only positive widths below 8 suffices. Fixed residual coefficients +are essential to this four-width statement. + +## Reproduction and limits + +Python 3.12 and the standard library suffice. From this directory: + +```sh +python clifford-experiment.py +python -I -O -W error clifford-experiment.py +``` + +The research author ran both commands under CPython 3.12.10 on Windows; their +outputs were byte-identical, SHA256 +`2163c2f6f4bbc77e126a3cc96e778fcded03512be6784b898afd21875389ce7d`. +The saved output includes every rank, null vectors and the representatives +stored as `2U`. The standalone verifier imports no predecessor executable. +It checks unitarity of all 96 elements, independently constructs 1,152 literal +tensor Gram entries at widths 4 and 5, and checks the same-residue witness. +Checks do not use removable Python assertions. Its SHA256 is +`400844199eb130c02215cd4affea736f3f80a08a7ee1f60572619bcd855b204a`. + +This is author-checked exact evidence with a brief AI sanity review, not +independent human or proof-kernel acceptance. No selected cold replay, +physical supplier verification, full repository package wrapper, registered +CI replay or full theorem audit is claimed. This small package uses the +standalone commands above and does not opt into the generic replay manifest. +Canonical base: `32890bc5de034ab8fc93ac88ead7279a6a416d04`, priority revision 7. +The predecessor is a mathematical source; executing this verifier does not +require its checkout or an unmerged Git object. + +## Open next questions + +What are the exact pointwise thresholds for larger full-Clifford groups? +They could sharpen sufficient algebraic identity tests. A first step is a +bounded exact Gram computation retaining the central residue. Group size and +exact arithmetic cost are the immediate blockers; no larger cutoff follows +from this one-qubit calculation. + +## Attribution + +Ali Romman retains credit for PR #5526's general theorem, phase conventions +and Fourier implication. Credit also the monomial results in +[#5521](https://github.com/CrocSwap/integer-mult-bounds/pull/5521), +[#5522](https://github.com/CrocSwap/integer-mult-bounds/pull/5522), +[#5529](https://github.com/CrocSwap/integer-mult-bounds/pull/5529) and +[#5542](https://github.com/CrocSwap/integer-mult-bounds/pull/5542), and DLamdata's +general-theorem audit [#5547](https://github.com/CrocSwap/integer-mult-bounds/pull/5547). +This result concerns the larger full-Clifford alphabet and does not repeat +those audits. Schur products, Pauli normalizers and Fourier inversion are +classical. No global literature-priority claim is made. + +Prepared for MatShep with substantial OpenAI Codex assistance (GPT-6.1 Sol +research; GPT-6 Astra brief validation and publication). Apache-2.0. diff --git a/research/full-clifford-one-qubit/RESULT.json b/research/full-clifford-one-qubit/RESULT.json new file mode 100644 index 0000000000..0f0fbdc778 --- /dev/null +++ b/research/full-clifford-one-qubit/RESULT.json @@ -0,0 +1,1446 @@ +{ + "group": 96, + "projective": 24, + "widths": [ + { + "f": 1, + "rank": 4, + "null_vector": [ + [ + [ + -1, + 1 + ], + [ + 1, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ] + ] + }, + { + "f": 2, + "rank": 10, + "null_vector": [ + [ + [ + -1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ] + ] + }, + { + "f": 3, + "rank": 20, + "null_vector": [ + [ + [ + 0, + 1 + ], + [ + -2, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + -1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + 1 + ], + [ + 0, + 1 + ] + ] + ] + }, + { + "f": 4, + "rank": 23, + "null_vector": [ + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ] + ] + }, + { + "f": 5, + "rank": 24 + }, + { + "f": 6, + "rank": 24 + }, + { + "f": 7, + "rank": 24 + }, + { + "f": 8, + "rank": 24 + }, + { + "f": 9, + "rank": 24 + } + ], + "literal_tensor_gram_entries_checked": 1152, + "same_residue_witness": "width 4 zero; width 8 nonzero", + "representatives_2U": [ + [ + [ + -2, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + -2, + 0 + ] + ], + [ + [ + -2, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -2 + ] + ], + [ + [ + -2, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 2 + ] + ], + [ + [ + -2, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 2, + 0 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + -1 + ], + [ + -1, + -1 + ], + [ + 1, + 1 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + -1 + ], + [ + -1, + 1 + ], + [ + 1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + -1 + ], + [ + 1, + -1 + ], + [ + -1, + 1 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + -1 + ], + [ + 1, + 1 + ], + [ + -1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + 1 + ], + [ + -1, + -1 + ], + [ + 1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + 1 + ], + [ + -1, + 1 + ], + [ + -1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + 1 + ], + [ + 1, + -1 + ], + [ + 1, + 1 + ] + ], + [ + [ + -1, + -1 + ], + [ + -1, + 1 + ], + [ + 1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + -1 + ], + [ + -1, + -1 + ], + [ + -1, + 1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + -1 + ], + [ + -1, + 1 + ], + [ + 1, + 1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + -1 + ], + [ + 1, + -1 + ], + [ + -1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + -1 + ], + [ + 1, + 1 + ], + [ + 1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + 1 + ], + [ + -1, + -1 + ], + [ + -1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + 1 + ], + [ + -1, + 1 + ], + [ + -1, + 1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + 1 + ], + [ + 1, + -1 + ], + [ + 1, + -1 + ] + ], + [ + [ + -1, + -1 + ], + [ + 1, + 1 + ], + [ + 1, + 1 + ], + [ + 1, + 1 + ] + ], + [ + [ + 0, + 0 + ], + [ + -2, + 0 + ], + [ + -2, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + -2, + 0 + ], + [ + 0, + -2 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + -2, + 0 + ], + [ + 0, + 2 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + -2, + 0 + ], + [ + 2, + 0 + ], + [ + 0, + 0 + ] + ] + ] +} diff --git a/research/full-clifford-one-qubit/clifford-experiment.py b/research/full-clifford-one-qubit/clifford-experiment.py new file mode 100644 index 0000000000..31142a3fc9 --- /dev/null +++ b/research/full-clifford-one-qubit/clifford-experiment.py @@ -0,0 +1,99 @@ +from fractions import Fraction as F +import json + +# Gaussian integers are pairs; all group matrices are represented as 2U. +def add(a,b): return (a[0]+b[0],a[1]+b[1]) +def neg(a): return (-a[0],-a[1]) +def conj(a): return (a[0],-a[1]) +def mul(a,b): return (a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]) +def power(a,n): + z=(1,0) + for _ in range(n): z=mul(z,a) + return z +def mm(a,b): + c=tuple(add(mul(a[2*i],b[j]),mul(a[2*i+1],b[2+j])) for i in range(2) for j in range(2)) + if not all(x%2==0 and y%2==0 for x,y in c): raise ValueError('nonintegral product') + return tuple((x//2,y//2) for x,y in c) +I=((2,0),(0,0),(0,0),(2,0)) +S=((2,0),(0,0),(0,0),(0,2)) +V=((1,1),(1,-1),(1,-1),(1,1)) +group={I}; todo=[I] +while todo: + a=todo.pop() + for b in (S,V): + c=mm(a,b) + if c not in group: group.add(c); todo.append(c) +def phase(a,j): return tuple(mul(x,power((0,1),j)) for x in a) +reps=sorted({min(phase(a,j) for j in range(4)) for a in group}) +def inner(a,b): + t=(0,0) + for x,y in zip(a,b): t=add(t,mul(conj(x),y)) + if not all(v%4==0 for v in t): raise ValueError('nonintegral trace') + return tuple(v//4 for v in t) +T=[[inner(a,b) for b in reps] for a in reps] +def div(a,b): + n=b[0]*b[0]+b[1]*b[1] + c=mul(a,conj(b)) + return (F(c[0],n),F(c[1],n)) +def rref(rows): + a=[[tuple(F(v) for v in z) for z in row] for row in rows]; piv=[] + for j in range(len(a[0])): + k=next((k for k in range(len(piv),len(a)) if a[k][j]!=(0,0)),None) + if k is None: continue + p=len(piv); a[p],a[k]=a[k],a[p]; z=a[p][j] + a[p]=[div(v,z) for v in a[p]] + for k in range(len(a)): + if k==p or a[k][j]==(0,0): continue + z=a[k][j]; a[k]=[add(x,neg(mul(z,y))) for x,y in zip(a[k],a[p])] + piv.append(j) + return a,piv +def need(c,msg): + if not c: raise ValueError(msg) +need(len(group)==96 and len(reps)==24,'group census') +for a in group: + adj=(conj(a[0]),conj(a[2]),conj(a[1]),conj(a[3])) + need(mm(adj,a)==I,'unitarity') +result={'group':len(group),'projective':len(reps),'widths':[]} +for f in range(1,10): + g=[[power(t,f) for t in row] for row in T] + rr,piv=rref(g) + item={'f':f,'rank':len(piv)} + if len(piv)<24: + j=next(j for j in range(24) if j not in piv) + v=[(F(0),F(0))]*24; v[j]=(F(1),F(0)) + for i,col in enumerate(piv): v[col]=neg(rr[i][j]) + item['null_vector']=[[[z.numerator,z.denominator] for z in x] for x in v] + result['widths'].append(item) +need([i['rank'] for i in result['widths']]==[4,10,20,23,24,24,24,24,24],'tensor ranks') +# Independent literal tensor-entry construction at the last failing and first +# faithful widths. Vectors use (2U)^tensor f, so their Gram is 4^f times +# the unnormalized trace-power Gram computed above. +for f in (4,5): + vectors=[] + for a in reps: + v=[(1,0)] + for _ in range(f): v=[mul(x,y) for x in v for y in a] + vectors.append(v) + for i,a in enumerate(vectors): + for j,b in enumerate(vectors): + z=(0,0) + for x,y in zip(a,b): z=add(z,mul(conj(x),y)) + expected=power(T[i][j],f) + need(z==tuple(4**f*x for x in expected),'literal tensor Gram') +# The explicit last-failing null vector must disappear at the next width of +# the same central-phase residue, not merely at a different phase quotient. +raw=result['widths'][3]['null_vector'] +w=[tuple(F(*z) for z in x) for x in raw] +def action(f): + out=[] + for row in T: + z=(F(0),F(0)) + for t,x in zip(row,w): z=add(z,mul(power(t,f),x)) + out.append(z) + return out +need(all(z==(0,0) for z in action(4)),'width-four null witness') +need(any(z!=(0,0) for z in action(8)),'same-residue separation') +result['literal_tensor_gram_entries_checked']=1152 +result['same_residue_witness']='width 4 zero; width 8 nonzero' +result['representatives_2U']=[list(a) for a in reps] +print(json.dumps(result,indent=2))