Beispiel #1
0
    def __init__(self, number_field, names=None):
        r"""
        Create a Galois group.

        EXAMPLES::

            sage: QuadraticField(-23,'a').galois_group()
            Galois group of Number Field in a with defining polynomial x^2 + 23
            sage: NumberField(x^3 - 2, 'b').galois_group()
            Traceback (most recent call last):
            ...
            TypeError: You must specify the name of the generator.
            sage: NumberField(x^3 - 2, 'b').galois_group(names="c")
            Galois group of Galois closure in c of Number Field in b with defining polynomial x^3 - 2
        """
        self._number_field = number_field

        if not number_field.is_galois():
            self._galois_closure, self._gc_map = number_field.galois_closure(names=names, map=True)
        else:
            self._galois_closure, self._gc_map = (number_field, number_field.hom(number_field.gen(), number_field))

        self._pari_gc = self._galois_closure.__pari__()

        g = self._pari_gc.galoisinit()
        self._pari_data = g

        # Sort the vector of permutations using .list() as key to avoid errors
        # from using comparison operators on non-scalar PARI objects.
        PermutationGroup_generic.__init__(self,
                                          sorted(g[6], key=lambda x: x.list()))

        # PARI computes all the elements of self anyway, so we might as well store them
        self._elts = sorted([self(x, check=False) for x in g[5]])
Beispiel #2
0
    def __init__(self, ambient, elts):
        r"""
        Create a subgroup of a Galois group with the given elements. It is generally better to
        use the subgroup() method of the parent group.

        EXAMPLES::

            sage: from sage.rings.number_field.galois_group import GaloisGroup_subgroup
            sage: G = NumberField(x^3 - x - 1, 'a').galois_closure('b').galois_group()
            sage: GaloisGroup_subgroup( G, [ G(1), G([(1,2,3),(4,5,6)]), G([(1,3,2),(4,6,5)])])
            Subgroup [(), (1,2,3)(4,5,6), (1,3,2)(4,6,5)] of Galois group of Number Field in b with defining polynomial x^6 - 6*x^4 + 9*x^2 + 23

        TESTS:

        Check that :trac:`17664` is fixed::

            sage: L.<c> = QuadraticField(-1)
            sage: P = L.primes_above(5)[0]
            sage: G = L.galois_group()
            sage: H = G.decomposition_group(P)
            sage: H.domain()
            {1, 2}
            sage: G.artin_symbol(P)
            ()
        """
        # XXX This should be fixed so that this can use GaloisGroup_v2.__init__
        PermutationGroup_generic.__init__(self, elts, canonicalize=True,
                                          domain=ambient.domain())
        self._ambient = ambient
        self._number_field = ambient.number_field()
        self._galois_closure = ambient._galois_closure
        self._pari_data = ambient._pari_data
        self._pari_gc = ambient._pari_gc
        self._gc_map = ambient._gc_map
        self._elts = elts
Beispiel #3
0
    def __init__(self, cartan_type):
        """
        Construct this Coxeter group as a Sage permutation group, by
        fetching the permutation representation of the generators from
        Chevie's database.

        TESTS::

            sage: from sage.combinat.root_system.coxeter_group import CoxeterGroupAsPermutationGroup
            sage: W = CoxeterGroupAsPermutationGroup(CartanType(["H",3])) # optional - chevie
            sage: TestSuite(W).run()             # optional - chevie
        """
        assert cartan_type.is_finite()
        assert cartan_type.is_irreducible()
        self._semi_simple_rank = cartan_type.n
        from sage.interfaces.gap3 import gap3
        gap3._start()
        gap3.load_package("chevie")
        self._gap_group = gap3('CoxeterGroup("%s",%s)'%(cartan_type.letter,cartan_type.n))
        # Following #9032, x.N is an alias for x.numerical_approx in every Sage object ...
        N = self._gap_group.__getattr__("N").sage()
        generators = [str(x) for x in self._gap_group.generators]
        self._is_positive_root = [None] + [ True ] * N + [False]*N
        PermutationGroup_generic.__init__(self, gens = generators,
                                          category = Category.join([FinitePermutationGroups(), FiniteCoxeterGroups()]))
Beispiel #4
0
    def __init__(self, cartan_type, prefix):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: W = WeylGroup(['F',4], implementation="permutation")
            sage: TestSuite(W).run()
        """
        self._cartan_type = cartan_type
        self._index_set = cartan_type.index_set()
        self._index_set_inverse = {
            ii: i
            for i, ii in enumerate(cartan_type.index_set())
        }
        self._reflection_representation = None
        self._prefix = prefix
        #from sage.libs.all import libgap
        Q = cartan_type.root_system().root_lattice()
        Phi = list(Q.positive_roots()) + [-x for x in Q.positive_roots()]
        p = [[Phi.index(x.weyl_action([i])) + 1 for x in Phi]
             for i in self._cartan_type.index_set()]
        cat = FiniteWeylGroups()
        if self._cartan_type.is_irreducible():
            cat = cat.Irreducible()
        cat = (cat, PermutationGroups().Finite())
        PermutationGroup_generic.__init__(self,
                                          gens=p,
                                          canonicalize=False,
                                          category=cat)
Beispiel #5
0
    def __init__(self, number_field, names=None):
        r"""
        Create a Galois group. 

        EXAMPLES::

            sage: QuadraticField(-23,'a').galois_group()
            Galois group of Number Field in a with defining polynomial x^2 + 23
            sage: NumberField(x^3 - 2, 'b').galois_group()
            Traceback (most recent call last):
            ...
            TypeError: You must specify the name of the generator.
            sage: NumberField(x^3 - 2, 'b').galois_group(names="c")
            Galois group of Galois closure in c of Number Field in b with defining polynomial x^3 - 2
        """

        from sage.groups.perm_gps.permgroup_element import PermutationGroupElement
        self._number_field = number_field

        if not number_field.is_galois():
            self._galois_closure, self._gc_map = number_field.galois_closure(names=names, map=True)
        else:
            self._galois_closure, self._gc_map = (number_field, number_field.hom(number_field.gen(), number_field))

        self._pari_gc = self._galois_closure._pari_()

        g = self._pari_gc.galoisinit()
        self._pari_data = g

        PermutationGroup_generic.__init__(self, sorted(g[6]))

        # PARI computes all the elements of self anyway, so we might as well store them
        self._elts = sorted([self(x, check=False) for x in g[5]])
Beispiel #6
0
    def __init__(self, ambient, elts):
        r"""
        Create a subgroup of a Galois group with the given elements. It is generally better to
        use the subgroup() method of the parent group.

        EXAMPLE::

            sage: from sage.rings.number_field.galois_group import GaloisGroup_subgroup
            sage: G = NumberField(x^3 - x - 1, 'a').galois_closure('b').galois_group()
            sage: GaloisGroup_subgroup( G, [ G(1), G([(1,2,3),(4,5,6)]), G([(1,3,2),(4,6,5)])])
            Subgroup [(), (1,2,3)(4,5,6), (1,3,2)(4,6,5)] of Galois group of Number Field in b with defining polynomial x^6 - 6*x^4 + 9*x^2 + 23

        TESTS:

        Check that :trac:`17664` is fixed::

            sage: L.<c> = QuadraticField(-1)
            sage: P = L.primes_above(5)[0]
            sage: G = L.galois_group()
            sage: H = G.decomposition_group(P)
            sage: H.domain()
            {1, 2}
            sage: G.artin_symbol(P)
            ()
        """
        #XXX: This should be fixed so that this can use GaloisGroup_v2.__init__
        PermutationGroup_generic.__init__(self, elts, canonicalize=True,
                                          domain=ambient.domain())
        self._ambient = ambient
        self._number_field = ambient.number_field()
        self._galois_closure = ambient._galois_closure
        self._pari_data = ambient._pari_data
        self._pari_gc = ambient._pari_gc
        self._gc_map = ambient._gc_map
        self._elts = elts
Beispiel #7
0
    def __init__(self, number_field, names=None):
        r"""
        Create a Galois group.

        EXAMPLES::

            sage: QuadraticField(-23,'a').galois_group()
            Galois group of Number Field in a with defining polynomial x^2 + 23
            sage: NumberField(x^3 - 2, 'b').galois_group()
            Traceback (most recent call last):
            ...
            TypeError: You must specify the name of the generator.
            sage: NumberField(x^3 - 2, 'b').galois_group(names="c")
            Galois group of Galois closure in c of Number Field in b with defining polynomial x^3 - 2
        """

        from sage.groups.perm_gps.permgroup_element import PermutationGroupElement
        self._number_field = number_field

        if not number_field.is_galois():
            self._galois_closure, self._gc_map = number_field.galois_closure(names=names, map=True)
        else:
            self._galois_closure, self._gc_map = (number_field, number_field.hom(number_field.gen(), number_field))

        self._pari_gc = self._galois_closure._pari_()

        g = self._pari_gc.galoisinit()
        self._pari_data = g

        # Sort the vector of permutations using cmp() to avoid errors
        # from using comparison operators on non-scalar PARI objects.
        PermutationGroup_generic.__init__(self, sorted(g[6], cmp=cmp))

        # PARI computes all the elements of self anyway, so we might as well store them
        self._elts = sorted([self(x, check=False) for x in g[5]])
Beispiel #8
0
    def __init__(self, cartan_type):
        """
        Construct this Coxeter group as a Sage permutation group, by
        fetching the permutation representation of the generators from
        Chevie's database.

        TESTS::

            sage: from sage.combinat.root_system.coxeter_group import CoxeterGroupAsPermutationGroup
            sage: W = CoxeterGroupAsPermutationGroup(CartanType(["H",3])) # optional - chevie
            sage: TestSuite(W).run()             # optional - chevie
        """
        assert cartan_type.is_finite()
        assert cartan_type.is_irreducible()
        self._semi_simple_rank = cartan_type.n
        from sage.interfaces.gap3 import gap3
        gap3._start()
        gap3.load_package("chevie")
        self._gap_group = gap3('CoxeterGroup("%s",%s)' %
                               (cartan_type.letter, cartan_type.n))
        # Following #9032, x.N is an alias for x.numerical_approx in every Sage object ...
        N = self._gap_group.__getattr__("N").sage()
        generators = [str(x) for x in self._gap_group.generators]
        self._is_positive_root = [None] + [True] * N + [False] * N
        PermutationGroup_generic.__init__(self,
                                          gens=generators,
                                          category=Category.join([
                                              FinitePermutationGroups(),
                                              FiniteCoxeterGroups()
                                          ]))
Beispiel #9
0
    def __init__(self, number_field, names=None):
        r"""
        Create a Galois group.

        EXAMPLES::

            sage: QuadraticField(-23,'a').galois_group()
            Galois group of Number Field in a with defining polynomial x^2 + 23
            sage: NumberField(x^3 - 2, 'b').galois_group()
            Traceback (most recent call last):
            ...
            TypeError: You must specify the name of the generator.
            sage: NumberField(x^3 - 2, 'b').galois_group(names="c")
            Galois group of Galois closure in c of Number Field in b with defining polynomial x^3 - 2

        TESTS::

            sage: F.<z> = CyclotomicField(7)
            sage: G = F.galois_group()

        We test that a method inherited from PermutationGroup_generic returns
        the right type of element (see :trac:`133`)::

            sage: phi = G.random_element()
            sage: type(phi) is G.element_class
            True
            sage: phi(z) # random
            z^3
        """
        self._number_field = number_field

        if not number_field.is_galois():
            self._galois_closure, self._gc_map = number_field.galois_closure(
                names=names, map=True)
        else:
            self._galois_closure, self._gc_map = (number_field,
                                                  number_field.hom(
                                                      number_field.gen(),
                                                      number_field))

        self._pari_gc = self._galois_closure.__pari__()

        g = self._pari_gc.galoisinit()
        self._pari_data = g

        # Sort the vector of permutations using .list() as key to avoid errors
        # from using comparison operators on non-scalar PARI objects.
        PermutationGroup_generic.__init__(self,
                                          sorted(g[6], key=lambda x: x.list()))

        # PARI computes all the elements of self anyway, so we might as well store them
        self._elts = sorted([self(x, check=False) for x in g[5]])
Beispiel #10
0
 def __init__(self, number_field, names=None, elts=None, print_mode='roots'):
     self._number_field = number_field
     self._subgroup_class = GaloisGroup_subgroup_v3                    ####
     self._non_galois_not_impl = False                        ####
     if not number_field.is_galois():
         self._galois_closure, self._gc_map = number_field.galois_closure(names=names, map=True)
     else:
         self._galois_closure, self._gc_map = (number_field, number_field.hom(number_field.gen(), number_field))
     self._pari_gc = self._galois_closure._pari_()
     g = self._pari_gc.galoisinit()
     self._pari_data = g
     
     self._print_mode = print_mode
     L = self._galois_closure
     _roots = tuple(r[0] for r in number_field.defining_polynomial().roots(L))
     #_roots = [r[0] for r in number_field.defining_polynomial().roots(L)]
     _elem_dict = {}
     for gamma in g[5]:
         _elem_dict[gamma] = g.galoispermtopol(gamma)
     self._as_auts = L.Hom(L)                            ####
     #self._elts = [self._as_auts(L(_elem_dict[gamma])) for gamma in g[5]]
     #self._elts_dict = dict([[g[5][i], self._elts[i]] for i in range(len(g[5]))])
     self._elts_dict = {}                                ####
     self._pari_dict = {}                                ####
     for gamma in g[5]:
         aut = self._as_auts(L(_elem_dict[gamma]))
         self._elts_dict[gamma] = aut
         self._pari_dict[aut] = gamma
     #self._elts_dict = dict([[gamma, self._as_auts(L(_elem_dict[gamma]))] for gamma in g[5]])
     _gens = []
     self._roots_to_homs_dict = {}                            ####
     self._homs_to_roots_dict = {}                            ####
     for gamma in g[6]:
         im_roots = [L(self._pari_gc.galoisapply(_elem_dict[gamma], r._pari_())) for r in _roots]
         _gens.append(im_roots)
         tup = tuple(im_roots)
         self._roots_to_homs_dict[repr(tup)] = self._elts_dict[gamma]
         self._homs_to_roots_dict[self._elts_dict[gamma]] = tup
     PermutationGroup_generic.__init__(self, _gens, domain=_roots)
     self._elts = []                                    ####
     for gamma in g[5]:
         self._elts.append(self._elts_dict[gamma])
         if gamma not in g[6]:
             im_roots = tuple(L(self._pari_gc.galoisapply(_elem_dict[gamma], r._pari_())) for r in _roots)
             self._roots_to_homs_dict[repr(im_roots)] = self._elts_dict[gamma]
             self._homs_to_roots_dict[self._elts_dict[gamma]] = im_roots
Beispiel #11
0
    def __init__(self, ambient, elts):
        r"""
        Return the subgroup of this Galois group generated by the
        given elements.

        It is generally better to use the :meth:`subgroup` method of
        the parent group.

        EXAMPLES::

            sage: from sage.rings.number_field.galois_group import GaloisGroup_subgroup
            sage: G = NumberField(x^3 - x - 1, 'a').galois_closure('b').galois_group()
            sage: GaloisGroup_subgroup( G, [ G(1), G([(1,2,3),(4,5,6)]), G([(1,3,2),(4,6,5)])])
            Subgroup [(), (1,2,3)(4,5,6), (1,3,2)(4,6,5)] of Galois group 6T2 ([3]2) with order 6 of x^6 - 6*x^4 + 9*x^2 + 23

        TESTS:

        Check that :trac:`17664` is fixed::

            sage: L.<c> = QuadraticField(-1)
            sage: P = L.primes_above(5)[0]
            sage: G = L.galois_group()
            sage: H = G.decomposition_group(P)
            sage: H.domain()
            {1, 2}
            sage: G.artin_symbol(P)
            ()
        """
        # XXX This should be fixed so that this can use GaloisGroup_v2.__init__
        PermutationGroup_generic.__init__(self,
                                          elts,
                                          canonicalize=True,
                                          domain=ambient.domain())
        self._ambient = ambient
        self._field = ambient.number_field()
        self._galois_closure = ambient._galois_closure
        self._pari_data = ambient._pari_data
        self._gc_map = ambient._gc_map
        self._default_algorithm = ambient._default_algorithm
        self._type = None  # Backward compatibility
        self._elts = sorted(self.iteration())
Beispiel #12
0
    def __init__(self, ambient, elts):
        r"""
        Create a subgroup of a Galois group with the given elements. It is generally better to
        use the subgroup() method of the parent group.

        EXAMPLE::

            sage: from sage.rings.number_field.galois_group import GaloisGroup_subgroup
            sage: G = NumberField(x^3 - x - 1, 'a').galois_closure('b').galois_group()
            sage: GaloisGroup_subgroup( G, [ G(1), G([(1,2,3),(4,5,6)]), G([(1,3,2),(4,6,5)])])
            Subgroup [(), (1,2,3)(4,5,6), (1,3,2)(4,6,5)] of Galois group of Number Field in b with defining polynomial x^6 - 6*x^4 + 9*x^2 + 23
        """
        #XXX: This should be fixed so that this can use GaloisGroup_v2.__init__
        PermutationGroup_generic.__init__(self, elts, canonicalize=True)
        self._ambient = ambient
        self._number_field = ambient.number_field()
        self._galois_closure = ambient._galois_closure
        self._pari_data = ambient._pari_data
        self._pari_gc = ambient._pari_gc
        self._gc_map = ambient._gc_map
        self._elts = elts
Beispiel #13
0
    def __init__(self, ambient, elts):
        r"""
        Create a subgroup of a Galois group with the given elements. It is generally better to 
        use the subgroup() method of the parent group.

        EXAMPLE::

            sage: from sage.rings.number_field.galois_group import GaloisGroup_subgroup
            sage: G = NumberField(x^3 - x - 1,'a').galois_closure('b').galois_group()
            sage: GaloisGroup_subgroup( G, [ G(1), G([(1,5,2),(3,4,6)]), G([(1,2,5),(3,6,4)])])
            Subgroup [(), (1,5,2)(3,4,6), (1,2,5)(3,6,4)] of Galois group of Number Field in b with defining polynomial x^6 - 14*x^4 + 20*x^3 + 49*x^2 - 140*x + 307
        """
        #XXX: This should be fixed so that this can use GaloisGroup_v2.__init__
        PermutationGroup_generic.__init__(self, elts, canonicalize = True)
        self._ambient = ambient
        self._number_field = ambient.number_field()
        self._galois_closure = ambient._galois_closure
        self._pari_data = ambient._pari_data
        self._pari_gc = ambient._pari_gc
        self._gc_map = ambient._gc_map
        self._elts = elts
Beispiel #14
0
    def __init__(self, cartan_type, prefix):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: W = WeylGroup(['F',4], implementation="permutation")
            sage: TestSuite(W).run()
        """
        self._cartan_type = cartan_type
        self._index_set = cartan_type.index_set()
        self._index_set_inverse = {ii: i for i,ii in enumerate(cartan_type.index_set())}
        self._reflection_representation = None
        self._prefix = prefix
        #from sage.libs.all import libgap
        Q = cartan_type.root_system().root_lattice()
        Phi = list(Q.positive_roots()) + [-x for x in Q.positive_roots()]
        p = [[Phi.index(x.weyl_action([i]))+1 for x in Phi]
             for i in self._cartan_type.index_set()]
        cat = FiniteWeylGroups()
        if self._cartan_type.is_irreducible():
            cat = cat.Irreducible()
        cat = (cat, PermutationGroups().Finite())
        PermutationGroup_generic.__init__(self, gens=p, canonicalize=False, category=cat)