def triangulation(self):
r"""
Plot a regular polygon with some diagonals.
If ``self`` is positive and integral then this will be a triangulation.
.. PLOT::
:width: 600 px
G = path_tableaux.FriezePattern([1,2,7,5,3,7,4,1]).triangulation()
p = graphics_array(G, 7, 6)
sphinx_plot(p)
EXAMPLES::
sage: path_tableaux.FriezePattern([1,2,7,5,3,7,4,1]).triangulation()
Graphics object consisting of 25 graphics primitives
sage: path_tableaux.FriezePattern([1,2,1/7,5,3]).triangulation()
Graphics object consisting of 12 graphics primitives
sage: K.<sqrt2> = NumberField(x^2-2)
sage: path_tableaux.FriezePattern([1,sqrt2,1,sqrt2,3,2*sqrt2,5,3*sqrt2,1], field=K).triangulation()
Graphics object consisting of 24 graphics primitives
"""
n = len(self) - 1
cd = CylindricalDiagram(self).diagram
from sage.plot.plot import Graphics
from sage.plot.line import line
from sage.plot.text import text
from sage.functions.trig import sin, cos
from sage.all import pi
G = Graphics()
G.set_aspect_ratio(1.0)
vt = [(cos(2 * theta * pi / (n)), sin(2 * theta * pi / (n)))
for theta in range(n + 1)]
for i, p in enumerate(vt):
G += text(str(i), [1.05 * p[0], 1.05 * p[1]])
for i, r in enumerate(cd):
for j, a in enumerate(r[:n]):
if a == 1:
G += line([vt[i], vt[j]])
G.axes(False)
return G
def plot(self, color='rainbow', orientation='bottom-top', gap=0.05, aspect_ratio=1, axes=False, **kwds):
"""
Plot the braid
The following options are available:
- ``color`` -- (default: ``'rainbow'``) the color of the
strands. Possible values are:
* ``'rainbow'``, uses :meth:`~sage.plot.colors.rainbow`
according to the number of strands.
* a valid color name for :meth:`~sage.plot.bezier_path`
and :meth:`~sage.plot.line`. Used for all strands.
* a list or a tuple of colors for each individual strand.
- ``orientation`` -- (default: ``'bottom-top'``) determines how
the braid is printed. The possible values are:
* ``'bottom-top'``, the braid is printed from bottom to top
* ``'top-bottom'``, the braid is printed from top to bottom
* ``'left-right'``, the braid is printed from left to right
- ``gap`` -- floating point number (default: 0.05). determines
the size of the gap left when a strand goes under another.
- ``aspect_ratio`` -- floating point number (default:
``1``). The aspect ratio.
- ``**kwds`` -- other keyword options that are passed to
:meth:`~sage.plot.bezier_path` and :meth:`~sage.plot.line`.
EXAMPLES::
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot()
sage: b.plot(color=["red", "blue", "red", "blue"])
sage: B.<s,t> = BraidGroup(3)
sage: b = t^-1*s^2
sage: b.plot(orientation="left-right", color="red")
"""
from sage.plot.bezier_path import bezier_path
from sage.plot.plot import Graphics, line
from sage.plot.colors import rainbow
if orientation=='top-bottom':
orx = 0
ory = -1
nx = 1
ny = 0
elif orientation=='left-right':
orx = 1
ory = 0
nx = 0
ny = -1
elif orientation=='bottom-top':
orx = 0
ory = 1
nx = 1
ny = 0
else:
raise ValueError('unknown value for "orientation"')
n = self.strands()
if isinstance(color, (list, tuple)):
if len(color) != n:
raise TypeError("color (=%s) must contain exactly %d colors" % (color, n))
col = list(color)
elif color == "rainbow":
col = rainbow(n)
else:
col = [color]*n
braid = self.Tietze()
a = Graphics()
op = gap
for i, m in enumerate(braid):
for j in range(n):
if m==j+1:
a += bezier_path([[(j*nx+i*orx, i*ory+j*ny), (j*nx+orx*(i+0.25), j*ny+ory*(i+0.25)),
(nx*(j+0.5)+orx*(i+0.5), ny*(j+0.5)+ory*(i+0.5))],
[(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col[j], **kwds)
elif m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5+4*op)+orx*(i+0.5-2*op), ny*(j-0.5+4*op)+ory*(i+0.5-2*op)),
(nx*(j-0.5+2*op)+orx*(i+0.5-op), ny*(j-0.5+2*op)+ory*(i+0.5-op))]],
color=col[j], **kwds)
a += bezier_path([[(nx*(j-0.5-2*op)+orx*(i+0.5+op), ny*(j-0.5-2*op)+ory*(i+0.5+op)),
(nx*(j-0.5-4*op)+orx*(i+0.5+2*op), ny*(j-0.5-4*op)+ory*(i+0.5+2*op)),
(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col[j], **kwds)
col[j], col[j-1] = col[j-1], col[j]
elif -m==j+1:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j+0.5-4*op)+orx*(i+0.5-2*op), ny*(j+0.5-4*op)+ory*(i+0.5-2*op)),
(nx*(j+0.5-2*op)+orx*(i+0.5-op), ny*(j+0.5-2*op)+ory*(i+0.5-op))]],
color=col[j], **kwds)
a += bezier_path([[(nx*(j+0.5+2*op)+orx*(i+0.5+op), ny*(j+0.5+2*op)+ory*(i+0.5+op)),
(nx*(j+0.5+4*op)+orx*(i+0.5+2*op), ny*(j+0.5+4*op)+ory*(i+0.5+2*op)),
(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col[j], **kwds)
elif -m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5)+orx*(i+0.5), ny*(j-0.5)+ory*(i+0.5))],
[(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col[j], **kwds)
col[j], col[j-1] = col[j-1], col[j]
else:
a += line([(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+1), ny*j+ory*(i+1))], color=col[j], **kwds)
a.set_aspect_ratio(aspect_ratio)
a.axes(axes)
return a
def plot(self, color='blue', orientation='bottom-top', gap=0.05, aspect_ratio=1, axes=False, **kwds):
"""
Plot the braid
The following options are available:
- ``orientation`` - (default: ``'bottom-top'``) determines how
the braid is printed. The possible values are:
* ``'bottom-top'``, the braid is printed from bottom to top
* ``'top-bottom'``, the braid is printed from top to bottom
* ``'left-right'``, the braid is printed from left to right
- ``gap`` -- floating point number (default: 0.05). determines
the size of the gap left when a strand goes under another.
- ``aspect_ratio`` -- floating point number (default:
``1``). The aspect ratio.
- ``**kwds`` -- other keyword options that are passed to
:meth:`~sage.plot.bezier_path` and :meth:`~sage.plot.line`.
EXAMPLES::
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot()
"""
from sage.plot.bezier_path import bezier_path
from sage.plot.plot import Graphics, line
if orientation=='top-bottom':
orx = 0
ory = -1
nx = 1
ny = 0
elif orientation=='left-right':
orx = 1
ory = 0
nx = 0
ny = -1
elif orientation=='bottom-top':
orx = 0
ory = 1
nx = 1
ny = 0
else:
raise ValueError('unknown value for "orientation"')
col = color
br = self.Tietze()
n = self.strands()
a = Graphics()
op = gap
for i in range(len(br)):
m = br[i]
for j in range(n):
if m==j+1:
a += bezier_path([[(j*nx+i*orx, i*ory+j*ny), (j*nx+orx*(i+0.25), j*ny+ory*(i+0.25)),
(nx*(j+0.5)+orx*(i+0.5), ny*(j+0.5)+ory*(i+0.5))],
[(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5+4*op)+orx*(i+0.5-2*op), ny*(j-0.5+4*op)+ory*(i+0.5-2*op)),
(nx*(j-0.5+2*op)+orx*(i+0.5-op), ny*(j-0.5+2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j-0.5-2*op)+orx*(i+0.5+op), ny*(j-0.5-2*op)+ory*(i+0.5+op)),
(nx*(j-0.5-4*op)+orx*(i+0.5+2*op), ny*(j-0.5-4*op)+ory*(i+0.5+2*op)),
(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
elif -m==j+1:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j+0.5-4*op)+orx*(i+0.5-2*op), ny*(j+0.5-4*op)+ory*(i+0.5-2*op)),
(nx*(j+0.5-2*op)+orx*(i+0.5-op), ny*(j+0.5-2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j+0.5+2*op)+orx*(i+0.5+op), ny*(j+0.5+2*op)+ory*(i+0.5+op)),
(nx*(j+0.5+4*op)+orx*(i+0.5+2*op), ny*(j+0.5+4*op)+ory*(i+0.5+2*op)),
(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif -m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5)+orx*(i+0.5), ny*(j-0.5)+ory*(i+0.5))],
[(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
else:
a += line([(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+1), ny*j+ory*(i+1))], color=col, **kwds)
a.set_aspect_ratio(aspect_ratio)
a.axes(axes)
return a
def plot(self, color='blue', orientation='bottom-top', gap=0.05, aspect_ratio=1, axes=False, **kwds):
"""
Plot the braid
The following options are available:
- ``orientation`` - (default: ``'bottom-top'``) determines how
the braid is printed. The possible values are:
* ``'bottom-top'``, the braid is printed from bottom to top
* ``'top-bottom'``, the braid is printed from top to bottom
* ``'left-right'``, the braid is printed from left to right
- ``gap`` -- floating point number (default: 0.05). determines
the size of the gap left when a strand goes under another.
- ``aspect_ratio`` -- floating point number (default:
``1``). The aspect ratio.
- ``**kwds`` -- other keyword options that are passed to
:meth:`~sage.plot.bezier_path` and :meth:`~sage.plot.line`.
EXAMPLES::
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot()
"""
from sage.plot.bezier_path import bezier_path
from sage.plot.plot import Graphics, line
if orientation=='top-bottom':
orx = 0
ory = -1
nx = 1
ny = 0
elif orientation=='left-right':
orx = 1
ory = 0
nx = 0
ny = -1
elif orientation=='bottom-top':
orx = 0
ory = 1
nx = 1
ny = 0
else:
raise ValueError('unknown value for "orientation"')
col = color
br = self.Tietze()
n = self.strands()
a = Graphics()
op = gap
for i in range(len(br)):
m = br[i]
for j in range(n):
if m==j+1:
a += bezier_path([[(j*nx+i*orx, i*ory+j*ny), (j*nx+orx*(i+0.25), j*ny+ory*(i+0.25)),
(nx*(j+0.5)+orx*(i+0.5), ny*(j+0.5)+ory*(i+0.5))],
[(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5+4*op)+orx*(i+0.5-2*op), ny*(j-0.5+4*op)+ory*(i+0.5-2*op)),
(nx*(j-0.5+2*op)+orx*(i+0.5-op), ny*(j-0.5+2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j-0.5-2*op)+orx*(i+0.5+op), ny*(j-0.5-2*op)+ory*(i+0.5+op)),
(nx*(j-0.5-4*op)+orx*(i+0.5+2*op), ny*(j-0.5-4*op)+ory*(i+0.5+2*op)),
(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
elif -m==j+1:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j+0.5-4*op)+orx*(i+0.5-2*op), ny*(j+0.5-4*op)+ory*(i+0.5-2*op)),
(nx*(j+0.5-2*op)+orx*(i+0.5-op), ny*(j+0.5-2*op)+ory*(i+0.5-op))]],
color=col, **kwds)
a += bezier_path([[(nx*(j+0.5+2*op)+orx*(i+0.5+op), ny*(j+0.5+2*op)+ory*(i+0.5+op)),
(nx*(j+0.5+4*op)+orx*(i+0.5+2*op), ny*(j+0.5+4*op)+ory*(i+0.5+2*op)),
(nx*(j+1)+orx*(i+0.75), ny*(j+1)+ory*(i+0.75)),
(nx*(j+1)+orx*(i+1), ny*(j+1)+ory*(i+1))]], color=col, **kwds)
elif -m==j:
a += bezier_path([[(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+0.25), ny*j+ory*(i+0.25)),
(nx*(j-0.5)+orx*(i+0.5), ny*(j-0.5)+ory*(i+0.5))],
[(nx*(j-1)+orx*(i+0.75), ny*(j-1)+ory*(i+0.75)),
(nx*(j-1)+orx*(i+1), ny*(j-1)+ory*(i+1))]], color=col, **kwds)
else:
a += line([(nx*j+orx*i, ny*j+ory*i), (nx*j+orx*(i+1), ny*j+ory*(i+1))], color=col, **kwds)
a.set_aspect_ratio(aspect_ratio)
a.axes(axes)
return a
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.plot 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
