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")
