コード例 #1
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_is_alt_sym():
    G = DihedralGroup(10)
    assert G.is_alt_sym() is False
    S = SymmetricGroup(10)
    N_eps = 10
    _random_prec = {'N_eps': N_eps,
                    0: Permutation([[2], [1, 4], [0, 6, 7, 8, 9, 3, 5]]),
                    1: Permutation([[1, 8, 7, 6, 3, 5, 2, 9], [0, 4]]),
                    2: Permutation([[5, 8], [4, 7], [0, 1, 2, 3, 6, 9]]),
                    3: Permutation([[3], [0, 8, 2, 7, 4, 1, 6, 9, 5]]),
                    4: Permutation([[8], [4, 7, 9], [3, 6], [0, 5, 1, 2]]),
                    5: Permutation([[6], [0, 2, 4, 5, 1, 8, 3, 9, 7]]),
                    6: Permutation([[6, 9, 8], [4, 5], [1, 3, 7], [0, 2]]),
                    7: Permutation([[4], [0, 2, 9, 1, 3, 8, 6, 5, 7]]),
                    8: Permutation([[1, 5, 6, 3], [0, 2, 7, 8, 4, 9]]),
                    9: Permutation([[8], [6, 7], [2, 3, 4, 5], [0, 1, 9]])}
    assert S.is_alt_sym(_random_prec=_random_prec) is True
    A = AlternatingGroup(10)
    _random_prec = {'N_eps': N_eps,
                    0: Permutation([[1, 6, 4, 2, 7, 8, 5, 9, 3], [0]]),
                    1: Permutation([[1], [0, 5, 8, 4, 9, 2, 3, 6, 7]]),
                    2: Permutation([[1, 9, 8, 3, 2, 5], [0, 6, 7, 4]]),
                    3: Permutation([[6, 8, 9], [4, 5], [1, 3, 7, 2], [0]]),
                    4: Permutation([[8], [5], [4], [2, 6, 9, 3], [1], [0, 7]]),
                    5: Permutation([[3, 6], [0, 8, 1, 7, 5, 9, 4, 2]]),
                    6: Permutation([[5], [2, 9], [1, 8, 3], [0, 4, 7, 6]]),
                    7: Permutation([[1, 8, 4, 7, 2, 3], [0, 6, 9, 5]]),
                    8: Permutation([[5, 8, 7], [3], [1, 4, 2, 6], [0, 9]]),
                    9: Permutation([[4, 9, 6], [3, 8], [1, 2], [0, 5, 7]])}
    assert A.is_alt_sym(_random_prec=_random_prec) is False
コード例 #2
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_center():
    # the center of the dihedral group D_n is of order 2 for even n
    for i in (4, 6, 10):
        D = DihedralGroup(i)
        assert (D.center()).order() == 2
    # the center of the dihedral group D_n is of order 1 for odd n>2
    for i in (3, 5, 7):
        D = DihedralGroup(i)
        assert (D.center()).order() == 1
    # the center of an abelian group is the group itself
    for i in (2, 3, 5):
        for j in (1, 5, 7):
            for k in (1, 1, 11):
                G = AbelianGroup(i, j, k)
                assert G.center().is_subgroup(G)
    # the center of a nonabelian simple group is trivial
    for i in(1, 5, 9):
        A = AlternatingGroup(i)
        assert (A.center()).order() == 1
    # brute-force verifications
    D = DihedralGroup(5)
    A = AlternatingGroup(3)
    C = CyclicGroup(4)
    G.is_subgroup(D*A*C)
    assert _verify_centralizer(G, G)
コード例 #3
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_commutator():
    # the commutator of the trivial group and the trivial group is trivial
    S = SymmetricGroup(3)
    triv = PermutationGroup([Permutation([0, 1, 2])])
    assert S.commutator(triv, triv).is_subgroup(triv)
    # the commutator of the trivial group and any other group is again trivial
    A = AlternatingGroup(3)
    assert S.commutator(triv, A).is_subgroup(triv)
    # the commutator is commutative
    for i in (3, 4, 5):
        S = SymmetricGroup(i)
        A = AlternatingGroup(i)
        D = DihedralGroup(i)
        assert S.commutator(A, D).is_subgroup(S.commutator(D, A))
    # the commutator of an abelian group is trivial
    S = SymmetricGroup(7)
    A1 = AbelianGroup(2, 5)
    A2 = AbelianGroup(3, 4)
    triv = PermutationGroup([Permutation([0, 1, 2, 3, 4, 5, 6])])
    assert S.commutator(A1, A1).is_subgroup(triv)
    assert S.commutator(A2, A2).is_subgroup(triv)
    # examples calculated by hand
    S = SymmetricGroup(3)
    A = AlternatingGroup(3)
    assert S.commutator(A, S).is_subgroup(A)
コード例 #4
0
ファイル: test_perm_groups.py プロジェクト: diofant/diofant
def test_PermutationGroup():
    assert PermutationGroup() == PermutationGroup(Permutation())

    a = Permutation(1, 2)
    b = Permutation(2, 3, 1)
    G = PermutationGroup(a, b, degree=5)
    assert G.contains(G[0])

    A = AlternatingGroup(4)
    A.schreier_sims()
    assert A.base == [0, 1]
    assert A.basic_stabilizers == [
        PermutationGroup(Permutation(0, 1, 2), Permutation(1, 2, 3)),
        PermutationGroup(Permutation(1, 2, 3))
    ]

    D = DihedralGroup(12)
    assert D.is_primitive(randomized=False) is False

    D = DihedralGroup(10)
    assert D.is_primitive() is False

    p = Permutation(0, 1, 2, 3, 4, 5)
    G1 = PermutationGroup([Permutation(0, 1, 2), Permutation(0, 1)])
    G2 = PermutationGroup([Permutation(0, 2), Permutation(0, 1, 2)])
    G3 = PermutationGroup([p, p**2])
    assert G1.order() == G2.order() == G3.order() == 6
    assert G1.is_subgroup(G2) is True
    assert G1.is_subgroup(G3) is False

    a, b = [Permutation([1, 0, 3, 2]), Permutation([1, 3, 0, 2])]
    G = PermutationGroup([a, b])
    assert G.make_perm([0, 1, 0]) == Permutation(0, 2, 3, 1)

    S = SymmetricGroup(5)
    base, strong_gens = S.schreier_sims_random()
    assert _verify_bsgs(S, base, strong_gens)

    D = DihedralGroup(4)
    assert D.strong_gens == [
        Permutation(0, 1, 2, 3),
        Permutation(0, 3)(1, 2),
        Permutation(1, 3)
    ]

    a = Permutation([1, 2, 0])
    b = Permutation([1, 0, 2])
    G = PermutationGroup([a, b])
    assert G.transitivity_degree == 3

    a = Permutation([1, 2, 0, 4, 5, 6, 3])
    G = PermutationGroup([a])
    assert G.orbit(0) == {0, 1, 2}
    assert G.orbit([0, 4], 'union') == {0, 1, 2, 3, 4, 5, 6}
    assert G.orbit([0, 4], 'sets') == {(0, 3), (0, 4), (0, 5), (0, 6), (1, 3),
                                       (1, 4), (1, 5), (1, 6), (2, 3), (2, 4),
                                       (2, 5), (2, 6)}
    assert G.orbit([0, 4], 'tuples') == {(0, 3), (0, 4), (0, 5), (0, 6),
                                         (1, 3), (1, 4), (1, 5), (1, 6),
                                         (2, 3), (2, 4), (2, 5), (2, 6)}
コード例 #5
0
def test_verify_normal_closure():
    # verified by GAP
    S = SymmetricGroup(3)
    A = AlternatingGroup(3)
    assert _verify_normal_closure(S, A, closure=A)
    S = SymmetricGroup(5)
    A = AlternatingGroup(5)
    C = CyclicGroup(5)
    assert _verify_normal_closure(S, A, closure=A)
    assert _verify_normal_closure(S, C, closure=A)
コード例 #6
0
def test_AlternatingGroup():
    G = AlternatingGroup(5)
    elements = list(G.generate())
    assert len(elements) == 60
    assert [perm.is_even for perm in elements] == [True] * 60
    H = AlternatingGroup(1)
    assert H.order() == 1
    L = AlternatingGroup(2)
    assert L.order() == 1
コード例 #7
0
ファイル: test_util.py プロジェクト: naveensaigit/diofant
def test_handle_precomputed_bsgs():
    A = AlternatingGroup(5)
    A.schreier_sims()
    base = A.base
    strong_gens = A.strong_gens
    result = _handle_precomputed_bsgs(base, strong_gens)
    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
    assert strong_gens_distr == result[2]
    transversals = result[0]
    orbits = result[1]
    base_len = len(base)
    for i in range(base_len):
        for el in orbits[i]:
            assert transversals[i][el](base[i]) == el
            for j in range(i):
                assert transversals[i][el](base[j]) == base[j]
    order = 1
    for i in range(base_len):
        order *= len(orbits[i])
    assert A.order() == order

    _, transversals = _orbits_transversals_from_bsgs(base, strong_gens_distr)
    assert transversals == _handle_precomputed_bsgs(base, strong_gens,
                                                    transversals)[0]
    assert transversals == _handle_precomputed_bsgs(
        base,
        strong_gens,
        transversals,
        basic_orbits=transversals,
        strong_gens_distr=strong_gens_distr)[0]

    D = DihedralGroup(3)
    D.schreier_sims()
    assert (_handle_precomputed_bsgs(D.base,
                                     D.strong_gens,
                                     basic_orbits=D.basic_orbits) == ([{
                                         0:
                                         Permutation(2),
                                         1:
                                         Permutation(0, 1, 2),
                                         2:
                                         Permutation(0, 2)
                                     }, {
                                         1:
                                         Permutation(2),
                                         2:
                                         Permutation(1, 2)
                                     }], [[0, 1, 2], [1, 2]], [[
                                         Permutation(0, 1, 2),
                                         Permutation(0, 2),
                                         Permutation(1, 2)
                                     ], [Permutation(1, 2)]]))
コード例 #8
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_lower_central_series():
    # the lower central series of the trivial group consists of the trivial
    # group
    triv = PermutationGroup([Permutation([0, 1, 2])])
    assert triv.lower_central_series()[0].is_subgroup(triv)
    # the lower central series of a simple group consists of the group itself
    for i in (5, 6, 7):
        A = AlternatingGroup(i)
        assert A.lower_central_series()[0].is_subgroup(A)
    # GAP-verified example
    S = SymmetricGroup(6)
    series = S.lower_central_series()
    assert len(series) == 2
    assert series[1].is_subgroup(AlternatingGroup(6))
コード例 #9
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_derived_series():
    # the derived series of the trivial group consists only of the trivial group
    triv = PermutationGroup([Permutation([0, 1, 2])])
    assert triv.derived_series()[0].is_subgroup(triv)
    # the derived series for a simple group consists only of the group itself
    for i in (5, 6, 7):
        A = AlternatingGroup(i)
        assert A.derived_series()[0].is_subgroup(A)
    # the derived series for S_4 is S_4 > A_4 > K_4 > triv
    S = SymmetricGroup(4)
    series = S.derived_series()
    assert series[1].is_subgroup(AlternatingGroup(4))
    assert series[2].is_subgroup(DihedralGroup(2))
    assert series[3].is_trivial
コード例 #10
0
def test_verify_centralizer():
    # verified by GAP
    S = SymmetricGroup(3)
    A = AlternatingGroup(3)
    triv = PermutationGroup([Permutation([0, 1, 2])])
    assert _verify_centralizer(S, S, centr=triv)
    assert _verify_centralizer(S, A, centr=A)
コード例 #11
0
ファイル: test_util.py プロジェクト: naveensaigit/diofant
def test_remove_gens():
    S = SymmetricGroup(10)
    base, strong_gens = S.schreier_sims_incremental()
    new_gens = _remove_gens(base, strong_gens)
    assert _verify_bsgs(S, base, new_gens) is True
    A = AlternatingGroup(7)
    base, strong_gens = A.schreier_sims_incremental()
    new_gens = _remove_gens(base, strong_gens)
    assert _verify_bsgs(A, base, new_gens) is True
    D = DihedralGroup(2)
    base, strong_gens = D.schreier_sims_incremental()
    new_gens = _remove_gens(base, strong_gens)
    assert _verify_bsgs(D, base, new_gens) is True
    D = DihedralGroup(2)
    base, strong_gens = D.schreier_sims_incremental()
    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
    _, transversals = _orbits_transversals_from_bsgs(base, strong_gens_distr)
    new_gens = _remove_gens(base, strong_gens, transversals, strong_gens_distr)
    assert _verify_bsgs(D, base, new_gens) is True
コード例 #12
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_is_nilpotent():
    # every abelian group is nilpotent
    for i in (1, 2, 3):
        C = CyclicGroup(i)
        Ab = AbelianGroup(i, i + 2)
        assert C.is_nilpotent
        assert Ab.is_nilpotent
    Ab = AbelianGroup(5, 7, 10)
    assert Ab.is_nilpotent
    # A_5 is not solvable and thus not nilpotent
    assert AlternatingGroup(5).is_nilpotent is False
コード例 #13
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_normal_closure():
    # the normal closure of the trivial group is trivial
    S = SymmetricGroup(3)
    identity = Permutation([0, 1, 2])
    closure = S.normal_closure(identity)
    assert closure.is_trivial
    # the normal closure of the entire group is the entire group
    A = AlternatingGroup(4)
    assert A.normal_closure(A).is_subgroup(A)
    # brute-force verifications for subgroups
    for i in (3, 4, 5):
        S = SymmetricGroup(i)
        A = AlternatingGroup(i)
        D = DihedralGroup(i)
        C = CyclicGroup(i)
        for gp in (A, D, C):
            assert _verify_normal_closure(S, gp)
    # brute-force verifications for all elements of a group
    for i in range(10):
        S = SymmetricGroup(5)
        elements = list(S.generate_dimino())
        for element in elements:
            assert _verify_normal_closure(S, element)
    # small groups
    small = []
    for i in (1, 2, 3):
        small.append(SymmetricGroup(i))
        small.append(AlternatingGroup(i))
        small.append(DihedralGroup(i))
        small.append(CyclicGroup(i))
    for gp in small:
        for gp2 in small:
            if gp2.is_subgroup(gp, 0) and gp2.degree == gp.degree:
                assert _verify_normal_closure(gp, gp2)
コード例 #14
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_centralizer():
    # the centralizer of the trivial group is the entire group
    S = SymmetricGroup(2)
    assert S.centralizer(Permutation(list(range(2)))).is_subgroup(S)
    A = AlternatingGroup(5)
    assert A.centralizer(Permutation(list(range(5)))).is_subgroup(A)
    # a centralizer in the trivial group is the trivial group itself
    triv = PermutationGroup([Permutation([0, 1, 2, 3])])
    D = DihedralGroup(4)
    assert triv.centralizer(D).is_subgroup(triv)
    # brute-force verifications for centralizers of groups
    for i in (4, 5, 6):
        S = SymmetricGroup(i)
        A = AlternatingGroup(i)
        C = CyclicGroup(i)
        D = DihedralGroup(i)
        for gp in (S, A, C, D):
            for gp2 in (S, A, C, D):
                if not gp2.is_subgroup(gp):
                    assert _verify_centralizer(gp, gp2)
    # verify the centralizer for all elements of several groups
    S = SymmetricGroup(5)
    elements = list(S.generate_dimino())
    for element in elements:
        assert _verify_centralizer(S, element)
    A = AlternatingGroup(5)
    elements = list(A.generate_dimino())
    for element in elements:
        assert _verify_centralizer(A, element)
    D = DihedralGroup(7)
    elements = list(D.generate_dimino())
    for element in elements:
        assert _verify_centralizer(D, element)
    # verify centralizers of small groups within small groups
    small = []
    for i in (1, 2, 3):
        small.append(SymmetricGroup(i))
        small.append(AlternatingGroup(i))
        small.append(DihedralGroup(i))
        small.append(CyclicGroup(i))
    for gp in small:
        for gp2 in small:
            if gp.degree == gp2.degree:
                assert _verify_centralizer(gp, gp2)
コード例 #15
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def test_schreier_sims_incremental():
    identity = Permutation([0, 1, 2, 3, 4])
    TrivialGroup = PermutationGroup([identity])
    base, strong_gens = TrivialGroup.schreier_sims_incremental(base=[0, 1, 2])
    assert _verify_bsgs(TrivialGroup, base, strong_gens) is True
    S = SymmetricGroup(5)
    base, strong_gens = S.schreier_sims_incremental(base=[0, 1, 2])
    assert _verify_bsgs(S, base, strong_gens) is True
    D = DihedralGroup(2)
    base, strong_gens = D.schreier_sims_incremental(base=[1])
    assert _verify_bsgs(D, base, strong_gens) is True
    A = AlternatingGroup(7)
    gens = A.generators[:]
    gen0 = gens[0]
    gen1 = gens[1]
    gen1 = rmul(gen1, ~gen0)
    gen0 = rmul(gen0, gen1)
    gen1 = rmul(gen0, gen1)
    base, strong_gens = A.schreier_sims_incremental(base=[0, 1], gens=gens)
    assert _verify_bsgs(A, base, strong_gens) is True
    C = CyclicGroup(11)
    gen = C.generators[0]
    base, strong_gens = C.schreier_sims_incremental(gens=[gen**3])
    assert _verify_bsgs(C, base, strong_gens) is True
コード例 #16
0
ファイル: test_perm_groups.py プロジェクト: fagan2888/diofant
def _subgroup_search(i, j, k):
    def prop_true(x):
        return True

    def prop_fix_points(x):
        return [x(point) for point in points] == points

    def prop_comm_g(x):
        return rmul(x, g) == rmul(g, x)

    def prop_even(x):
        return x.is_even

    for i in range(i, j, k):
        S = SymmetricGroup(i)
        A = AlternatingGroup(i)
        C = CyclicGroup(i)
        Sym = S.subgroup_search(prop_true)
        assert Sym.is_subgroup(S)
        Alt = S.subgroup_search(prop_even)
        assert Alt.is_subgroup(A)
        Sym = S.subgroup_search(prop_true, init_subgroup=C)
        assert Sym.is_subgroup(S)
        points = [7]
        assert S.stabilizer(7).is_subgroup(S.subgroup_search(prop_fix_points))
        points = [3, 4]
        assert S.stabilizer(3).stabilizer(4).is_subgroup(
            S.subgroup_search(prop_fix_points))
        points = [3, 5]
        fix35 = A.subgroup_search(prop_fix_points)
        points = [5]
        fix5 = A.subgroup_search(prop_fix_points)
        assert A.subgroup_search(prop_fix_points,
                                 init_subgroup=fix35).is_subgroup(fix5)
        base, strong_gens = A.schreier_sims_incremental()
        g = A.generators[0]
        comm_g = \
            A.subgroup_search(prop_comm_g, base=base, strong_gens=strong_gens)
        assert _verify_bsgs(comm_g, base, comm_g.generators) is True
        assert [prop_comm_g(gen) is True for gen in comm_g.generators]
コード例 #17
0
def test_naive_list_centralizer():
    # verified by GAP
    S = SymmetricGroup(3)
    A = AlternatingGroup(3)
    assert _naive_list_centralizer(S, S) == [Permutation([0, 1, 2])]
    assert PermutationGroup(_naive_list_centralizer(S, A)).is_subgroup(A)