| import unittest, itertools, math |
| from fractions import Fraction as F |
| import numpy as np |
| from scipy.special import logsumexp |
| from infinite_players.temporal import lag_moments, reaction_interval |
| from infinite_players.evidence_tree import EvidenceTree, paired_emission_factors, forward_log_likelihoods |
| from infinite_players.memory_contract import confusability_graph, exact_coloring, retrospective_memory_lower_bits |
| from infinite_players.fidelity import solve_fiber, policy_iteration, project_improvement, semantic_law, signature_residual |
| from infinite_players.arena import make_arena,calibration_fixture |
| from infinite_players.promotion import budget,audit_gain |
|
|
| class TemporalTests(unittest.TestCase): |
| def test_aligned_variance(self):self.assertAlmostEqual(lag_moments(80,0,.45,.72)[1],80*(1-.45**2)) |
| def test_lag_one_independent(self):self.assertAlmostEqual(lag_moments(80,1,.45,.72)[1],80*(1-(.45*.72)**2)) |
| def test_zero_persistence(self):self.assertEqual(lag_moments(20,3,.6,0), (0.,20.,1.)) |
| def test_no_signal(self):self.assertEqual(lag_moments(20,4,0,.8),(0.,20.,1.)) |
| def test_deterministic_gate(self):self.assertAlmostEqual(lag_moments(20,4,.5,1)[1],15.) |
| def test_invalid_parameters(self): |
| for args in ((0,1,.2,.3),(2,-1,.2,.3),(2,1,2,.3)): |
| with self.assertRaises(ValueError):lag_moments(*args) |
| def test_clock_gauge(self): |
| self.assertAlmostEqual(.12+.03,.09+.06) |
| self.assertTrue(np.allclose(reaction_interval(.15,.02,.04),(.11,.13))) |
| def test_impossible_clock(self): |
| with self.assertRaises(ValueError):reaction_interval(.01,.02,.03) |
|
|
| class TreeTests(unittest.TestCase): |
| def setUp(self): |
| self.rng=np.random.default_rng(12) |
| self.f=self.rng.uniform(.01,.8,(13,4,2,2));self.ids=[f"e{i}" for i in range(13)] |
| self.tree=EvidenceTree(self.f,self.ids,model_id="fixed") |
| def test_forward_equivalence(self): |
| self.assertTrue(np.allclose(self.tree.log_likelihoods([.3,.7]),forward_log_likelihoods(self.f,[.3,.7]),atol=1e-12)) |
| def test_boundary_equivalence(self): |
| terminal=np.array([.1,.9]);init=[.8,.2] |
| self.assertTrue(np.allclose(self.tree.log_likelihoods(init,terminal),forward_log_likelihoods(self.f,init,terminal))) |
| def test_local_replacement(self): |
| fnew=self.f.copy();fnew[7]*=.3 |
| self.tree.replace("e7",fnew[7],model_id="fixed",revision_id="r1") |
| self.assertEqual(self.tree.last_update_compositions,4) |
| self.assertTrue(np.allclose(self.tree.log_likelihoods([.5,.5]),forward_log_likelihoods(fnew,[.5,.5]))) |
| def test_replacement_not_double_count(self): |
| old=self.tree.posterior([.5,.5]) |
| self.tree.replace("e7",self.f[7],model_id="fixed",revision_id="identity") |
| np.testing.assert_allclose(old,self.tree.posterior([.5,.5]),atol=1e-14) |
| def test_duplicate_id(self): |
| with self.assertRaises(ValueError):EvidenceTree(self.f,["x"]*13,model_id="m") |
| def test_invalid_replace_atomic(self): |
| old=self.tree.posterior([.5,.5]).copy() |
| with self.assertRaises(ValueError):self.tree.replace("e1",-self.f[1],model_id="fixed",revision_id="bad") |
| np.testing.assert_array_equal(old,self.tree.posterior([.5,.5]));self.assertEqual(len(self.tree.revisions),0) |
| def test_generated_evidence_rejected(self): |
| with self.assertRaises(ValueError):self.tree.replace("e1",self.f[1],model_id="fixed",revision_id="bad",source_kind="imagined_rollout") |
| def test_catalog_change_rejected(self): |
| with self.assertRaises(ValueError):self.tree.replace("e1",self.f[1],model_id="new",revision_id="bad") |
| def test_duplicate_revision(self): |
| self.tree.replace("e1",self.f[1],model_id="fixed",revision_id="r") |
| with self.assertRaises(ValueError):self.tree.replace("e2",self.f[2],model_id="fixed",revision_id="r") |
| def test_all_impossible(self): |
| with self.assertRaises(ValueError):self.tree.posterior([.5,.5],probe=np.zeros(4)) |
| def test_rare_probe(self): |
| p=self.tree.posterior([.5,.5],probe=np.array([1e-250,2e-250,0,0])) |
| q=self.tree.posterior([.5,.5],probe=np.array([1,2,0,0])) |
| np.testing.assert_allclose(p,q,atol=1e-12) |
| def test_long_underflow_control(self): |
| f=np.broadcast_to(np.eye(2)*.01,(1024,2,2,2)).copy() |
| t=EvidenceTree(f,[str(i) for i in range(1024)],model_id="small") |
| np.testing.assert_allclose(t.posterior([.5,.5]),[.5,.5]);self.assertTrue(np.all(np.isfinite(t.log_likelihoods([.5,.5])))) |
| def test_scalar_root_not_sufficient(self): |
| a=np.array([[[[1.,0],[0,0]]]]);b=np.array([[[[0.,1],[0,0]]]]) |
| x=EvidenceTree(a,["x"],model_id="m");y=EvidenceTree(b,["x"],model_id="m") |
| np.testing.assert_array_equal(x.log_likelihoods([1,0]),y.log_likelihoods([1,0])) |
| self.assertNotEqual(x.log_likelihoods([1,0],[1,0])[0],y.log_likelihoods([1,0],[1,0])[0]) |
| def test_world_symmetry(self): |
| hyp=list(itertools.product([-1,1],repeat=2)) |
| factors=paired_emission_factors([1,1,-1],[1,1,-1],hyp) |
| t=EvidenceTree(factors,["a","b","c"],model_id="m") |
| p=t.posterior([.5,.5]);self.assertAlmostEqual(p[:2].sum(),.5) |
| post=t.posterior([.5,.5],probe=[0,1,0,1]);self.assertGreater(post[3],.5) |
|
|
| class MemoryTests(unittest.TestCase): |
| def test_one_bit_full_record_memory(self): |
| rows=list(itertools.product([0,1],repeat=4));g=confusability_graph(rows) |
| k,c=exact_coloring(g);self.assertEqual(k,16) |
| def test_future_query_subset(self): |
| rows=np.array(list(itertools.product([0,1],repeat=3))) |
| k,_=exact_coloring(confusability_graph(rows[:,:1]));self.assertEqual(k,2) |
| def test_support_changes_graph(self): |
| g=confusability_graph([[0,1],[1,0]],[[1,0],[0,1]]) |
| self.assertFalse(g[0,1]);self.assertEqual(exact_coloring(g)[0],1) |
| def test_odd_cycle_coloring(self): |
| g=np.zeros((5,5),bool) |
| for i in range(5):g[i,(i+1)%5]=g[(i+1)%5,i]=True |
| self.assertEqual(exact_coloring(g)[0],3) |
| def test_lossy_bound_endpoints(self): |
| self.assertEqual(retrospective_memory_lower_bits(128,0),128) |
| self.assertEqual(retrospective_memory_lower_bits(128,.5),0) |
| self.assertGreater(retrospective_memory_lower_bits(128,.01),117) |
| def test_invalid_graph(self): |
| with self.assertRaises(ValueError):exact_coloring([[1]]) |
|
|
| class FidelityTests(unittest.TestCase): |
| def setUp(self):self.mdp,self.anchor,self.k=make_arena(81) |
| def test_anchor_feasible(self):self.assertLess(signature_residual(self.mdp,self.anchor,self.k),1e-12) |
| def test_lp_optimum_dominates_anchor(self): |
| pi,v,a=policy_iteration(self.mdp,self.k) |
| self.assertGreaterEqual(np.min(v-self.mdp.evaluate(self.anchor)[0]),-1e-10) |
| self.assertLess(signature_residual(self.mdp,pi,self.k),1e-10) |
| def test_whole_semantic_law(self): |
| pi,_,_=policy_iteration(self.mdp,self.k) |
| for horizon in range(1,6):np.testing.assert_allclose(semantic_law(self.mdp,pi,horizon),semantic_law(self.mdp,self.anchor,horizon),atol=1e-12) |
| def test_class_only_does_not_protect_path(self): |
| pi,_,_=policy_iteration(self.mdp,self.k,"class") |
| law=semantic_law(self.mdp,pi,5);ref=semantic_law(self.mdp,self.anchor,5) |
| self.assertGreater(np.abs(law-ref).sum()/2,.1) |
| def test_projection_monotonic(self): |
| pi,h=project_improvement(self.mdp,self.anchor,self.k,steps=12) |
| self.assertTrue(all(x['minimum_value_gain']>=-1e-9 for x in h)) |
| self.assertLess(signature_residual(self.mdp,pi,self.k),1e-9) |
| def test_projection_identity(self): |
| _,q=self.mdp.evaluate(self.anchor) |
| for s in range(self.mdp.S): |
| D=self.mdp.signature(s);d=(np.eye(self.mdp.A)-np.linalg.pinv(D)@D)@q[s] |
| np.testing.assert_allclose(D@d,0,atol=1e-12) |
| self.assertAlmostEqual(float(q[s]@d),float(d@d),places=10) |
| def test_zero_headroom(self): |
| mdp,a,k=make_arena(82,no_headroom=True);pi,v,_=policy_iteration(mdp,k) |
| np.testing.assert_allclose(v,mdp.evaluate(a)[0],atol=1e-11) |
| def test_calibration_opens_fiber(self): |
| d0,d1,k,r=calibration_fixture() |
| robust,_=solve_fiber(r,np.vstack([d0,d1]),np.tile(k,2)) |
| calibrated,_=solve_fiber(r,d0,k) |
| np.testing.assert_allclose(robust,[1,0,0]);np.testing.assert_allclose(calibrated,[0,.5,.5]) |
| self.assertAlmostEqual(r@calibrated,.85) |
| def test_other_world_no_unlock(self): |
| d0,d1,k,r=calibration_fixture();p,_=solve_fiber(r,d1,k);self.assertAlmostEqual(r@p,.4) |
| def test_lp_dual(self): |
| pi,v,a=policy_iteration(self.mdp,self.k) |
| self.assertTrue(all(x['primal_residual']<1e-9 and x['dual_violation']<1e-9 and abs(x['duality_gap'])<1e-9 for x in a['lp_audits'])) |
| def test_impossible_target(self): |
| with self.assertRaises(ValueError):solve_fiber([1,2],[[1,1],[0,0]],[1,.2]) |
| def test_law_probability(self):self.assertAlmostEqual(semantic_law(self.mdp,self.anchor,5).sum(),1.) |
|
|
| class PromotionTests(unittest.TestCase): |
| def test_lifetime_budget(self):self.assertAlmostEqual(sum(budget(.05,j) for j in range(1,1000)),.05*(1-1/1000)) |
| def test_zero_not_promoted(self):self.assertFalse(audit_gain(np.zeros(100),version=1)['promoted']) |
| def test_positive_promoted(self):self.assertTrue(audit_gain(np.ones(100),version=1)['promoted']) |
| def test_bad_samples(self): |
| with self.assertRaises(ValueError):audit_gain([2],version=1) |
| def test_invalid_version(self): |
| with self.assertRaises(ValueError):budget(.05,0) |
|
|
|
|
| class IntegrationTests(unittest.TestCase): |
| def test_environment_authorization(self): |
| from infinite_players.arena import ArenaEnvironment |
| env=ArenaEnvironment(make_arena(2)[0]);self.assertEqual(env.reset()['tick'],0) |
| with self.assertRaises(ValueError):env.step(99) |
| def test_environment_step(self): |
| from infinite_players.arena import ArenaEnvironment |
| env=ArenaEnvironment(make_arena(3)[0]);obs,r,d,i=env.step(1);self.assertEqual(obs['tick'],1);self.assertIn(r,(0.,1.)) |
| def test_fixture_decoder_rejects_synthetic_as_human(self): |
| from infinite_players.demo import decode_fixture_record |
| with self.assertRaises(ValueError):decode_fixture_record([{'event_id':'a','source_kind':'human_record','tick':1,'action_signal':1,'context_signal':1}]) |
| def test_record_order(self): |
| from infinite_players.demo import decode_fixture_record |
| e=[{'event_id':str(i),'source_kind':'synthetic_fixture','tick':0,'action_signal':1,'context_signal':1} for i in range(2)] |
| with self.assertRaises(ValueError):decode_fixture_record(e) |
| def test_pipeline(self): |
| import tempfile |
| from pathlib import Path |
| from infinite_players.demo import run |
| with tempfile.TemporaryDirectory() as d: |
| c=run(Path(d),steps=5) |
| self.assertLess(c['evaluation']['path_TV_h6'],1e-10) |
| self.assertGreaterEqual(c['evaluation']['normalized_descendant_value'],c['evaluation']['normalized_anchor_value']-1e-10) |
| self.assertEqual(c['source_events'],32) |
|
|
| if __name__=='__main__':unittest.main() |
|
|
