import unittest import random from itertools import permutations, product import sympy as s from axioryn.core import * from axioryn.mesh import compile_faces, integrate_scales Q=s.Rational I=s.eye(3) class GainTests(unittest.TestCase): def test_balanced_cycle(self): e=[GainEdge(0,1,2),GainEdge(1,2,3),GainEdge(2,0,Q(1,6))] r=positive_gain_kernel(3,e) self.assertTrue(r.feasible) self.assertEqual(r.basis,s.Matrix([1,2,6])) out=project_gain_scales(r,[1,1,1],[1,1,1],[Q(1,10)]*3,[10]*3) self.assertEqual(out['alpha'],s.Matrix([Q(9,41)])) def test_unbalanced_cycle(self): r=positive_gain_kernel(3,[GainEdge(0,1,2),GainEdge(1,2,3),GainEdge(2,0,Q(1,5))]) self.assertFalse(r.feasible) self.assertNotEqual(r.witness['closed_walk_gain'],1) def test_components(self): r=positive_gain_kernel(4,[GainEdge(0,1,2)]) self.assertEqual(r.basis.shape,(4,3)) self.assertTrue(all(x>0 for x in r.potentials)) def test_selfloop(self): self.assertFalse(positive_gain_kernel(1,[GainEdge(0,0,2)]).feasible) def test_nonpositive_rejected(self): with self.assertRaises(ValueError): positive_gain_kernel(2,[GainEdge(0,1,-1)]) def test_float_rejected(self): with self.assertRaises(TypeError): positive_gain_kernel(2,[GainEdge(0,1,0.5)]) def test_face_gain(self): self.assertEqual(face_gain([2,4],[1,2]),{'kind':'gain','gain':2}) def test_zero_face(self): self.assertEqual(face_gain([0,0],[0,0])['kind'],'released') def test_one_zero(self): self.assertEqual(face_gain([0,0],[1,0])['reason'],'one_zero_trace') def test_noncollinear(self): self.assertEqual(face_gain([1,0],[1,1])['reason'],'noncollinear_traces') def test_opposite(self): self.assertEqual(face_gain([-1,0],[1,0])['reason'],'opposite_traces') def test_random_planted(self): rng=random.Random(314159) for _ in range(100): n=rng.randint(3,15) d=[Q(rng.randint(1,7),rng.randint(1,7)) for _ in range(n)] e=[GainEdge(j-1,j,d[j]/d[j-1]) for j in range(1,n)] for _ in range(n): a,b=rng.sample(range(n),2); e.append(GainEdge(a,b,d[b]/d[a])) r=positive_gain_kernel(n,e) self.assertTrue(r.feasible) self.assertEqual(r.basis,s.Matrix([x/d[0] for x in d])) class InterfaceTests(unittest.TestCase): def test_generic(self): self.assertEqual(interface_data(I,I,[1,2,2])['active_normal_components'],3) def test_rank_two_family(self): n=s.Matrix([Q(3,5),Q(4,5),0]); a=n b=s.Matrix([2*a[0],a[1]/2,0]); B=I+(b-a)*n.T out=interface_data(I,B,n) self.assertEqual(out['ratios'],{0:s.Integer(2),1:Q(1,2)}) self.assertGreater(B.det(),0) def test_rank_one_family(self): B=s.diag(3,1,1) self.assertEqual(interface_data(I,B,[1,0,0])['ratios'],{0:s.Integer(3)}) def test_high_dimensional_lock(self): self.assertEqual(interface_data(s.eye(5),s.eye(5),[1,2,3,0,0])['active_normal_components'],3) def test_orientation_excludes_reflection(self): n=s.Matrix([Q(1,3),Q(2,3),Q(2,3)]) with self.assertRaises(ValueError): interface_data(I,I-2*n*n.T,n) def test_symbolic_classification(self): a1,a2,a3=s.symbols('a1 a2 a3',nonzero=True) t=s.symbols('t',nonzero=True) a=s.Matrix([a1,a2,a3]); b=s.Matrix([t*a1,a2/t,a3/t]) self.assertEqual(s.factor(b[1]*b[2]-a2*a3),-a2*a3*(t-1)*(t+1)/t**2) def test_quantitative_rational_trials(self): rng=random.Random(1729) n=s.Matrix([Q(1,3),Q(2,3),Q(2,3)]) for _ in range(120): A=s.diag(*[Q(rng.randint(1,4)) for j in range(3)]) a=A*n b=s.Matrix([a[j]*(1+Q(rng.randint(-3,3),1000)) for j in range(3)]) B=A+(b-a)*n.T out=quantitative_interface_bound(A,B,n) self.assertTrue(out['verified']) def test_sharp_zero(self): out=quantitative_interface_bound(I,I,[Q(1,3),Q(2,3),Q(2,3)]) self.assertEqual(out['upper_bound_squared'],0) def test_explicit_shear_necessity(self): n=s.Matrix([Q(1,3),Q(2,3),Q(2,3)]) B=I+s.Matrix([Q(1,100),0,0])*n.T self.assertNotEqual((B*B.T)[0,1],0) self.assertTrue(quantitative_interface_bound(I,B,n)['verified']) class GaugeTests(unittest.TestCase): def test_fake_torsion(self): B=s.Matrix([[2],[0]]) c=primitive_real_gauge_quotient(B)['C'] b=s.Matrix([Q(1,2),3]) self.assertTrue(all(x.q==1 for x in c*b)) self.assertEqual(b+B*s.Matrix([-Q(1,4)]),s.Matrix([0,3])) def test_primitive(self): B=s.Matrix([[2,4],[4,8],[6,12]]) r=primitive_real_gauge_quotient(B) self.assertEqual(r['C']*r['integer_right_inverse'],s.eye(2)) def test_no_gauge(self): r=primitive_real_gauge_quotient(s.zeros(1,0)) self.assertEqual(r['C'],s.eye(1)) self.assertNotEqual((r['C']*s.Matrix([Q(1,2)]))[0].q,1) def test_rotation_self_loop(self): rot=s.Matrix([[0,-1,0],[1,0,0],[0,0,1]]) B=twisted_incidence(1,[(0,0,rot)]) r=primitive_real_gauge_quotient(B) self.assertEqual(r['C'].rows,1) self.assertEqual(B.rank(),2) def test_tree_has_no_period_obstruction(self): B=twisted_incidence(3,[(0,1,I),(1,2,I)]) self.assertEqual(primitive_real_gauge_quotient(B)['C'].rows,0) def test_two_loop_no_fixed_vector(self): q1=s.diag(1,-1,-1); q2=s.diag(-1,1,-1) B=twisted_incidence(1,[(0,0,q1),(0,0,q2)]) self.assertEqual(B.rank(),3) self.assertEqual(primitive_real_gauge_quotient(B)['C'].rows,3) def test_random_rank_identity(self): rng=random.Random(41) rots=[] for p in permutations(range(3)): for sg in product((-1,1),repeat=3): m=s.zeros(3) for i,j in enumerate(p):m[i,j]=sg[i] if m.det()==1:rots.append(m) for _ in range(40): v=rng.randint(1,4); beta=rng.randint(1,3) edges=[(i-1,i,rng.choice(rots)) for i in range(1,v)] edges += [(rng.randrange(v),rng.randrange(v),rng.choice(rots)) for i in range(beta)] B=twisted_incidence(v,edges) f=3*v-B.rank(); r=3*len(edges)-B.rank() self.assertEqual(r,3*beta-3+f) self.assertLessEqual(r,3*beta) class OptimizationTests(unittest.TestCase): def test_inactive_bounds(self): out=box_equality_qp(s.eye(2),[0,0],[[1,1]],[2],[0,0],[3,3]) self.assertEqual(out['alpha'],s.Matrix([1,1])) self.assertEqual(out['cost'],1) def test_active_bounds(self): out=box_equality_qp(s.eye(2),[Q(9,10),Q(1,10)],[[1,1]],[1],[Q(1,5)]*2,[2,2]) self.assertEqual(out['alpha'],s.Matrix([Q(4,5),Q(1,5)])) self.assertEqual(out['cost'],Q(1,100)) def test_rank_deficient_equality(self): out=box_equality_qp(s.eye(2),[0,0],[[1,1],[2,2]],[2,4],[0,0],[3,3]) self.assertEqual(out['alpha'],s.Matrix([1,1])) def test_infeasible(self): self.assertIsNone(box_equality_qp([[1]],[0],[[1]],[3],[0],[2])) def test_coupled_integer_cannot_edit_offsets_freely(self): out=bounded_integer_projection([[1]],[Q(49,100)],[[1],[2]],[0,0],[Q(2,5)],[Q(7,5)]) self.assertEqual(out['alpha'],s.Matrix([1])) self.assertEqual(out['integer_target'],s.Matrix([1,2])) self.assertEqual(out['cost'],Q(2601,20000)) def test_bounded_integer_infeasible(self): self.assertIsNone(bounded_integer_projection([[1]],[Q(1,2)],[[1]],[0],[Q(2,5)],[Q(3,5)])) def test_cap(self): with self.assertRaises(ValueError): bounded_integer_projection([[1]],[0],[[1]],[0],[0],[100],max_targets=2) class MeshTests(unittest.TestCase): def setUp(self): self.V=[[0,0,0],[0,1,0],[0,0,1],[-1,0,0],[1,0,0]] self.T=[[0,1,2,3],[0,2,1,4]] def test_face_aligned_flexibility(self): out=compile_faces(self.V,self.T,[I,I]) self.assertTrue(out['feasible']) self.assertEqual(out['basis'].cols,4) def test_actual_pl_reconstruction(self): out=integrate_scales(self.V,self.T,[I,I],[1,2,3,2,2,3]) self.assertTrue(out['integrable']) self.assertEqual(out['determinants'],[6,12]) self.assertEqual(out['global_injectivity'],'NOT_CERTIFIED') def test_generic_face_constant_directions(self): v=[[0,0,0],[1,-1,0],[1,0,-1],[1,1,1],[-1,-1,-1]] out=compile_faces(v,self.T,[I,I]) self.assertTrue(out['feasible']) self.assertEqual(out['basis'].cols,3) def test_generic_rotated_rejected(self): v=[[0,0,0],[1,-1,0],[1,0,-1],[1,1,1],[-1,-1,-1]] r=s.Matrix([[Q(3,5),-Q(4,5),0],[Q(4,5),Q(3,5),0],[0,0,1]]) self.assertFalse(compile_faces(v,self.T,[I,r])['feasible']) def test_degenerate_rejected(self): with self.assertRaises(ValueError):compile_faces([[0,0,0]]*4,[[0,1,2,3]],[I]) def test_trace_failure_rejected(self): self.assertFalse(integrate_scales(self.V,self.T,[I,I],[1,2,3,2,4,3])['integrable']) class InjectivityCounterexampleTests(unittest.TestCase): @staticmethod def prism_data(): ring=[(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)] target=[(1,0),(0,1),(-1,0),(0,-1)]*2 v2=[(0,0)]+ring; u2=[(0,0)]+target V=s.Matrix([[x,y,z] for z in (0,1) for x,y in v2]) U=s.Matrix([[x,y,z] for z in (0,1) for x,y in u2]) tets=[] for j in range(8): a,b,c=sorted([0,1+j,1+(j+1)%8]) tets += [[a,b,c,c+9],[a,b,b+9,c+9],[a,a+9,b+9,c+9]] return V,U,tets def test_all_twentyfour_tets_positive(self): V,U,T=self.prism_data() for ids in T: X=s.Matrix.hstack(*[(V[i,:]-V[ids[0],:]).T for i in ids[1:]]) Y=s.Matrix.hstack(*[(U[i,:]-U[ids[0],:]).T for i in ids[1:]]) self.assertEqual((Y*X.inv()).det(),1) def test_double_cover_collision(self): V,U,T=self.prism_data() # Two points in opposite triangular prism sectors have identical images. p=(V[0,:]+V[1,:]+V[2,:])/3+s.Matrix([[0,0,s.Rational(1,2)]]) q=(V[0,:]+V[5,:]+V[6,:])/3+s.Matrix([[0,0,s.Rational(1,2)]]) imagep=(U[0,:]+U[1,:]+U[2,:])/3 imageq=(U[0,:]+U[5,:]+U[6,:])/3 self.assertNotEqual(p,q) self.assertEqual(imagep,imageq) if __name__=='__main__':unittest.main()