def test_tuple_derivative2(self):

        cell = ('aa', 'v', 'aa')
        d_cell = derivative(cell, self.DGC)
        d_cell = [tp for c in d_cell for tp in expand_tuple_list(c)]

        self.assertEqual(d_cell, [('b', 'v', 'aa'), ('aa', 'v', 'b')])
    def test_chain_derivative2(self):

        chain = [('v', 'aa'), ('v', 'ab'), ('aa', 'v'), ('ab', 'v'),
                 ('a', 'a'), ('a', 'b'), ('b', 'a'), ('b', 'b')]
        d_chain = derivative(chain, self.DGC)
        d_chain = [tp for c in d_chain for tp in expand_tuple_list(c)]

        self.assertEqual(d_chain, [('v', 'b'), ('b', 'v')])
    def test_tuple_derivative(self):

        cell = ('m_{4}', 'm_{11}')
        d_cell = derivative(cell, self.BR3)

        self.assertEqual(d_cell, [(['v_{2}', 'v_{1}'], 'm_{11}'),
                                  ('m_{4}', ['v_{2}', 'v_{1}'])])

        d_cell = [tp for c in d_cell for tp in expand_tuple_list(c)]
        self.assertEqual(d_cell, [('v_{2}', 'm_{11}'), ('v_{1}', 'm_{11}'),
                                  ('m_{4}', 'v_{2}'), ('m_{4}', 'v_{1}')])
    def test_BR3_g3_h1_1(self):
        g3_h1_1a = [(['c_{3}', 'c_{7}'], ['v_{1}', 'v_{3}'], ['m_{4}']),
                    (['c_{3}', 'c_{7}'], ['c_{3}'], ['v_{1}', 'v_{3}']),
                    (['c_{3}', 'c_{7}'], ['m_{4}'], ['v_{1}', 'v_{2}']),
                    (['c_{3}', 'c_{7}'], ['v_{2}', 'v_{3}'], ['c_{3}'])]

        anti_g3_h1_1a = chain_integrate(g3_h1_1a, self.BR_C)

        self.assertIsNotNone(anti_g3_h1_1a)

        d_anti_g3_h1_1a = [dX for dXs in derivative(anti_g3_h1_1a, self.BR_C) for dX in expand_tuple_list(dXs)]
        d_anti_g3_h1_1a = list_mod(d_anti_g3_h1_1a)
        g3_h1_1a_exp = [x for xs in g3_h1_1a for x in expand_tuple_list(xs)]
        g3_h1_1a_exp = list_mod(g3_h1_1a_exp)
        self.assertSetEqual(set(d_anti_g3_h1_1a), set(g3_h1_1a_exp))
    def test_chain_derivative2(self):

        chain = [('v_{1}', 'm_{4}'), ('v_{2}', 'm_{4}'),
                 ('v_{1}', 'm_{11}'), ('v_{2}', 'm_{11}')]

        d_chain = derivative(chain, self.BR3)
        self.assertEqual(d_chain, [([], 'm_{4}'), ('v_{1}', ['v_{2}', 'v_{1}']), ([], 'm_{4}'), ('v_{2}', ['v_{2}', 'v_{1}']),
                                   ([], 'm_{11}'), ('v_{1}', ['v_{2}', 'v_{1}']), ([], 'm_{11}'), ('v_{2}', ['v_{2}', 'v_{1}'])])

        d_chain = [tp for c in d_chain for tp in expand_tuple_list(c)]

        self.assertEqual(d_chain, [('v_{1}', 'v_{2}'), ('v_{1}', 'v_{1}'), ('v_{2}', 'v_{2}'), ('v_{2}', 'v_{1}'),
                                   ('v_{1}', 'v_{2}'), ('v_{1}', 'v_{1}'), ('v_{2}', 'v_{2}'), ('v_{2}', 'v_{1}')])

        d_chain = list_mod(d_chain)
        self.assertFalse(d_chain)
    def test_expand_then_factor(self):
        chain = expand_tuple_list((['m_{4}', 'm_{11}'], ['c_{3}', 'c_{7}'], ['t_{5}', 't_{6}', 't_{7}', 't_{8}']))

        result = factorize_cycles(chain, self.BR_C)
        result = [tuple([set(tp_cmp) for tp_cmp in x]) for x in result]
        self.assertEqual(result, [({'m_{4}', 'm_{11}'}, {'c_{3}', 'c_{7}'}, {'t_{5}', 't_{6}', 't_{7}', 't_{8}'})])
 def test_counts(self):
     self.assertEqual(len(expand_tuple_list((range(3), range(3)))), 9)
     self.assertEqual(len(expand_tuple_list((range(40), range(5)))), 200)
     self.assertEqual(len(expand_tuple_list((range(10), range(11), range(12)))), 1320)
     self.assertEqual(len(expand_tuple_list((range(1), range(2), range(3), range(4), range(5)))), 120)
 def test_three_tuple(self):
     tp_list = ([1, 2], [1, 2, 3], [5, 6])
     expected = [(1, 1, 5), (1, 1, 6), (1, 2, 5), (1, 2, 6), (1, 3, 5), (1, 3, 6),
                 (2, 1, 5), (2, 1, 6), (2, 2, 5), (2, 2, 6), (2, 3, 5), (2, 3, 6)]
     self.assertEqual(expand_tuple_list(tp_list), expected)
 def test_two_tuple(self):
     self.assertEqual(expand_tuple_list(([1], [1, 2])), [(1, 1), (1, 2)])
     self.assertEqual(expand_tuple_list(([1, 2], [1])), [(1, 1), (2, 1)])
     self.assertEqual(expand_tuple_list(([1, 2], [1, 2])), [(1, 1), (1, 2), (2, 1), (2, 2)])
 def test_simple_tuple(self):
     self.assertEqual([(1, 1)], expand_tuple_list(([1], [1])))