Datasets:
Formats:
csv
Languages:
English
Size:
1K - 10K
Tags:
mathematics
inverse-problems
observability
noncommutative-algebra
symbolic-computation
calibration-rigidity
| from itertools import combinations, product | |
| import sympy as sp | |
| import pytest | |
| from noulith import TwistedAlgebra, bits, partitions, ideal_generators, equal_polynomial_ideals | |
| from noulith.geometry import * | |
| def test_refinement_identity_symbolic_four_channels(): | |
| pairs=list(combinations(range(4),2)); params=sp.symbols('q0:6') | |
| alg=TwistedAlgebra(4,dict(zip(pairs,params))); sh=alg.shuffle_table() | |
| for mask in range(1,16): | |
| for a in range(1,mask.bit_count()): | |
| total=0 | |
| for sub in range(1,16): | |
| if sub & mask == sub and sub.bit_count()==a: | |
| other=mask^sub | |
| _,weight=alg.monomial_product(sub,other) | |
| total+=weight*sh[sub]*sh[other] | |
| assert sp.expand(total-sh[mask])==0 | |
| def test_two_deficit_generator_formula(): | |
| a,b,c,d,e,f=sp.symbols('a b c d e f') | |
| pairs=list(combinations(range(4),2)) | |
| alg=TwistedAlgebra(4,{ij:-1+x for ij,x in zip(pairs,[a,b,c,d,e,f])}) | |
| sh=alg.shuffle_table() | |
| full=15 | |
| motifs=[sh[mask] for mask in range(16) if mask.bit_count()==3] | |
| motifs += [a*f,b*e,c*d] | |
| actual=ideal_generators(sh,full,2) | |
| assert equal_polynomial_ideals(actual,motifs,[a,b,c,d,e,f]) | |
| def test_pfaffian_tangent_theorem_exact(m,seed): | |
| t=sp.Symbol('t'); pairs=list(combinations(range(m),2)) | |
| edges={pair:sp.Integer(((i+seed)*7)%13-6) for i,pair in enumerate(pairs)} | |
| alg=TwistedAlgebra(m,{pair:-1+t*v for pair,v in edges.items()}) | |
| polynomial=sp.Poly(alg.shuffle_table()[-1],t) | |
| k=m//2 | |
| assert all(polynomial.coeff_monomial(t**j)==0 for j in range(k)) | |
| matrix=sp.zeros(m) | |
| for (i,j),v in edges.items(): matrix[i,j]=v;matrix[j,i]=-v | |
| assert sp.expand(polynomial.coeff_monomial(t**k)-leading_shuffle_form(matrix))==0 | |
| def test_formal_group_axioms_and_differential(): | |
| x,y,z=sp.symbols('x y z');F=resonance_group | |
| assert sp.cancel(F(F(x,y),z)-F(x,F(y,z)))==0 | |
| assert F(x,0)==x and sp.cancel(F(x,resonance_inverse(x)))==0 | |
| assert sp.cancel(sp.diff(F(x,y),y).subs(y,0)-(1-x+x*x))==0 | |
| def test_flat_triangle_identity_symbolic(): | |
| a,b,c=sp.symbols('a b c') | |
| A=flat_edge(a,b);B=flat_edge(a,c);C=flat_edge(b,c) | |
| assert sp.cancel(A*B*C-A*C+A-B+C)==0 | |
| def test_line_arrangement_generators_and_hilbert_function(N): | |
| z=sp.symbols(f'z1:{N+1}'); all_z=(sp.S.Zero,)+z | |
| motifs=[] | |
| edges=list(combinations(range(N+1),2)) | |
| for a,e in enumerate(edges): | |
| for f in edges[a+1:]: | |
| if not set(e)&set(f): | |
| motifs.append((all_z[e[1]]-all_z[e[0]])*(all_z[f[1]]-all_z[f[0]])) | |
| generators=line_arrangement_generators(z) | |
| assert equal_polynomial_ideals(motifs,generators,z) | |
| groebner=sp.groebner(generators,*z) | |
| leading=[poly.LM(order=groebner.order).exponents for poly in groebner.polys] | |
| for degree in range(6): | |
| count=0 | |
| for exponents in product(range(degree+1),repeat=N): | |
| if sum(exponents)==degree and not any(all(a>=b for a,b in zip(exponents,lead)) for lead in leading): count+=1 | |
| assert count==([1,N][degree] if degree<2 else N+1) | |
| def test_all_five_exact_resonance_branches(outlier): | |
| t=sp.Symbol('t');h=[0]*5;h[outlier]=t | |
| f={ij:flat_edge(h[ij[0]],h[ij[1]]) for ij in combinations(range(5),2)} | |
| for i,j,k in combinations(range(5),3): | |
| A,B,C=f[i,j],f[i,k],f[j,k] | |
| assert sp.cancel(A*B*C-A*C+A-B+C)==0 | |
| for e,g in combinations(f,2): | |
| if not set(e)&set(g): assert sp.cancel(f[e]*f[g])==0 | |
| def test_triangle_flatness_alone_is_insufficient(): | |
| t=sp.Symbol('t');h=[0,t,2*t,3*t] | |
| f={ij:flat_edge(h[ij[0]],h[ij[1]]) for ij in combinations(range(4),2)} | |
| for i,j,k in combinations(range(4),3): | |
| A,B,C=f[i,j],f[i,k],f[j,k] | |
| assert sp.cancel(A*B*C-A*C+A-B+C)==0 | |
| assert sp.cancel(f[0,1]*f[2,3])!=0 | |
| def test_second_deficit_full_rank_strata(m,stratum,defect): | |
| from noulith.protocols import normalized_measurement_matrix | |
| f={pair:sp.S.Zero for pair in combinations(range(m),2)} | |
| if stratum=='generic': | |
| f={pair:sp.Rational(1,10) for pair in f} | |
| elif stratum=='single_star': | |
| for j in range(1,m): | |
| f[(0,j)]=sp.Rational(j,10*m) | |
| elif stratum=='outlier_branch': | |
| for j in range(1,m): | |
| f[(0,j)]=sp.Rational(1,10) | |
| elif stratum=='two_stars': | |
| f[(0,1)]=sp.Rational(1,10) | |
| algebra=TwistedAlgebra(m,{pair:-1+value for pair,value in f.items()}) | |
| matrix=normalized_measurement_matrix(algebra.shuffle_table(),m-2) | |
| # The frame has disjoint one-coordinate row supports; column nonzeroness is | |
| # therefore its exact rank, without floating-point thresholding. | |
| rank=sum(any(value!=0 for value in matrix[:,i]) for i in range(2**m)) | |
| expected=2**m-(m+1 if stratum=='origin' else defect) | |
| assert rank==expected | |
| if m==4: | |
| assert matrix.rank()==expected | |
| def test_branch_carriers_and_normalization_conductor(N): | |
| z=sp.symbols(f'z0:{N}') | |
| t=sp.symbols('t') | |
| carriers=branch_carriers(z) | |
| branches=[{v:(t if j==i else 0) for j,v in enumerate(z)} for i in range(N)] | |
| branches.append({v:t for v in z}) | |
| evaluations=sp.Matrix([[sp.expand(g.subs(branch)) for branch in branches] for g in carriers]) | |
| assert evaluations==t*t*sp.eye(N+1) | |
| def test_perfect_artinian_slice_pairing(N): | |
| z=sp.symbols(f'z0:{N}') | |
| G=sp.groebner(line_arrangement_generators(z)+[sum(z)],*z) | |
| h=z[0]*z[1] | |
| assert G.reduce(h)[1]!=0 | |
| pairing=perfect_slice_matrix(N) | |
| for i in range(N-1): | |
| for j in range(N-1): | |
| assert G.reduce(z[i]*z[j]-pairing[i,j]*h)[1]==0 | |
| assert sp.factor(pairing.det())==-(-N)**(N-2) | |