def coxeter_matrix(t):
"""
Returns the Coxeter matrix of type t.
EXAMPLES::
sage: coxeter_matrix(['A', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 3]
[2 2 3 1]
sage: coxeter_matrix(['B', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 4]
[2 2 4 1]
sage: coxeter_matrix(['C', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 4]
[2 2 4 1]
sage: coxeter_matrix(['D', 4])
[1 3 2 2]
[3 1 3 3]
[2 3 1 2]
[2 3 2 1]
::
sage: coxeter_matrix(['E', 6])
[1 2 3 2 2 2]
[2 1 2 3 2 2]
[3 2 1 3 2 2]
[2 3 3 1 3 2]
[2 2 2 3 1 3]
[2 2 2 2 3 1]
::
sage: coxeter_matrix(['F', 4])
[1 3 2 2]
[3 1 4 2]
[2 4 1 3]
[2 2 3 1]
::
sage: coxeter_matrix(['G', 2])
[1 6]
[6 1]
"""
ct = CartanType(t)
cf = coxeter_matrix_as_function(ct)
index_set = ct.index_set()
MS = MatrixSpace(ZZ, len(index_set))
m = MS(0)
for i in range(len(index_set)):
for j in range(len(index_set)):
m[i, j] = cf(index_set[i], index_set[j])
return m
def ascii_art(self, label=lambda i: i, node=None):
"""
Return a ascii art representation of the extended Dynkin diagram.
EXAMPLES::
sage: print CartanType(['C',5,1]).ascii_art(label = lambda x: x+2)
O=>=O---O---O---O=<=O
2 3 4 5 6 7
sage: print CartanType(['C',3,1]).ascii_art()
O=>=O---O=<=O
0 1 2 3
sage: print CartanType(['C',2,1]).ascii_art()
O=>=O=<=O
0 1 2
sage: print CartanType(['C',1,1]).ascii_art()
O<=>O
0 1
"""
if node is None:
node = self._ascii_art_node
n = self.n
from cartan_type import CartanType
if n == 1:
return CartanType(["A", 1, 1]).ascii_art(label, node)
ret = node(label(0)) + "=>=" + "---".join(
node(label(i)) for i in range(1, n))
ret += "=<=" + node(label(n)) + '\n'
ret += "".join("{!s:4}".format(label(i)) for i in range(n + 1))
return ret
def ascii_art(self, label = lambda x: x):
"""
Returns a ascii art representation of the extended Dynkin diagram
EXAMPLES::
sage: print CartanType(['C',5,1]).ascii_art(label = lambda x: x+2)
O=>=O---O---O---O=<=O
2 3 4 5 6 7
sage: print CartanType(['C',3,1]).ascii_art()
O=>=O---O=<=O
0 1 2 3
sage: print CartanType(['C',2,1]).ascii_art()
O=>=O=<=O
0 1 2
sage: print CartanType(['C',1,1]).ascii_art()
O<=>O
0 1
"""
n = self.n
from cartan_type import CartanType
if n == 1:
return CartanType(["A",1,1]).ascii_art(label)
if self.global_options('mark_special_node') in ['printing', 'both']:
special_str = self.global_options('special_node_str')
else:
special_str = 'O'
ret = "%s=>=O"%special_str + (n-2)*"---O"+"=<=O\n%s "%label(0)
ret += " ".join("%s"%label(i) for i in range(1,n+1))
return ret
def coxeter_matrix_as_function(t):
"""
Returns the coxeter matrix associated to the Cartan type t.
EXAMPLES::
sage: from sage.combinat.root_system.coxeter_matrix import coxeter_matrix_as_function
sage: f = coxeter_matrix_as_function(['A',4])
sage: matrix([[f(i,j) for j in range(1,5)] for i in range(1,5)])
[1 3 2 2]
[3 1 3 2]
[2 3 1 3]
[2 2 3 1]
"""
a = CartanType(t).dynkin_diagram()
scalarproducts_to_order = {
0: 2,
1: 3,
2: 4,
3: 6
# 4 should be infinity
}
return lambda i, j: 1 if i == j else scalarproducts_to_order[a[i, j] * a[
j, i]]
def __init__(self, cartan_type, as_dual_of=None):
"""
TESTS::
sage: R = RootSystem(['A',3])
sage: R
Root system of type ['A', 3]
"""
self._cartan_type = CartanType(cartan_type)
# Duality
# The root system can be defined as dual of another root system. This will
# only affects the pretty printing
if as_dual_of is None:
self.dual_side = False
self.dual = RootSystem(self._cartan_type.dual(), as_dual_of=self)
# still fails for CartanType G2xA1
try:
self.dual = RootSystem(self._cartan_type.dual(),
as_dual_of=self)
except StandardError:
pass
else:
self.dual_side = True
self.dual = as_dual_of
def ascii_art(self, label=lambda x: x):
"""
Returns a ascii art representation of the extended Dynkin diagram
EXAMPLES::
sage: print CartanType(['C',5,1]).ascii_art(label = lambda x: x+2)
O=>=O---O---O---O=<=O
2 3 4 5 6 7
sage: print CartanType(['C',3,1]).ascii_art()
O=>=O---O=<=O
0 1 2 3
sage: print CartanType(['C',2,1]).ascii_art()
O=>=O=<=O
0 1 2
sage: print CartanType(['C',1,1]).ascii_art()
O<=>O
0 1
"""
n = self.n
from cartan_type import CartanType
if n == 1:
return CartanType(["A", 1, 1]).ascii_art(label)
ret = "O=>=O" + (n - 2) * "---O" + "=<=O\n%s " % label(0)
ret += " ".join("%s" % label(i) for i in range(1, n + 1))
return ret
def ascii_art(self, label=lambda x: x):
"""
Returns a ascii art representation of the extended Dynkin diagram
EXAMPLES::
sage: print CartanType(['B',3,1]).ascii_art()
O 0
|
|
O---O=>=O
1 2 3
sage: print CartanType(['B',5,1]).ascii_art(label = lambda x: x+2)
O 2
|
|
O---O---O---O=>=O
3 4 5 6 7
sage: print CartanType(['B',2,1]).ascii_art(label = lambda x: x+2)
O=>=O=<=O
2 4 3
sage: print CartanType(['B',1,1]).ascii_art(label = lambda x: x+2)
O<=>O
2 3
"""
n = self.n
from cartan_type import CartanType
if n == 1:
return CartanType(["A", 1, 1]).ascii_art(label)
if n == 2:
return CartanType(["C", 2, 1]).relabel({
0: 0,
1: 2,
2: 1
}).ascii_art(label)
if self.global_options('mark_special_node') in ['printing', 'both']:
special_str = self.global_options('special_node_str')
else:
special_str = 'O'
ret = " %s %s\n |\n |\n" % (special_str, label(0))
ret += (n - 2) * "O---" + "O=>=O\n"
ret += " ".join("%s" % label(i) for i in range(1, n + 1))
return ret
def ascii_art(self, label=lambda x: x):
"""
Returns a ascii art representation of the extended Dynkin diagram
EXAMPLES::
sage: print CartanType(['B',3,1]).ascii_art()
O 0
|
|
O---O=>=O
1 2 3
sage: print CartanType(['B',5,1]).ascii_art(label = lambda x: x+2)
O 2
|
|
O---O---O---O=>=O
3 4 5 6 7
sage: print CartanType(['B',2,1]).ascii_art(label = lambda x: x+2)
O=>=O=<=O
2 4 3
sage: print CartanType(['B',1,1]).ascii_art(label = lambda x: x+2)
O<=>O
2 3
"""
n = self.n
from cartan_type import CartanType
if n == 1:
return CartanType(["A", 1, 1]).ascii_art(label)
if n == 2:
return CartanType(["C", 2, 1]).relabel({
0: 0,
1: 2,
2: 1
}).ascii_art(label)
ret = " O %s\n |\n |\n" % label(0)
ret += (n - 2) * "O---" + "O=>=O\n"
ret += " ".join("%s" % label(i) for i in range(1, n + 1))
return ret
def DynkinDiagram(*args):
"""
INPUT:
- ``ct`` - a Cartan Type
Returns a Dynkin diagram for type ct.
The edge multiplicities are encoded as edge labels. This uses the
convention in Kac / Fulton Harris, Representation theory / Wikipedia
(http://en.wikipedia.org/wiki/Dynkin_diagram). That is for i != j::
j --k--> i <==> a_ij = -k
<==> -scalar(coroot[i], root[j]) = k
<==> multiple arrows point from the longer root
to the shorter one
EXAMPLES::
sage: DynkinDiagram(['A', 4])
O---O---O---O
1 2 3 4
A4
sage: DynkinDiagram(['A',1],['A',1])
O
1
O
2
A1xA1
sage: R = RootSystem("A2xB2xF4")
sage: DynkinDiagram(R)
O---O
1 2
O=>=O
3 4
O---O=>=O---O
5 6 7 8
A2xB2xF4
SEE ALSO: :func:`CartanType` for a general discussion on Cartan
types and in particular node labeling conventions.
"""
if len(args) == 0:
return DynkinDiagram_class()
ct = CartanType(*args)
if hasattr(ct, "dynkin_diagram"):
return ct.dynkin_diagram()
else:
raise ValueError, "Dynkin diagram data not yet hardcoded for type %s"%ct
def coxeter_matrix(t):
"""
Returns the Coxeter matrix of type t.
EXAMPLES::
sage: coxeter_matrix(['A', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 3]
[2 2 3 1]
sage: coxeter_matrix(['B', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 4]
[2 2 4 1]
sage: coxeter_matrix(['C', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 4]
[2 2 4 1]
sage: coxeter_matrix(['D', 4])
[1 3 2 2]
[3 1 3 3]
[2 3 1 2]
[2 3 2 1]
::
sage: coxeter_matrix(['E', 6])
[1 2 3 2 2 2]
[2 1 2 3 2 2]
[3 2 1 3 2 2]
[2 3 3 1 3 2]
[2 2 2 3 1 3]
[2 2 2 2 3 1]
::
sage: coxeter_matrix(['F', 4])
[1 3 2 2]
[3 1 4 2]
[2 4 1 3]
[2 2 3 1]
::
sage: coxeter_matrix(['G', 2])
[1 6]
[6 1]
"""
return CartanType(t).coxeter_matrix()
def __classcall__(cls, cartan_type, as_dual_of=None):
"""
Straighten arguments to enable unique representation
.. seealso:: :class:`UniqueRepresentation`
TESTS::
sage: RootSystem(["A",3]) is RootSystem(CartanType(["A",3]))
True
sage: RootSystem(["B",3], as_dual_of=None) is RootSystem("B3")
True
"""
return super(RootSystem, cls).__classcall__(cls, CartanType(cartan_type), as_dual_of)
def WeylDim(ct, coeffs):
"""
The Weyl Dimension Formula.
INPUT:
- ``type`` - a Cartan type
- ``coeffs`` - a list of nonnegative integers
The length of the list must equal the rank type[1]. A dominant
weight hwv is constructed by summing the fundamental weights with
coefficients from this list. The dimension of the irreducible
representation of the semisimple complex Lie algebra with highest
weight vector hwv is returned.
EXAMPLES:
For `SO(7)`, the Cartan type is `B_3`, so::
sage: WeylDim(['B',3],[1,0,0]) # standard representation of SO(7)
7
sage: WeylDim(['B',3],[0,1,0]) # exterior square
21
sage: WeylDim(['B',3],[0,0,1]) # spin representation of spin(7)
8
sage: WeylDim(['B',3],[1,0,1]) # sum of the first and third fundamental weights
48
sage: [WeylDim(['F',4],x) for x in [1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]
[52, 1274, 273, 26]
sage: [WeylDim(['E', 6], x) for x in [0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 1], [2, 0, 0, 0, 0, 0]]
[1, 78, 27, 351, 351, 351, 27, 650, 351]
"""
ct = CartanType(ct)
lattice = RootSystem(ct).ambient_space()
rank = ct.rank()
fw = lattice.fundamental_weights()
hwv = lattice.sum(coeffs[i] * fw[i + 1]
for i in range(min(rank, len(coeffs))))
return lattice.weyl_dimension(hwv)
def coxeter_matrix_as_function(t):
"""
Returns the coxeter matrix, as a function
INPUT:
- ``t`` -- a Cartan type
EXAMPLES::
sage: from sage.combinat.root_system.coxeter_matrix import coxeter_matrix_as_function
sage: f = coxeter_matrix_as_function(['A',4])
sage: matrix([[f(i,j) for j in range(1,5)] for i in range(1,5)])
[1 3 2 2]
[3 1 3 2]
[2 3 1 3]
[2 2 3 1]
"""
t = CartanType(t)
m = t.coxeter_matrix()
index_set = t.index_set()
reverse = dict((index_set[i], i) for i in range(len(index_set)))
return lambda i,j: m[reverse[i], reverse[j]]
def cartan_matrix(t):
"""
Returns the Cartan matrix corresponding to type t.
EXAMPLES::
sage: cartan_matrix(['A', 4])
[ 2 -1 0 0]
[-1 2 -1 0]
[ 0 -1 2 -1]
[ 0 0 -1 2]
sage: cartan_matrix(['B', 6])
[ 2 -1 0 0 0 0]
[-1 2 -1 0 0 0]
[ 0 -1 2 -1 0 0]
[ 0 0 -1 2 -1 0]
[ 0 0 0 -1 2 -1]
[ 0 0 0 0 -2 2]
sage: cartan_matrix(['C', 4])
[ 2 -1 0 0]
[-1 2 -1 0]
[ 0 -1 2 -2]
[ 0 0 -1 2]
sage: cartan_matrix(['D', 6])
[ 2 -1 0 0 0 0]
[-1 2 -1 0 0 0]
[ 0 -1 2 -1 0 0]
[ 0 0 -1 2 -1 -1]
[ 0 0 0 -1 2 0]
[ 0 0 0 -1 0 2]
sage: cartan_matrix(['E',6])
[ 2 0 -1 0 0 0]
[ 0 2 0 -1 0 0]
[-1 0 2 -1 0 0]
[ 0 -1 -1 2 -1 0]
[ 0 0 0 -1 2 -1]
[ 0 0 0 0 -1 2]
sage: cartan_matrix(['E',7])
[ 2 0 -1 0 0 0 0]
[ 0 2 0 -1 0 0 0]
[-1 0 2 -1 0 0 0]
[ 0 -1 -1 2 -1 0 0]
[ 0 0 0 -1 2 -1 0]
[ 0 0 0 0 -1 2 -1]
[ 0 0 0 0 0 -1 2]
sage: cartan_matrix(['E', 8])
[ 2 0 -1 0 0 0 0 0]
[ 0 2 0 -1 0 0 0 0]
[-1 0 2 -1 0 0 0 0]
[ 0 -1 -1 2 -1 0 0 0]
[ 0 0 0 -1 2 -1 0 0]
[ 0 0 0 0 -1 2 -1 0]
[ 0 0 0 0 0 -1 2 -1]
[ 0 0 0 0 0 0 -1 2]
sage: cartan_matrix(['F', 4])
[ 2 -1 0 0]
[-1 2 -1 0]
[ 0 -2 2 -1]
[ 0 0 -1 2]
This is different from MuPAD-Combinat, due to different node
convention?
::
sage: cartan_matrix(['G', 2])
[ 2 -3]
[-1 2]
sage: cartan_matrix(['A',1,1])
[ 2 -2]
[-2 2]
sage: cartan_matrix(['A', 3, 1])
[ 2 -1 0 -1]
[-1 2 -1 0]
[ 0 -1 2 -1]
[-1 0 -1 2]
sage: cartan_matrix(['B', 3, 1])
[ 2 0 -1 0]
[ 0 2 -1 0]
[-1 -1 2 -1]
[ 0 0 -2 2]
sage: cartan_matrix(['C', 3, 1])
[ 2 -1 0 0]
[-2 2 -1 0]
[ 0 -1 2 -2]
[ 0 0 -1 2]
sage: cartan_matrix(['D', 4, 1])
[ 2 0 -1 0 0]
[ 0 2 -1 0 0]
[-1 -1 2 -1 -1]
[ 0 0 -1 2 0]
[ 0 0 -1 0 2]
sage: cartan_matrix(['E', 6, 1])
[ 2 0 -1 0 0 0 0]
[ 0 2 0 -1 0 0 0]
[-1 0 2 0 -1 0 0]
[ 0 -1 0 2 -1 0 0]
[ 0 0 -1 -1 2 -1 0]
[ 0 0 0 0 -1 2 -1]
[ 0 0 0 0 0 -1 2]
sage: cartan_matrix(['E', 7, 1])
[ 2 -1 0 0 0 0 0 0]
[-1 2 0 -1 0 0 0 0]
[ 0 0 2 0 -1 0 0 0]
[ 0 -1 0 2 -1 0 0 0]
[ 0 0 -1 -1 2 -1 0 0]
[ 0 0 0 0 -1 2 -1 0]
[ 0 0 0 0 0 -1 2 -1]
[ 0 0 0 0 0 0 -1 2]
sage: cartan_matrix(['E', 8, 1])
[ 2 0 0 0 0 0 0 0 -1]
[ 0 2 0 -1 0 0 0 0 0]
[ 0 0 2 0 -1 0 0 0 0]
[ 0 -1 0 2 -1 0 0 0 0]
[ 0 0 -1 -1 2 -1 0 0 0]
[ 0 0 0 0 -1 2 -1 0 0]
[ 0 0 0 0 0 -1 2 -1 0]
[ 0 0 0 0 0 0 -1 2 -1]
[-1 0 0 0 0 0 0 -1 2]
sage: cartan_matrix(['F', 4, 1])
[ 2 -1 0 0 0]
[-1 2 -1 0 0]
[ 0 -1 2 -1 0]
[ 0 0 -2 2 -1]
[ 0 0 0 -1 2]
sage: cartan_matrix(['G', 2, 1])
[ 2 0 -1]
[ 0 2 -3]
[-1 -1 2]
.. note::
This function is likely to be deprecated in favor of
``CartanType(...).cartan_matrix()``, to avoid polluting the
global namespace.
"""
return CartanType(t).cartan_matrix()
def plot(self,
size=[[0], [0]],
projection='usual',
simple_roots=True,
fundamental_weights=True,
alcovewalks=[]):
r"""
Return a graphics object built from a space of weight(space/lattice).
There is a different technic to plot if the Cartan type is affine or not.
The graphics returned is a Graphics object.
This function is experimental, and is subject to short term evolutions.
EXAMPLES::
By default, the plot returned has no axes and the ratio between axes is 1.
sage: G = RootSystem(['C',2]).weight_lattice().plot()
sage: G.axes(True)
sage: G.set_aspect_ratio(2)
For a non affine Cartan type, the plot method work for type with 2 generators,
it will draw the hyperlane(line for this dimension) accrow the fundamentals weights.
sage: G = RootSystem(['A',2]).weight_lattice().plot()
sage: G = RootSystem(['B',2]).weight_lattice().plot()
sage: G = RootSystem(['G',2]).weight_lattice().plot()
The plot returned has a size of one fundamental polygon by default. We can
ask plot to give a bigger plot by using the argument size
sage: G = RootSystem(['G',2,1]).weight_space().plot(size = [[0..1],[-1..1]])
sage: G = RootSystem(['A',2,1]).weight_space().plot(size = [[-1..1],[-1..1]])
A very important argument is the projection which will draw the plot. There are
some usual projections is this method. If you want to draw in the plane a very
special Cartan type, Sage will ask you to specify the projection. The projection
is a matrix over a ring. In practice, calcul over float is a good way to draw.
sage: L = RootSystem(['A',2,1]).weight_space()
sage: G = L.plot(projection=matrix(RR, [[0,0.5,-0.5],[0,0.866,0.866]]))
sage: G = RootSystem(['C',2,1]).weight_space().plot()
By default, the plot method draw the simple roots, this can be disabled by setting
the argument simple_roots=False
sage: G = RootSystem(['A',2]).weight_space().plot(simple_roots=False)
By default, the plot method draw the fundamental weights,this can be disabled by
setting the argument fundamental_weights=False
sage: G = RootSystem(['A',2]).weight_space().plot(fundamental_weights=False, simple_roots=False)
There is in a plot an argument to draw alcoves walks. The good way to do this is
to use the crystals theory. the plot method contains only the drawing part...
sage: L = RootSystem(['A',2,1]).weight_space()
sage: G = L.plot(size=[[-1..1],[-1..1]],alcovewalks=[[0,2,0,1,2,1,2,0,2,1]])
"""
from sage.plot.all import Graphics
from sage.plot.line import line
from cartan_type import CartanType
from sage.matrix.constructor import matrix
from sage.rings.all import QQ, RR
from sage.plot.arrow import arrow
from sage.plot.point import point
# We begin with an empty plot G
G = Graphics()
ct = self.cartan_type()
n = ct.n
# Define a set of colors
# TODO : Colors in option ?
colors = [(0, 1, 0), (1, 0, 0), (0, 0, 1), (1, 1, 0), (0, 1, 1),
(1, 0, 1)]
# plot the affine types:
if ct.is_affine():
# Check the projection
# TODO : try to have usual_projection for main plotable types
if projection == 'usual':
if ct == CartanType(['A', 2, 1]):
projection = matrix(
RR, [[0, 0.5, -0.5], [0, 0.866, 0.866]])
elif ct == CartanType(['C', 2, 1]):
projection = matrix(QQ, [[0, 1, 1], [0, 0, 1]])
elif ct == CartanType(['G', 2, 1]):
projection = matrix(RR,
[[0, 0.5, 0], [0, 0.866, 1.732]])
else:
raise 'There is no usual projection for this Cartan type, you have to give one in argument'
assert (n + 1 == projection.ncols())
assert (2 == projection.nrows())
# Check the size is correct with the lattice
assert (len(size) == n)
# Select the center of the translated fundamental polygon to plot
translation_factors = ct.translation_factors()
simple_roots = self.simple_roots()
translation_vectors = [
translation_factors[i] * simple_roots[i]
for i in ct.classical().index_set()
]
initial = [[]]
for i in range(n):
prod_list = []
for elem in size[i]:
for partial_list in initial:
prod_list.append([elem] + partial_list)
initial = prod_list
part_lattice = []
for combinaison in prod_list:
elem_lattice = self.zero()
for i in range(n):
elem_lattice = elem_lattice + combinaison[
i] * translation_vectors[i]
part_lattice.append(elem_lattice)
# Get the vertices of the fundamental alcove
fundamental_weights = self.fundamental_weights()
vertices = map(lambda x: (1 / x.level()) * x,
fundamental_weights.list())
# Recup the group which act on the fundamental polygon
classical = self.weyl_group().classical()
for center in part_lattice:
for w in classical:
# for each center of polygon and each element of classical
# parabolic subgroup, we have to draw an alcove.
#first, iterate over pairs of fundamental weights, drawing lines border of polygons:
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
p1 = projection * (
(w.action(vertices[i])).to_vector() +
center.to_vector())
p2 = projection * (
(w.action(vertices[j])).to_vector() +
center.to_vector())
G += line([p1, p2],
rgbcolor=(0, 0, 0),
thickness=2)
#next, get all lines from point to a fundamental weight, that separe different
#chanber in a same polygon (important: associate a color with a fundamental weight)
pcenter = projection * (center.to_vector())
for i in range(1, n + 1):
p3 = projection * (
(w.action(vertices[i])).to_vector() +
center.to_vector())
G += line([p3, pcenter],
rgbcolor=colors[n - i + 1])
#Draw alcovewalks
#FIXME : The good way to draw this is to use the alcoves walks works made in Cristals
#The code here just draw like example and import the good things.
rho = (1 / self.rho().level()) * self.rho()
W = self.weyl_group()
for walk in alcovewalks:
target = W.from_reduced_word(walk).action(rho)
for i in range(len(walk)):
walk.pop()
origin = W.from_reduced_word(walk).action(rho)
G += arrow(projection * (origin.to_vector()),
projection * (target.to_vector()),
rgbcolor=(0.6, 0, 0.6),
width=1,
arrowsize=5)
target = origin
else:
# non affine plot
# Check the projection
# TODO : try to have usual_projection for main plotable types
if projection == 'usual':
if ct == CartanType(['A', 2]):
projection = matrix(RR, [[0.5, -0.5], [0.866, 0.866]])
elif ct == CartanType(['B', 2]):
projection = matrix(QQ, [[1, 0], [1, 1]])
elif ct == CartanType(['C', 2]):
projection = matrix(QQ, [[1, 1], [0, 1]])
elif ct == CartanType(['G', 2]):
projection = matrix(RR, [[0.5, 0], [0.866, 1.732]])
else:
raise 'There is no usual projection for this Cartan type, you have to give one in argument'
# Get the fundamental weights
fundamental_weights = self.fundamental_weights()
WeylGroup = self.weyl_group()
#Draw not the alcove but the cones delimited by the hyperplanes
#The size of the line depend of the fundamental weights.
pcenter = projection * (self.zero().to_vector())
for w in WeylGroup:
for i in range(1, n + 1):
p3 = 3 * projection * (
(w.action(fundamental_weights[i])).to_vector())
G += line([p3, pcenter], rgbcolor=colors[n - i + 1])
#Draw the simple roots
if simple_roots:
SimpleRoots = self.simple_roots()
if ct.is_affine():
G += arrow((0, 0),
projection * (SimpleRoots[0].to_vector()),
rgbcolor=(0, 0, 0))
for j in range(1, n + 1):
G += arrow((0, 0),
projection * (SimpleRoots[j].to_vector()),
rgbcolor=colors[j])
#Draw the fundamental weights
if fundamental_weights:
FundWeight = self.fundamental_weights()
for j in range(1, n + 1):
G += point(projection * (FundWeight[j].to_vector()),
rgbcolor=colors[j],
pointsize=60)
G.set_aspect_ratio(1)
G.axes(False)
return G
def __classcall__(cls, cartan_type, as_dual_of=None):
return super(RootSystem,
cls).__classcall__(cls, CartanType(cartan_type),
as_dual_of)
def DynkinDiagram(*args):
r"""
Return a Dynkin diagram for type ``ct``.
INPUT:
- ``ct`` -- a Cartan Type
The edge multiplicities are encoded as edge labels. This uses the
convention in Hong and Kang, Kac, Fulton Harris, and crystals. This is the
**opposite** convention in Bourbaki and Wikipedia's Dynkin diagram
(:wikipedia:`Dynkin_diagram`). That is for `i \neq j`::
i <--k-- j <==> a_ij = -k
<==> -scalar(coroot[i], root[j]) = k
<==> multiple arrows point from the longer root
to the shorter one
For example, in type `C_2`, we have::
sage: C2 = DynkinDiagram(['C',2]); C2
O=<=O
1 2
C2
sage: C2.cartan_matrix()
[ 2 -2]
[-1 2]
However Bourbaki would have the Cartan matrix as:
.. MATH::
\begin{bmatrix}
2 & -1 \\
-2 & 2
\end{bmatrix}.
EXAMPLES::
sage: DynkinDiagram(['A', 4])
O---O---O---O
1 2 3 4
A4
sage: DynkinDiagram(['A',1],['A',1])
O
1
O
2
A1xA1
sage: R = RootSystem("A2xB2xF4")
sage: DynkinDiagram(R)
O---O
1 2
O=>=O
3 4
O---O=>=O---O
5 6 7 8
A2xB2xF4
.. SEEALSO::
:func:`CartanType` for a general discussion on Cartan
types and in particular node labeling conventions.
"""
if len(args) == 0:
return DynkinDiagram_class()
ct = CartanType(*args)
if hasattr(ct, "dynkin_diagram"):
return ct.dynkin_diagram()
else:
raise ValueError, "Dynkin diagram data not yet hardcoded for type %s" % ct
