def CoxeterGroup(cartan_type, implementation = None): """ INPUT: - ``cartan_type`` -- a cartan type (or coercible into; see :class:`CartanType`) - ``implementation`` -- "permutation", "matrix", "coxeter3", or None (default: None) Returns an implementation of the Coxeter group of type ``cartan_type``. EXAMPLES: If ``implementation`` is not specified, a permutation representation is returned whenever possible (finite irreducible Cartan type, with the GAP3 Chevie package available):: sage: W = CoxeterGroup(["A",2]) sage: W # optional - chevie Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)] Otherwise, a Weyl group is returned:: sage: W = CoxeterGroup(["A",3,1]) sage: W Weyl Group of type ['A', 3, 1] (as a matrix group acting on the root space) We now use the ``implementation`` option:: sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie sage: W # optional - chevie Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)] sage: W.category() # optional - chevie Join of Category of finite permutation groups and Category of finite coxeter groups sage: W = CoxeterGroup(["A",2], implementation = "matrix") sage: W Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space) sage: W = CoxeterGroup(["H",3], implementation = "matrix") Traceback (most recent call last): ... NotImplementedError: Coxeter group of type ['H', 3] as matrix group not implemented sage: W = CoxeterGroup(["A",4,1], implementation = "permutation") Traceback (most recent call last): ... NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented """ assert implementation in ["permutation", "matrix", "coxeter3", None] cartan_type = CartanType(cartan_type) if implementation is None: if cartan_type.is_finite() and cartan_type.is_irreducible() and is_chevie_available(): implementation = "permutation" else: implementation = "matrix" if implementation == "coxeter3": try: from sage.libs.coxeter3.coxeter_group import CoxeterGroup except ImportError: raise RuntimeError, "coxeter3 must be installed" else: return CoxeterGroup(cartan_type) if implementation == "permutation" and is_chevie_available() and \ cartan_type.is_finite() and cartan_type.is_irreducible(): return CoxeterGroupAsPermutationGroup(cartan_type) elif implementation == "matrix" and cartan_type.is_crystallographic(): return WeylGroup(cartan_type) else: raise NotImplementedError, "Coxeter group of type %s as %s group not implemented "%(cartan_type, implementation)
def Shi(self, data, K=QQ, names=None, m=1): r""" Return the Shi arrangement. INPUT: - ``data`` -- either an integer or a Cartan type (or coercible into; see "CartanType") - ``K`` -- field (default:``QQ``) - ``names`` -- tuple of strings or ``None`` (default); the variable names for the ambient space - ``m`` -- integer (default: 1) OUTPUT: - If ``data`` is an integer `n`, return the Shi arrangement in dimension `n`, i.e. the set of `n(n-1)` hyperplanes: `\{ x_i - x_j = 0,1 : 1 \leq i \leq j \leq n \}`. This corresponds to the Shi arrangement of Cartan type `A_{n-1}`. - If ``data`` is a Cartan type, return the Shi arrangement of given type. - If `m > 1`, return the `m`-extended Shi arrangement of given type. The `m`-extended Shi arrangement of a given crystallographic Cartan type is defined by the inner product `\langle a,x \rangle = k` for `-m < k \leq m` and `a \in \Phi^+` is a positive root of the root system `\Phi`. EXAMPLES:: sage: hyperplane_arrangements.Shi(4) Arrangement of 12 hyperplanes of dimension 4 and rank 3 sage: hyperplane_arrangements.Shi("A3") Arrangement of 12 hyperplanes of dimension 4 and rank 3 sage: hyperplane_arrangements.Shi("A3",m=2) Arrangement of 24 hyperplanes of dimension 4 and rank 3 sage: hyperplane_arrangements.Shi("B4") Arrangement of 32 hyperplanes of dimension 4 and rank 4 sage: hyperplane_arrangements.Shi("B4",m=3) Arrangement of 96 hyperplanes of dimension 4 and rank 4 sage: hyperplane_arrangements.Shi("C3") Arrangement of 18 hyperplanes of dimension 3 and rank 3 sage: hyperplane_arrangements.Shi("D4",m=3) Arrangement of 72 hyperplanes of dimension 4 and rank 4 sage: hyperplane_arrangements.Shi("E6") Arrangement of 72 hyperplanes of dimension 8 and rank 6 sage: hyperplane_arrangements.Shi("E6",m=2) Arrangement of 144 hyperplanes of dimension 8 and rank 6 If the Cartan type is not crystallographic, the Shi arrangement is not defined:: sage: hyperplane_arrangements.Shi("H4") Traceback (most recent call last): ... NotImplementedError: Shi arrangements are not defined for non crystallographic Cartan types The characteristic polynomial is pre-computed using the results of [Ath1996]_:: sage: hyperplane_arrangements.Shi("A3").characteristic_polynomial() x^4 - 12*x^3 + 48*x^2 - 64*x sage: hyperplane_arrangements.Shi("A3",m=2).characteristic_polynomial() x^4 - 24*x^3 + 192*x^2 - 512*x sage: hyperplane_arrangements.Shi("C3").characteristic_polynomial() x^3 - 18*x^2 + 108*x - 216 sage: hyperplane_arrangements.Shi("E6").characteristic_polynomial() x^8 - 72*x^7 + 2160*x^6 - 34560*x^5 + 311040*x^4 - 1492992*x^3 + 2985984*x^2 sage: hyperplane_arrangements.Shi("B4",m=3).characteristic_polynomial() x^4 - 96*x^3 + 3456*x^2 - 55296*x + 331776 TESTS:: sage: h = hyperplane_arrangements.Shi(4) sage: h.characteristic_polynomial() x^4 - 12*x^3 + 48*x^2 - 64*x sage: h.characteristic_polynomial.clear_cache() # long time sage: h.characteristic_polynomial() # long time x^4 - 12*x^3 + 48*x^2 - 64*x sage: h = hyperplane_arrangements.Shi("A3",m=2) sage: h.characteristic_polynomial() x^4 - 24*x^3 + 192*x^2 - 512*x sage: h.characteristic_polynomial.clear_cache() sage: h.characteristic_polynomial() x^4 - 24*x^3 + 192*x^2 - 512*x sage: h = hyperplane_arrangements.Shi("B3",m=3) sage: h.characteristic_polynomial() x^3 - 54*x^2 + 972*x - 5832 sage: h.characteristic_polynomial.clear_cache() sage: h.characteristic_polynomial() x^3 - 54*x^2 + 972*x - 5832 """ if data in NN: cartan_type = CartanType(["A", data - 1]) else: cartan_type = CartanType(data) if not cartan_type.is_crystallographic(): raise NotImplementedError( "Shi arrangements are not defined for non crystallographic Cartan types" ) n = cartan_type.rank() h = cartan_type.coxeter_number() Ra = RootSystem(cartan_type).ambient_space() PR = Ra.positive_roots() d = Ra.dimension() H = make_parent(K, d, names) x = H.gens() hyperplanes = [] for a in PR: for const in range(-m + 1, m + 1): hyperplanes.append(sum(a[j] * x[j] for j in range(d)) - const) A = H(*hyperplanes) x = polygen(QQ, 'x') charpoly = x**(d - n) * (x - m * h)**n A.characteristic_polynomial.set_cache(charpoly) return A
def CoxeterGroup(data, implementation="reflection", base_ring=None, index_set=None): """ Return an implementation of the Coxeter group given by ``data``. INPUT: - ``data`` -- a Cartan type (or coercible into; see :class:`CartanType`) or a Coxeter matrix or graph - ``implementation`` -- (default: ``'reflection'``) can be one of the following: * ``'permutation'`` - as a permutation representation * ``'matrix'`` - as a Weyl group (as a matrix group acting on the root space); if this is not implemented, this uses the "reflection" implementation * ``'coxeter3'`` - using the coxeter3 package * ``'reflection'`` - as elements in the reflection representation; see :class:`~sage.groups.matrix_gps.coxeter_groups.CoxeterMatrixGroup` - ``base_ring`` -- (optional) the base ring for the ``'reflection'`` implementation - ``index_set`` -- (optional) the index set for the ``'reflection'`` implementation EXAMPLES: Now assume that ``data`` represents a Cartan type. If ``implementation`` is not specified, the reflection representation is returned:: sage: W = CoxeterGroup(["A",2]) sage: W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3] [3 1] sage: W = CoxeterGroup(["A",3,1]); W Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2 3] [3 1 3 2] [2 3 1 3] [3 2 3 1] sage: W = CoxeterGroup(['H',3]); W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] We now use the ``implementation`` option:: sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie sage: W # optional - chevie Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)] sage: W.category() # optional - chevie Join of Category of finite permutation groups and Category of finite coxeter groups sage: W = CoxeterGroup(["A",2], implementation="matrix") sage: W Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space) sage: W = CoxeterGroup(["H",3], implementation="matrix") sage: W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] sage: W = CoxeterGroup(["H",3], implementation="reflection") sage: W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] sage: W = CoxeterGroup(["A",4,1], implementation="permutation") Traceback (most recent call last): ... NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented We use the different options for the "reflection" implementation:: sage: W = CoxeterGroup(["H",3], implementation="reflection", base_ring=RR) sage: W Finite Coxeter group over Real Field with 53 bits of precision with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] sage: W = CoxeterGroup([[1,10],[10,1]], implementation="reflection", index_set=['a','b'], base_ring=SR) sage: W Finite Coxeter group over Symbolic Ring with Coxeter matrix: [ 1 10] [10 1] TESTS:: sage: W = groups.misc.CoxeterGroup(["H",3]) """ if implementation not in [ "permutation", "matrix", "coxeter3", "reflection", None ]: raise ValueError("invalid type implementation") try: cartan_type = CartanType(data) except ( TypeError, ValueError ): # If it is not a Cartan type, try to see if we can represent it as a matrix group return CoxeterMatrixGroup(data, base_ring, index_set) if implementation is None: implementation = "matrix" if implementation == "reflection": return CoxeterMatrixGroup(cartan_type, base_ring, index_set) if implementation == "coxeter3": try: from sage.libs.coxeter3.coxeter_group import CoxeterGroup except ImportError: raise RuntimeError("coxeter3 must be installed") else: return CoxeterGroup(cartan_type) if implementation == "permutation" and is_chevie_available() and \ cartan_type.is_finite() and cartan_type.is_irreducible(): return CoxeterGroupAsPermutationGroup(cartan_type) elif implementation == "matrix": if cartan_type.is_crystallographic(): return WeylGroup(cartan_type) return CoxeterMatrixGroup(cartan_type, base_ring, index_set) raise NotImplementedError( "Coxeter group of type {} as {} group not implemented".format( cartan_type, implementation))
def CoxeterGroup(data, implementation="reflection", base_ring=None, index_set=None): """ Return an implementation of the Coxeter group given by ``data``. INPUT: - ``data`` -- a Cartan type (or coercible into; see :class:`CartanType`) or a Coxeter matrix or graph - ``implementation`` -- (default: ``'reflection'``) can be one of the following: * ``'permutation'`` - as a permutation representation * ``'matrix'`` - as a Weyl group (as a matrix group acting on the root space); if this is not implemented, this uses the "reflection" implementation * ``'coxeter3'`` - using the coxeter3 package * ``'reflection'`` - as elements in the reflection representation; see :class:`~sage.groups.matrix_gps.coxeter_groups.CoxeterMatrixGroup` - ``base_ring`` -- (optional) the base ring for the ``'reflection'`` implementation - ``index_set`` -- (optional) the index set for the ``'reflection'`` implementation EXAMPLES: Now assume that ``data`` represents a Cartan type. If ``implementation`` is not specified, the reflection representation is returned:: sage: W = CoxeterGroup(["A",2]) sage: W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3] [3 1] sage: W = CoxeterGroup(["A",3,1]); W Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2 3] [3 1 3 2] [2 3 1 3] [3 2 3 1] sage: W = CoxeterGroup(['H',3]); W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] We now use the ``implementation`` option:: sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie sage: W # optional - chevie Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)] sage: W.category() # optional - chevie Join of Category of finite permutation groups and Category of finite coxeter groups sage: W = CoxeterGroup(["A",2], implementation="matrix") sage: W Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space) sage: W = CoxeterGroup(["H",3], implementation="matrix") sage: W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] sage: W = CoxeterGroup(["H",3], implementation="reflection") sage: W Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] sage: W = CoxeterGroup(["A",4,1], implementation="permutation") Traceback (most recent call last): ... NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented We use the different options for the "reflection" implementation:: sage: W = CoxeterGroup(["H",3], implementation="reflection", base_ring=RR) sage: W Finite Coxeter group over Real Field with 53 bits of precision with Coxeter matrix: [1 3 2] [3 1 5] [2 5 1] sage: W = CoxeterGroup([[1,10],[10,1]], implementation="reflection", index_set=['a','b'], base_ring=SR) sage: W Finite Coxeter group over Symbolic Ring with Coxeter matrix: [ 1 10] [10 1] TESTS:: sage: W = groups.misc.CoxeterGroup(["H",3]) """ if implementation not in ["permutation", "matrix", "coxeter3", "reflection", None]: raise ValueError("invalid type implementation") try: cartan_type = CartanType(data) except (TypeError, ValueError): # If it is not a Cartan type, try to see if we can represent it as a matrix group return CoxeterMatrixGroup(data, base_ring, index_set) if implementation is None: implementation = "matrix" if implementation == "reflection": return CoxeterMatrixGroup(cartan_type, base_ring, index_set) if implementation == "coxeter3": try: from sage.libs.coxeter3.coxeter_group import CoxeterGroup except ImportError: raise RuntimeError("coxeter3 must be installed") else: return CoxeterGroup(cartan_type) if implementation == "permutation" and is_chevie_available() and \ cartan_type.is_finite() and cartan_type.is_irreducible(): return CoxeterGroupAsPermutationGroup(cartan_type) elif implementation == "matrix": if cartan_type.is_crystallographic(): return WeylGroup(cartan_type) return CoxeterMatrixGroup(cartan_type, base_ring, index_set) raise NotImplementedError("Coxeter group of type {} as {} group not implemented".format(cartan_type, implementation))
def CoxeterGroup(cartan_type, implementation=None): """ INPUT: - ``cartan_type`` -- a cartan type (or coercible into; see :class:`CartanType`) - ``implementation`` -- "permutation", "matrix", "coxeter3", or None (default: None) Returns an implementation of the Coxeter group of type ``cartan_type``. EXAMPLES: If ``implementation`` is not specified, a permutation representation is returned whenever possible (finite irreducible Cartan type, with the GAP3 Chevie package available):: sage: W = CoxeterGroup(["A",2]) sage: W # optional - chevie Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)] Otherwise, a Weyl group is returned:: sage: W = CoxeterGroup(["A",3,1]) sage: W Weyl Group of type ['A', 3, 1] (as a matrix group acting on the root space) We now use the ``implementation`` option:: sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie sage: W # optional - chevie Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)] sage: W.category() # optional - chevie Join of Category of finite permutation groups and Category of finite coxeter groups sage: W = CoxeterGroup(["A",2], implementation = "matrix") sage: W Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space) sage: W = CoxeterGroup(["H",3], implementation = "matrix") Traceback (most recent call last): ... NotImplementedError: Coxeter group of type ['H', 3] as matrix group not implemented sage: W = CoxeterGroup(["A",4,1], implementation = "permutation") Traceback (most recent call last): ... NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented """ assert implementation in ["permutation", "matrix", "coxeter3", None] cartan_type = CartanType(cartan_type) if implementation is None: if cartan_type.is_finite() and cartan_type.is_irreducible( ) and is_chevie_available(): implementation = "permutation" else: implementation = "matrix" if implementation == "coxeter3": try: from sage.libs.coxeter3.coxeter_group import CoxeterGroup except ImportError: raise RuntimeError, "coxeter3 must be installed" else: return CoxeterGroup(cartan_type) if implementation == "permutation" and is_chevie_available() and \ cartan_type.is_finite() and cartan_type.is_irreducible(): return CoxeterGroupAsPermutationGroup(cartan_type) elif implementation == "matrix" and cartan_type.is_crystallographic(): return WeylGroup(cartan_type) else: raise NotImplementedError, "Coxeter group of type %s as %s group not implemented " % ( cartan_type, implementation)