def __classcall_private__(cls, ambient, virtualization, scaling_factors, contained=None, generators=None, cartan_type=None, index_set=None, category=None): """ Normalize arguments to ensure a unique representation. EXAMPLES:: sage: B = crystals.Tableaux(['B',3], shape=[1]) sage: C = crystals.Tableaux(['D',4], shape=[2]) sage: psi1 = B.crystal_morphism(C.module_generators) sage: V1 = psi1.image() sage: psi2 = B.crystal_morphism(C.module_generators, index_set=[1,2,3]) sage: V2 = psi2.image() sage: V1 is V2 True """ if cartan_type is None: cartan_type = ambient.cartan_type() else: cartan_type = CartanType(cartan_type) if index_set is None: index_set = cartan_type.index_set() if generators is None: generators = ambient.module_generators virtualization = Family(virtualization) scaling_factors = Family(scaling_factors) category = Crystals().or_subcategory(category) return super(Subcrystal, cls).__classcall__(cls, ambient, virtualization, scaling_factors, contained, tuple(generators), cartan_type, tuple(index_set), category)
def __classcall_private__(cls, ct, c=None, use_Y=None): r""" Normalize input to ensure a unique representation. INPUT: - ``ct`` -- a Cartan type EXAMPLES:: sage: M = crystals.infinity.NakajimaMonomials("E8") sage: M1 = crystals.infinity.NakajimaMonomials(['E',8]) sage: M2 = crystals.infinity.NakajimaMonomials(CartanType(['E',8])) sage: M is M1 is M2 True """ if use_Y is not None: from sage.misc.superseded import deprecation deprecation( 18895, 'use_Y is deprecated; use the set_variables() method instead.') else: use_Y = True cartan_type = CartanType(ct) n = len(cartan_type.index_set()) c = InfinityCrystalOfNakajimaMonomials._normalize_c(c, n) M = super(InfinityCrystalOfNakajimaMonomials, cls).__classcall__(cls, cartan_type, c) if not use_Y: M.set_variables('A') else: M.set_variables('Y') return M
def __classcall_private__(cls, ct, c=None, use_Y=None): r""" Normalize input to ensure a unique representation. INPUT: - ``ct`` -- a Cartan type EXAMPLES:: sage: M = crystals.infinity.NakajimaMonomials("E8") sage: M1 = crystals.infinity.NakajimaMonomials(['E',8]) sage: M2 = crystals.infinity.NakajimaMonomials(CartanType(['E',8])) sage: M is M1 is M2 True """ if use_Y is not None: from sage.misc.superseded import deprecation deprecation(18895, 'use_Y is deprecated; use the set_variables() method instead.') else: use_Y = True cartan_type = CartanType(ct) n = len(cartan_type.index_set()) c = InfinityCrystalOfNakajimaMonomials._normalize_c(c, n) M = super(InfinityCrystalOfNakajimaMonomials, cls).__classcall__(cls, cartan_type, c) if not use_Y: M.set_variables('A') else: M.set_variables('Y') return M
def __classcall_private__(cls, cartan_type, La=None, c=None): r""" Normalize input to ensure a unique representation. EXAMPLES:: sage: La = RootSystem(['E',8,1]).weight_lattice(extended=True).fundamental_weights() sage: M = crystals.NakajimaMonomials(['E',8,1],La[0]+La[8]) sage: M1 = crystals.NakajimaMonomials(CartanType(['E',8,1]),La[0]+La[8]) sage: M2 = crystals.NakajimaMonomials(['E',8,1],M.Lambda()[0] + M.Lambda()[8]) sage: M is M1 is M2 True """ if La is None: La = cartan_type cartan_type = La.parent().cartan_type() cartan_type = CartanType(cartan_type) if cartan_type.is_affine(): La = RootSystem(cartan_type).weight_lattice(extended=True)(La) else: La = RootSystem(cartan_type).weight_lattice()(La) n = len(cartan_type.index_set()) c = InfinityCrystalOfNakajimaMonomials._normalize_c(c, n) return super(CrystalOfNakajimaMonomials, cls).__classcall__(cls, cartan_type, La, c)
def __classcall_private__(cls, cartan_type, virtual, orbit): """ Normalize input to ensure a unique representation. EXAMPLES:: sage: from sage.combinat.root_system.type_folded import CartanTypeFolded sage: sigma_list = [[0], [1,5], [2,4], [3]] sage: fct1 = CartanTypeFolded(['C',3,1], ['A',5,1], sigma_list) sage: sigma_tuple = tuple(map(tuple, sigma_list)) sage: fct2 = CartanTypeFolded(CartanType(['C',3,1]), CartanType(['A',5,1]), sigma_tuple) sage: fct3 = CartanTypeFolded('C3~', 'A5~', {0:[0], 2:[2,4], 1:[1,5], 3:[3]}) sage: fct1 is fct2 and fct2 is fct3 True """ if isinstance(cartan_type, CartanTypeFolded): return cartan_type cartan_type = CartanType(cartan_type) virtual = CartanType(virtual) if isinstance(orbit, dict): i_set = cartan_type.index_set() orb = [None]*len(i_set) for k,v in six.iteritems(orbit): orb[i_set.index(k)] = tuple(v) orbit = tuple(orb) else: orbit = tuple(map(tuple, orbit)) return super(CartanTypeFolded, cls).__classcall__(cls, cartan_type, virtual, orbit)
def __classcall_private__(cls, cartan_type, virtual, orbit): """ Normalize input to ensure a unique representation. EXAMPLES:: sage: from sage.combinat.root_system.type_folded import CartanTypeFolded sage: sigma_list = [[0], [1,5], [2,4], [3]] sage: fct1 = CartanTypeFolded(['C',3,1], ['A',5,1], sigma_list) sage: sigma_tuple = tuple(map(tuple, sigma_list)) sage: fct2 = CartanTypeFolded(CartanType(['C',3,1]), CartanType(['A',5,1]), sigma_tuple) sage: fct3 = CartanTypeFolded('C3~', 'A5~', {0:[0], 2:[2,4], 1:[1,5], 3:[3]}) sage: fct1 is fct2 and fct2 is fct3 True """ if isinstance(cartan_type, CartanTypeFolded): return cartan_type cartan_type = CartanType(cartan_type) virtual = CartanType(virtual) if isinstance(orbit, dict): i_set = cartan_type.index_set() orb = [None] * len(i_set) for k, v in orbit.iteritems(): orb[i_set.index(k)] = tuple(v) orbit = tuple(orb) else: orbit = tuple(map(tuple, orbit)) return super(CartanTypeFolded, cls).__classcall__(cls, cartan_type, virtual, orbit)
def __classcall_private__(cls, cartan_type, seq=None): """ Normalize input to ensure a unique representation. EXAMPLES:: sage: B1 = crystals.infinity.PolyhedralRealization(['A',2]) sage: B2 = crystals.infinity.PolyhedralRealization(['A',2], [1,2]) sage: B1 is B2 True """ cartan_type = CartanType(cartan_type) if seq is None: seq = cartan_type.index_set() else: seq = tuple(seq) if set(seq) != set(cartan_type.index_set()): raise ValueError("the support of seq is not the index set") return super(InfinityCrystalAsPolyhedralRealization, cls).__classcall__(cls, cartan_type, seq)
def __classcall_private__(cls, cartan_type, seq=None): """ Normalize input to ensure a unique representation. EXAMPLES:: sage: B1 = crystals.infinity.PolyhedralRealization(['A',2]) sage: B2 = crystals.infinity.PolyhedralRealization(['A',2], [1,2]) sage: B1 is B2 True """ cartan_type = CartanType(cartan_type) if seq is None: seq = cartan_type.index_set() else: seq = tuple(seq) if set(seq) != set(cartan_type.index_set()): raise ValueError("the support of seq is not the index set") return super(InfinityCrystalAsPolyhedralRealization, cls).__classcall__(cls, cartan_type, seq)
def __classcall_private__(cls, ambient, virtualization, scaling_factors, contained=None, generators=None, cartan_type=None, index_set=None, category=None): """ Normalize arguments to ensure a unique representation. EXAMPLES:: sage: B = crystals.Tableaux(['B',3], shape=[1]) sage: C = crystals.Tableaux(['D',4], shape=[2]) sage: psi1 = B.crystal_morphism(C.module_generators) sage: V1 = psi1.image() sage: psi2 = B.crystal_morphism(C.module_generators, index_set=[1,2,3]) sage: V2 = psi2.image() sage: V1 is V2 True TESTS: Check that :trac:`19481` is fixed:: sage: from sage.combinat.crystals.virtual_crystal import VirtualCrystal sage: A = crystals.Tableaux(['A',3], shape=[2,1,1]) sage: V = VirtualCrystal(A, {1:(1,3), 2:(2,)}, {1:1, 2:2}, cartan_type=['C',2]) sage: V.category() Category of finite crystals """ if cartan_type is None: cartan_type = ambient.cartan_type() else: cartan_type = CartanType(cartan_type) if index_set is None: index_set = cartan_type.index_set() if generators is None: generators = ambient.module_generators virtualization = Family(virtualization) scaling_factors = Family(scaling_factors) category = Crystals().or_subcategory(category) if ambient in FiniteCrystals() or isinstance(contained, frozenset): category = category.Finite() return super(Subcrystal, cls).__classcall__(cls, ambient, virtualization, scaling_factors, contained, tuple(generators), cartan_type, tuple(index_set), category)
def __classcall_private__(cls, cartan_type, i): r""" Normalize input to ensure a unique representation. EXAMPLES:: sage: B = crystals.elementary.Elementary(['A',4], 3) sage: C = crystals.elementary.Elementary(CartanType("A4"), int(3)) sage: B is C True """ cartan_type = CartanType(cartan_type) if i not in cartan_type.index_set(): raise ValueError('i must an element of the index set.') return super(ElementaryCrystal, cls).__classcall__(cls, cartan_type, i)
def __classcall_private__(cls, cartan_type, i): r""" Normalize input to ensure a unique representation. EXAMPLES:: sage: B = crystals.elementary.Elementary(['A',4], 3) sage: C = crystals.elementary.Elementary(CartanType("A4"), int(3)) sage: B is C True """ cartan_type = CartanType(cartan_type) if i not in cartan_type.index_set(): raise ValueError('i must an element of the index set.') return super(ElementaryCrystal, cls).__classcall__(cls, cartan_type, i)
def __classcall_private__(cls, ambient, virtualization, scaling_factors, contained=None, generators=None, cartan_type=None, index_set=None, category=None): """ Normalize arguments to ensure a unique representation. EXAMPLES:: sage: B = crystals.Tableaux(['B',3], shape=[1]) sage: C = crystals.Tableaux(['D',4], shape=[2]) sage: psi1 = B.crystal_morphism(C.module_generators) sage: V1 = psi1.image() sage: psi2 = B.crystal_morphism(C.module_generators, index_set=[1,2,3]) sage: V2 = psi2.image() sage: V1 is V2 True TESTS: Check that :trac:`19481` is fixed:: sage: from sage.combinat.crystals.virtual_crystal import VirtualCrystal sage: A = crystals.Tableaux(['A',3], shape=[2,1,1]) sage: V = VirtualCrystal(A, {1:(1,3), 2:(2,)}, {1:1, 2:2}, cartan_type=['C',2]) sage: V.category() Category of finite crystals """ if cartan_type is None: cartan_type = ambient.cartan_type() else: cartan_type = CartanType(cartan_type) if index_set is None: index_set = cartan_type.index_set() if generators is None: generators = ambient.module_generators virtualization = Family(virtualization) scaling_factors = Family(scaling_factors) category = Crystals().or_subcategory(category) if ambient in FiniteCrystals() or isinstance(contained, frozenset): category = category.Finite() return super(Subcrystal, cls).__classcall__(cls, ambient, virtualization, scaling_factors, contained, tuple(generators), cartan_type, tuple(index_set), category)
def __classcall_private__(cls, ambient, virtualization, scaling_factors, contained=None, generators=None, cartan_type=None, index_set=None, category=None): """ Normalize arguments to ensure a unique representation. EXAMPLES:: sage: B = crystals.Tableaux(['B',3], shape=[1]) sage: C = crystals.Tableaux(['D',4], shape=[2]) sage: psi1 = B.crystal_morphism(C.module_generators) sage: V1 = psi1.image() sage: psi2 = B.crystal_morphism(C.module_generators, index_set=[1,2,3]) sage: V2 = psi2.image() sage: V1 is V2 True """ if cartan_type is None: cartan_type = ambient.cartan_type() else: cartan_type = CartanType(cartan_type) if index_set is None: index_set = cartan_type.index_set() if generators is None: generators = ambient.module_generators virtualization = Family(virtualization) scaling_factors = Family(scaling_factors) category = Crystals().or_subcategory(category) return super(Subcrystal, cls).__classcall__(cls, ambient, virtualization, scaling_factors, contained, tuple(generators), cartan_type, tuple(index_set), category)
def __classcall_private__(cls, ct, c=None): r""" Normalize input to ensure a unique representation. INPUT: - ``ct`` -- a Cartan type EXAMPLES:: sage: M = crystals.infinity.NakajimaMonomials("E8") sage: M1 = crystals.infinity.NakajimaMonomials(['E',8]) sage: M2 = crystals.infinity.NakajimaMonomials(CartanType(['E',8])) sage: M is M1 is M2 True """ cartan_type = CartanType(ct) n = len(cartan_type.index_set()) c = InfinityCrystalOfNakajimaMonomials._normalize_c(c, n) M = super(InfinityCrystalOfNakajimaMonomials, cls).__classcall__(cls, cartan_type, c) M.set_variables('Y') return M
def __classcall_private__(cls, ct, c=None): r""" Normalize input to ensure a unique representation. INPUT: - ``ct`` -- a Cartan type EXAMPLES:: sage: M = crystals.infinity.NakajimaMonomials("E8") sage: M1 = crystals.infinity.NakajimaMonomials(['E',8]) sage: M2 = crystals.infinity.NakajimaMonomials(CartanType(['E',8])) sage: M is M1 is M2 True """ cartan_type = CartanType(ct) n = len(cartan_type.index_set()) c = InfinityCrystalOfNakajimaMonomials._normalize_c(c, n) M = super(InfinityCrystalOfNakajimaMonomials, cls).__classcall__(cls, cartan_type, c) M.set_variables('Y') return M
def __classcall_private__(cls, cartan_type, La=None, c=None): r""" Normalize input to ensure a unique representation. EXAMPLES:: sage: La = RootSystem(['E',8,1]).weight_lattice(extended=True).fundamental_weights() sage: M = crystals.NakajimaMonomials(['E',8,1],La[0]+La[8]) sage: M1 = crystals.NakajimaMonomials(CartanType(['E',8,1]),La[0]+La[8]) sage: M2 = crystals.NakajimaMonomials(['E',8,1],M.Lambda()[0] + M.Lambda()[8]) sage: M is M1 is M2 True """ if La is None: La = cartan_type cartan_type = La.parent().cartan_type() cartan_type = CartanType(cartan_type) if cartan_type.is_affine(): La = RootSystem(cartan_type).weight_lattice(extended=True)(La) else: La = RootSystem(cartan_type).weight_lattice()(La) n = len(cartan_type.index_set()) c = InfinityCrystalOfNakajimaMonomials._normalize_c(c, n) return super(CrystalOfNakajimaMonomials, cls).__classcall__(cls, cartan_type, La, c)
def __classcall_private__(cls, data=None, index_set=None, cartan_type=None, cartan_type_check=True): """ Normalize input so we can inherit from sparse integer matrix. .. NOTE:: To disable the Cartan type check, use the optional argument ``cartan_type_check = False``. EXAMPLES:: sage: C = CartanMatrix(['A',1,1]) sage: C2 = CartanMatrix([[2, -2], [-2, 2]]) sage: C3 = CartanMatrix(matrix([[2, -2], [-2, 2]]), [0, 1]) sage: C == C2 and C == C3 True TESTS: Check that :trac:`15740` is fixed:: sage: d = DynkinDiagram() sage: d.add_edge('a', 'b', 2) sage: d.index_set() ('a', 'b') sage: cm = CartanMatrix(d) sage: cm.index_set() ('a', 'b') """ # Special case with 0 args and kwds has Cartan type if cartan_type is not None and data is None: data = CartanType(cartan_type) if data is None: data = [] n = 0 index_set = tuple() cartan_type = None subdivisions = None elif isinstance(data, CartanMatrix): if index_set is not None: d = {a: index_set[i] for i, a in enumerate(data.index_set())} return data.relabel(d) return data else: dynkin_diagram = None subdivisions = None from sage.combinat.root_system.dynkin_diagram import DynkinDiagram_class if isinstance(data, DynkinDiagram_class): dynkin_diagram = data cartan_type = data._cartan_type else: try: cartan_type = CartanType(data) dynkin_diagram = cartan_type.dynkin_diagram() except (TypeError, ValueError): pass if dynkin_diagram is not None: n = dynkin_diagram.rank() index_set = dynkin_diagram.index_set() oir = dynkin_diagram.odd_isotropic_roots() reverse = {a: i for i, a in enumerate(index_set)} data = {(i, i): 2 if index_set[i] not in oir else 0 for i in range(n)} for (i, j, l) in dynkin_diagram.edge_iterator(): data[(reverse[j], reverse[i])] = -l else: M = matrix(data) if not is_generalized_cartan_matrix(M): raise ValueError( "the input matrix is not a generalized Cartan matrix") n = M.ncols() data = M.dict() subdivisions = M._subdivisions if index_set is None: index_set = tuple(range(n)) else: index_set = tuple(index_set) if len(index_set) != n and len(set(index_set)) != n: raise ValueError("the given index set is not valid") # We can do the Cartan type initialization later as this is not # a unique representation mat = typecall(cls, MatrixSpace(ZZ, n, sparse=True), data, False, True) # FIXME: We have to initialize the CartanMatrix part separately because # of the __cinit__ of the matrix. We should get rid of this workaround mat._CM_init(cartan_type, index_set, cartan_type_check) mat._subdivisions = subdivisions return mat
def __classcall_private__(cls, *args, **kwds): """ Normalize input so we can inherit from spare integer matrix. .. NOTE:: To disable the Cartan type check, use the optional argument ``cartan_type_check = False``. EXAMPLES:: sage: C = CartanMatrix(['A',1,1]) sage: C2 = CartanMatrix([[2, -2], [-2, 2]]) sage: C3 = CartanMatrix(matrix([[2, -2], [-2, 2]]), [0, 1]) sage: C == C2 and C == C3 True """ # Special case with 0 args and kwds has cartan type if "cartan_type" in kwds and len(args) == 0: args = (CartanType(kwds["cartan_type"]),) if len(args) == 0: data = [] n = 0 index_set = tuple() cartan_type = None subdivisions = None elif len(args) == 4 and isinstance(args[0], MatrixSpace): # For pickling return typecall(cls, args[0], args[1], args[2], args[3]) elif isinstance(args[0], CartanMatrix): return args[0] else: cartan_type = None dynkin_diagram = None subdivisions = None try: cartan_type = CartanType(args[0]) dynkin_diagram = cartan_type.dynkin_diagram() except (TypeError, ValueError): pass if dynkin_diagram is not None: n = cartan_type.rank() index_set = dynkin_diagram.index_set() reverse = dict((index_set[i], i) for i in range(len(index_set))) data = {(i, i): 2 for i in range(n)} for (i,j,l) in dynkin_diagram.edge_iterator(): data[(reverse[j], reverse[i])] = -l else: M = matrix(args[0]) if not is_generalized_cartan_matrix(M): raise ValueError("The input matrix is not a generalized Cartan matrix.") n = M.ncols() if "cartan_type" in kwds: cartan_type = CartanType(kwds["cartan_type"]) elif n == 1: cartan_type = CartanType(['A', 1]) elif kwds.get("cartan_type_check", True): cartan_type = find_cartan_type_from_matrix(M) data = M.dict() subdivisions = M._subdivisions if len(args) == 1: if cartan_type is not None: index_set = tuple(cartan_type.index_set()) else: index_set = tuple(range(M.ncols())) elif len(args) == 2: index_set = tuple(args[1]) if len(index_set) != n and len(set(index_set)) != n: raise ValueError("The given index set is not valid.") else: raise ValueError("Too many arguments.") mat = typecall(cls, MatrixSpace(ZZ, n, sparse=True), data, cartan_type, index_set) mat._subdivisions = subdivisions return mat
def __classcall_private__(cls, data=None, index_set=None, cartan_type=None, cartan_type_check=True, borcherds=None): """ Normalize input so we can inherit from sparse integer matrix. .. NOTE:: To disable the Cartan type check, use the optional argument ``cartan_type_check = False``. EXAMPLES:: sage: C = CartanMatrix(['A',1,1]) sage: C2 = CartanMatrix([[2, -2], [-2, 2]]) sage: C3 = CartanMatrix(matrix([[2, -2], [-2, 2]]), [0, 1]) sage: C == C2 and C == C3 True TESTS: Check that :trac:`15740` is fixed:: sage: d = DynkinDiagram() sage: d.add_edge('a', 'b', 2) sage: d.index_set() ('a', 'b') sage: cm = CartanMatrix(d) sage: cm.index_set() ('a', 'b') """ # Special case with 0 args and kwds has Cartan type if cartan_type is not None and data is None: data = CartanType(cartan_type) if data is None: data = [] n = 0 index_set = tuple() cartan_type = None subdivisions = None elif isinstance(data, CartanMatrix): if index_set is not None: d = {a: index_set[i] for i,a in enumerate(data.index_set())} return data.relabel(d) return data else: dynkin_diagram = None subdivisions = None from sage.combinat.root_system.dynkin_diagram import DynkinDiagram_class if isinstance(data, DynkinDiagram_class): dynkin_diagram = data cartan_type = data._cartan_type else: try: cartan_type = CartanType(data) dynkin_diagram = cartan_type.dynkin_diagram() except (TypeError, ValueError): pass if dynkin_diagram is not None: n = dynkin_diagram.rank() index_set = dynkin_diagram.index_set() oir = dynkin_diagram.odd_isotropic_roots() reverse = {a: i for i,a in enumerate(index_set)} if isinstance(borcherds, (list, tuple)): if (len(borcherds) != len(index_set) and not all(val in ZZ and (val == 2 or (val % 2 == 0 and val < 0)) for val in borcherds)): raise ValueError("the input data is not a Borcherds-Cartan matrix") data = {(i, i): val if index_set[i] not in oir else 0 for i,val in enumerate(borcherds)} else: data = {(i, i): 2 if index_set[i] not in oir else 0 for i in range(n)} for (i,j,l) in dynkin_diagram.edge_iterator(): data[(reverse[j], reverse[i])] = -l else: M = matrix(data) if borcherds: if not is_borcherds_cartan_matrix(M): raise ValueError("the input matrix is not a Borcherds-Cartan matrix") else: if not is_generalized_cartan_matrix(M): raise ValueError("the input matrix is not a generalized Cartan matrix") n = M.ncols() data = M.dict() subdivisions = M._subdivisions if index_set is None: index_set = tuple(range(n)) else: index_set = tuple(index_set) if len(index_set) != n and len(set(index_set)) != n: raise ValueError("the given index set is not valid") # We can do the Cartan type initialization later as this is not # a unique representation mat = typecall(cls, MatrixSpace(ZZ, n, sparse=True), data, False, True) # FIXME: We have to initialize the CartanMatrix part separately because # of the __cinit__ of the matrix. We should get rid of this workaround mat._CM_init(cartan_type, index_set, cartan_type_check) mat._subdivisions = subdivisions return mat
def cartan_type(self): r""" Returns the Cartan type of the Cartan companion of self.b_matrix() Only crystallographic types are implemented Warning: this function is redundant but the corresonding method in CartanType does not recognize all the types """ A = self.cartan_companion() n = self.rk degrees_dict = dict(zip(range(n),map(sum,2-A))) degrees_set = Set(degrees_dict.values()) types_to_check = [ ["A",n] ] if n > 1: types_to_check.append(["B",n]) if n > 2: types_to_check.append(["C",n]) if n > 3: types_to_check.append(["D",n]) if n >=6 and n <= 8: types_to_check.append(["E",n]) if n == 4: types_to_check.append(["F",n]) if n == 2: types_to_check.append(["G",n]) if n >1: types_to_check.append(["A", n-1,1]) types_to_check.append(["B", n-1,1]) types_to_check.append(["BC",n-1,2]) types_to_check.append(["A", 2*n-2,2]) types_to_check.append(["A", 2*n-3,2]) if n>2: types_to_check.append(["C", n-1,1]) types_to_check.append(["D", n,2]) if n>3: types_to_check.append(["D", n-1,1]) if n >=7 and n <= 9: types_to_check.append(["E",n-1,1]) if n == 5: types_to_check.append(["F",4,1]) if n == 3: types_to_check.append(["G",n-1,1]) types_to_check.append(["D",4,3]) if n == 5: types_to_check.append(["E",6,2]) for ct_name in types_to_check: ct = CartanType(ct_name) if 0 not in ct.index_set(): ct = ct.relabel(dict(zip(range(1,n+1),range(n)))) ct_matrix = ct.cartan_matrix() ct_degrees_dict = dict(zip(range(n),map(sum,2-ct_matrix))) if Set(ct_degrees_dict.values()) != degrees_set: continue for p in Permutations(range(n)): relabeling = dict(zip(range(n),p)) ct_new = ct.relabel(relabeling) if ct_new.cartan_matrix() == A: return copy(ct_new) raise ValueError("Type not recognized")
def __classcall_private__(cls, *args, **kwds): """ Normalize input so we can inherit from spare integer matrix. .. NOTE:: To disable the Cartan type check, use the optional argument ``cartan_type_check = False``. EXAMPLES:: sage: C = CartanMatrix(['A',1,1]) sage: C2 = CartanMatrix([[2, -2], [-2, 2]]) sage: C3 = CartanMatrix(matrix([[2, -2], [-2, 2]]), [0, 1]) sage: C == C2 and C == C3 True TESTS: Check that :trac:`15740` is fixed:: sage: d = DynkinDiagram() sage: d.add_edge('a', 'b', 2) sage: d.index_set() ('a', 'b') sage: cm = CartanMatrix(d) sage: cm.index_set() ('a', 'b') """ # Special case with 0 args and kwds has Cartan type if "cartan_type" in kwds and len(args) == 0: args = (CartanType(kwds["cartan_type"]),) if len(args) == 0: data = [] n = 0 index_set = tuple() cartan_type = None subdivisions = None elif len(args) == 4 and isinstance(args[0], MatrixSpace): # For pickling return typecall(cls, args[0], args[1], args[2], args[3]) elif isinstance(args[0], CartanMatrix): return args[0] else: cartan_type = None dynkin_diagram = None subdivisions = None from sage.combinat.root_system.dynkin_diagram import DynkinDiagram_class if isinstance(args[0], DynkinDiagram_class): dynkin_diagram = args[0] cartan_type = args[0]._cartan_type else: try: cartan_type = CartanType(args[0]) dynkin_diagram = cartan_type.dynkin_diagram() except (TypeError, ValueError): pass if dynkin_diagram is not None: n = dynkin_diagram.rank() index_set = dynkin_diagram.index_set() reverse = dict((index_set[i], i) for i in range(len(index_set))) data = {(i, i): 2 for i in range(n)} for (i,j,l) in dynkin_diagram.edge_iterator(): data[(reverse[j], reverse[i])] = -l else: M = matrix(args[0]) if not is_generalized_cartan_matrix(M): raise ValueError("the input matrix is not a generalized Cartan matrix") n = M.ncols() if "cartan_type" in kwds: cartan_type = CartanType(kwds["cartan_type"]) elif n == 1: cartan_type = CartanType(['A', 1]) elif kwds.get("cartan_type_check", True): cartan_type = find_cartan_type_from_matrix(M) data = M.dict() subdivisions = M._subdivisions if len(args) == 1: if cartan_type is not None: index_set = tuple(cartan_type.index_set()) elif dynkin_diagram is None: index_set = tuple(range(n)) elif len(args) == 2: index_set = tuple(args[1]) if len(index_set) != n and len(set(index_set)) != n: raise ValueError("the given index set is not valid") else: raise ValueError("too many arguments") mat = typecall(cls, MatrixSpace(ZZ, n, sparse=True), data, cartan_type, index_set) mat._subdivisions = subdivisions return mat
def cartan_type(self): r""" Returns the Cartan type of the Cartan companion of self.b_matrix() Only crystallographic types are implemented Warning: this function is redundant but the corresonding method in CartanType does not recognize all the types """ A = self.cartan_companion() n = self.rk degrees_dict = dict(zip(range(n), map(sum, 2 - A))) degrees_set = Set(degrees_dict.values()) types_to_check = [["A", n]] if n > 1: types_to_check.append(["B", n]) if n > 2: types_to_check.append(["C", n]) if n > 3: types_to_check.append(["D", n]) if n >= 6 and n <= 8: types_to_check.append(["E", n]) if n == 4: types_to_check.append(["F", n]) if n == 2: types_to_check.append(["G", n]) if n > 1: types_to_check.append(["A", n - 1, 1]) types_to_check.append(["B", n - 1, 1]) types_to_check.append(["BC", n - 1, 2]) types_to_check.append(["A", 2 * n - 2, 2]) types_to_check.append(["A", 2 * n - 3, 2]) if n > 2: types_to_check.append(["C", n - 1, 1]) types_to_check.append(["D", n, 2]) if n > 3: types_to_check.append(["D", n - 1, 1]) if n >= 7 and n <= 9: types_to_check.append(["E", n - 1, 1]) if n == 5: types_to_check.append(["F", 4, 1]) if n == 3: types_to_check.append(["G", n - 1, 1]) types_to_check.append(["D", 4, 3]) if n == 5: types_to_check.append(["E", 6, 2]) for ct_name in types_to_check: ct = CartanType(ct_name) if 0 not in ct.index_set(): ct = ct.relabel(dict(zip(range(1, n + 1), range(n)))) ct_matrix = ct.cartan_matrix() ct_degrees_dict = dict(zip(range(n), map(sum, 2 - ct_matrix))) if Set(ct_degrees_dict.values()) != degrees_set: continue for p in Permutations(range(n)): relabeling = dict(zip(range(n), p)) ct_new = ct.relabel(relabeling) if ct_new.cartan_matrix() == A: return copy(ct_new) raise ValueError("Type not recognized")