def test_example_04(self): # Two valid interpretations fcrn = "B + B -> B" icrn = "B <=> x1; B + x1 -> x2 + x3; x2 -> B + x4" (fcrn, fs) = self._parse_crn_string(fcrn) (icrn, _) = self._parse_crn_string(icrn) ifull1 = { 'B': Counter(['B']), 'x1': Counter(['B']), 'x2': Counter(['B', 'B']), 'x3': Counter(), 'x4': Counter() } ipart1 = {'B': Counter(['B']), 'x2': Counter(['B', 'B'])} v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=ipart1) self.assertTrue(v) self.assertDictEqual(i1, ifull1) ifull2 = { 'B': Counter(['B']), 'x1': Counter(['B']), 'x2': Counter(['B']), 'x3': Counter(), 'x4': Counter() } ipart2 = {'B': Counter(['B']), 'x2': Counter(['B'])} v, i2 = bisimulation.test(fcrn, icrn, fs, interpretation=ipart2) self.assertTrue(v) self.assertDictEqual(i2, ifull2)
def test_roessler_qian_equivalence(self): (fcrn, fs) = self._parse_crn_file('tests/crns/roessler_formal.crn') (icrn, _) = self._parse_crn_file('tests/crns/roessler_qian2011_gen.crn') v, i = bisimulation.test(fcrn, icrn, fs) self.assertTrue(v)
def dont_test_cardelli2D(self): fcrn = "-> A" icrn = " <=> e68_; A + e163_ <=> e129_; e163_ -> e197_ + e198_; e68_ <=> e98_ + e99_; e98_ -> e127_ + e237_; e99_ -> e127_ + e129_" (fcrn, fs) = self._parse_crn_string(fcrn) (icrn, _) = self._parse_crn_string(icrn) #ifull1 = {'B': Counter(['B']), # 'x1': Counter(['B']), # 'x2': Counter(['B','B']), # 'x3': Counter(), # 'x4': Counter()} #ipart1 = {'A': Counter(['A']), # '_e129': Counter(['A']), # '_e237': Counter(), # '_e197': Counter()} v, i = bisimulation.test(fcrn, icrn, fs) print 'returned', v print 'returned', i for impl, formal in sorted(i[0].items()): print " {} => {}".format( impl, ', '.join([x for x in formal.elements()])) self.assertTrue(v)
def test_example_01(self): #A sample test to aggree on a new interface for bisimulation. fcrn = "A->B" ecrn = "A<=>i19; i19<=>i39+X; i39->i71+i72" (fcrn, fs) = self._parse_crn_string(fcrn) (ecrn, _) = self._parse_crn_string(ecrn) partial = dict() partial['A'] = Counter(A=1) partial['B'] = Counter(B=1) v, i = bisimulation.test(fcrn, ecrn, fs, interpretation=partial, permissive='loop-search', verbose=False) self.assertTrue(v) v, i = bisimulation.test(fcrn, ecrn, fs, interpretation=partial, permissive='whole-graph', verbose=False) self.assertTrue(v) v, i = bisimulation.test(fcrn, ecrn, fs, interpretation=partial, permissive='depth-first', permissive_depth=8, verbose=False) self.assertTrue(v) # A function that does not say so, should not modify its arguments: argcheck = dict() argcheck['A'] = Counter(A=1) argcheck['B'] = Counter(B=1) self.assertDictEqual(partial, argcheck)
def test_example_02(self): # """A simple example of finding a bisimulation from group meeting.""" fcrn = "A + B -> C + D ; A + C -> B + D" icrn = "x1 -> x2 ; x3 + x4 <=> x5 ; x2 -> x6 + x8 ; x5 -> x7 ; " + \ "x3 <=> x6 ; x9 <=> x10 ; x10 + x4 <=> x1 ; x7 -> x9 + x8" (fcrn, fs, _) = parse_crn_string(fcrn) fcrn = split_reversible_reactions(fcrn) fcrn = [[Counter(part) for part in rxn] for rxn in fcrn] (icrn, _, _) = parse_crn_string(icrn) icrn = split_reversible_reactions(icrn) icrn = [[Counter(part) for part in rxn] for rxn in icrn] v, _ = bisimulation.test(fcrn, icrn, fs) self.assertTrue(v) # Test wrong partial interpretation partial = dict() partial['x2'] = Counter(['B', 'D']) partial['x3'] = Counter(['C']) v, i = bisimulation.test(fcrn, icrn, fs, interpretation=partial, permissive='loop-search', verbose=False) self.assertFalse(v) del partial['x3'] v, _ = bisimulation.test(fcrn, icrn, fs, permissive='loop-search', interpretation=partial, verbose=False) self.assertTrue(v)
def test_example_05(self): # Issue fixed: Naming species in certain ways broke bisimulation fcrn = "A+C->A+B" #icrn = "A <=> x1 + x2; C+x1 <=> x3 + x4; x3 -> A + B + x5" icrn = "A <=> x1 + e45; C + x1 <=> x3 + x4; x3 -> A + B + x5" (fcrn, fs) = self._parse_crn_string(fcrn) (icrn, _) = self._parse_crn_string(icrn) inter = {'A': Counter(['A']), 'B': Counter(['B']), 'C': Counter(['C'])} v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=inter) self.assertTrue(v)
def test_qingdongthesis_solo(self): # An example where the choice of the permchecker matters ... (fcrn, fs) = self._parse_crn_file('tests/crns/crn6.crn') (icrn, _) = self._parse_crn_file('tests/crns/crn6_qingdong_thesis.crn') inter_01 = { 'i778': Counter(['Y']), 'i575': Counter(['X']), 'i599': Counter(['C']), 'i2232': Counter(['A']), 'i73': Counter(['B']) } inter_02 = { 'i842': Counter(['Y', 'X', 'A']), 'i394': Counter(['X', 'Y', 'X']), 'i119': Counter(['X', 'B', 'A']), 'i2300': Counter(['A', 'C']), 'i778': Counter(['Y']), 'i575': Counter(['X']), 'i599': Counter(['C']), 'i2232': Counter(['A']), 'i73': Counter(['B']) } if True: # NOTE: These tests complete in less than 10 minutes v, _ = bisimulation.test(fcrn, icrn, fs, permissive='whole-graph') self.assertTrue(v) v, _ = bisimulation.test(fcrn, icrn, fs, permissive='depth-first') self.assertTrue(v) if False: # NOTE: These don't finish within 10 minutes v, _ = bisimulation.test(fcrn, icrn, fs, permissive='loop-search') self.assertTrue(v) v, _ = bisimulation.test(fcrn, icrn, fs, interpretation=inter_01, permissive='loop-search') self.assertTrue(v) if True: # These tests pass quite fast! v, _ = bisimulation.test(fcrn, icrn, fs, interpretation=inter_01) self.assertTrue(v) v, _ = bisimulation.test(fcrn, icrn, fs, interpretation=inter_01, permissive='depth-first') self.assertTrue(v) v, _ = bisimulation.test(fcrn, icrn, fs, interpretation=inter_02, permissive='whole-graph') self.assertTrue(v) v, _ = bisimulation.test(fcrn, icrn, fs, interpretation=inter_02, permissive='depth-first') self.assertTrue(v) v, _ = bisimulation.test(fcrn, icrn, fs, interpretation=inter_02, permissive='loop-search') self.assertTrue(v)
def test_example_03(self): #""" a follow-up on testing the groupmeeting example """ fcrn = "A + B -> C + D ; A + C -> B + D" icrn = "x1 -> x2 ; x3 + x4 <=> x5 ; x2 -> x6 + x8 ; x5 -> x7 ; " + \ "x3 <=> x6 ; x9 <=> x10 ; x10 + x4 <=> x1 ; x7 -> x9 + x8" # First correct interpretation inter1 = { 'x1': Counter({ 'A': 1, 'B': 1 }), 'x2': Counter({ 'C': 1, 'D': 1 }), 'x3': Counter({'C': 1}), 'x4': Counter({'A': 1}), 'x5': Counter({ 'A': 1, 'C': 1 }), 'x6': Counter({'C': 1}), 'x7': Counter({ 'B': 1, 'D': 1 }), 'x8': Counter({'D': 1}), 'x9': Counter({'B': 1}), 'x10': Counter({'B': 1}) } pinter1 = {'x7': Counter({'B': 1, 'D': 1})} # Second correct interpretation inter2 = { 'x1': Counter({ 'A': 1, 'C': 1 }), 'x2': Counter({ 'B': 1, 'D': 1 }), 'x3': Counter({'B': 1}), 'x4': Counter({'A': 1}), 'x5': Counter({ 'A': 1, 'B': 1 }), 'x6': Counter({'B': 1}), 'x7': Counter({ 'C': 1, 'D': 1 }), 'x8': Counter({'D': 1}), 'x9': Counter({'C': 1}), 'x10': Counter({'C': 1}) } pinter2 = {'x7': Counter({'C': 1, 'D': 1})} # CRN preprocessing (fcrn, fs, _) = parse_crn_string(fcrn) fcrn = split_reversible_reactions(fcrn) fcrn = [[Counter(part) for part in rxn] for rxn in fcrn] (icrn, _, _) = parse_crn_string(icrn) icrn = split_reversible_reactions(icrn) icrn = [[Counter(part) for part in rxn] for rxn in icrn] # NOTE: Correct behavior v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=pinter1, permissive='whole-graph') self.assertTrue(v) self.assertDictEqual(inter1, i1) v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=pinter1, permissive='loop-search') self.assertTrue(v) self.assertDictEqual(inter1, i1) v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=pinter1, permissive='depth-first') self.assertTrue(v) self.assertDictEqual(inter1, i1) v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=inter1, permissive='loop-search') self.assertTrue(v) self.assertDictEqual(inter1, i1) v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=inter1, permissive='whole-graph') self.assertTrue(v) self.assertDictEqual(inter1, i1) v, i1 = bisimulation.test(fcrn, icrn, fs, interpretation=inter1, permissive='depth-first') self.assertTrue(v) self.assertDictEqual(inter1, i1) v, i2 = bisimulation.test(fcrn, icrn, fs, interpretation=pinter2, permissive='loop-search') self.assertTrue(v) self.assertDictEqual(inter2, i2) v, i2 = bisimulation.test(fcrn, icrn, fs, interpretation=pinter2, permissive='whole-graph') self.assertTrue(v) self.assertDictEqual(inter2, i2) v, i2 = bisimulation.test(fcrn, icrn, fs, interpretation=pinter2, permissive='depth-first') self.assertTrue(v) self.assertDictEqual(inter2, i2)