This module implements a generic algorithm to solve Knutson-Tao puzzles. An instance of this class will be callable: the arguments are the labels of north-east and north-west sides of the puzzle boundary; the output is the list of the fillings of the puzzle with the specified pieces.
This code was written during Sage Days 45 at ICERM with Franco Saliola, Anne Schilling, and Avinash Dalal in discussions with Allen Knutson. The code was tested afterwards by Liz Beazley and Ed Richmond.
Todo
Functionality to add:
The puzzle pieces used in computing the Belkale-Kumar coefficients for any
partial flag variety in type .
There are two types of puzzle pieces:
Each of these is rotated by 60 degrees, but not reflected.
We model the rhombus pieces as two triangles: a delta piece north-west
label , north-east label
and south label
; and a nabla piece
with south-east label
, south-west label
and north label
.
INPUT:
REFERENCES:
[KnutsonPurbhoo10] | A. Knutson, K. Purbhoo, Product and puzzle formulae
for ![]() |
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import BK_pieces
sage: BK_pieces(3)
Nablas : [1\1/1, 1\2(1)/2, 1\3(1)/3, 2(1)\2/1, 2\1/2(1), 2\2/2, 2\3(2)/3, 3(1)\3/1, 3(2)\3/2, 3\1/3(1), 3\2/3(2), 3\3/3]
Deltas : [1/1\1, 1/2\2(1), 1/3\3(1), 2(1)/1\2, 2/2(1)\1, 2/2\2, 2/3\3(2), 3(1)/1\3, 3(2)/2\3, 3/3(1)\1, 3/3(2)\2, 3/3\3]
Bases: sage.combinat.knutson_tao_puzzles.PuzzlePiece
Delta Piece takes as input three labels, inputted as strings. They label the South, Northwest and Northeast edges, respectively.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: DeltaPiece('a','b','c')
b/a\c
Rotates the Delta piece by 120 degree clockwise.
OUTPUT:
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: delta = DeltaPiece('1','2','3')
sage: delta.clockwise_rotation()
1/3\2
Return the tuple of edge names.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: delta = DeltaPiece('1','2','3')
sage: delta.edges()
('south', 'north_west', 'north_east')
Rotates the Delta piece by 180 degree.
OUTPUT:
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: delta = DeltaPiece('1','2','3')
sage: delta.half_turn_rotation()
3\1/2
Defines the puzzle pieces used in computing the torus-equivariant cohomology of the Grassmannian.
REFERENCES:
[KT2003] | Allen Knutson, Terence Tao, Puzzles and (equivariant) cohomology of Grassmannians, Duke Math. J. 119 (2003) 221 |
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import HT_grassmannian_pieces
sage: HT_grassmannian_pieces()
Nablas : [0\0/0, 0\10/1, 10\1/0, 1\0/10, 1\1/1, 1\T0|1/0]
Deltas : [0/0\0, 0/1\10, 0/T0|1\1, 1/10\0, 1/1\1, 10/0\1]
Defines the puzzle pieces used in computing the equivariant two step puzzle pieces.
For the puzzle pieces, see Figure 26 on page 22 of [CoskunVakil06].
REFERENCES:
[CoskunVakil06] | I. Coskun, R. Vakil, Geometric positivity in the cohomology of homogeneous spaces and generalized Schubert calculus, Arxiv math/0610538 |
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import HT_two_step_pieces
sage: HT_two_step_pieces()
Nablas : [(21)0\21/0, 0\(21)0/21, 0\0/0, 0\10/1, 0\20/2, 10\1/0, 10\2(10)/2,
1\0/10, 1\1/1, 1\21/2, 1\T0|1/0, 2(10)\2/10, 20\2/0, 21\0/(21)0, 21\2/1, 21\T0|21/0,
21\T10|21/10, 2\0/20, 2\1/21, 2\10/2(10), 2\2/2, 2\T0|2/0, 2\T10|2/10, 2\T1|2/1]
Deltas : [(21)0/0\21, 0/0\0, 0/1\10, 0/21\(21)0, 0/2\20, 0/T0|1\1, 0/T0|21\21, 0/T0|2\2,
1/10\0, 1/1\1, 1/2\21, 1/T1|2\2, 10/0\1, 10/2\2(10), 10/T10|21\21, 10/T10|2\2, 2(10)/10\2,
2/2(10)\10, 2/20\0, 2/21\1, 2/2\2, 20/0\2, 21/(21)0\0, 21/1\2]
Defines the puzzle pieces used in computing the cohomology of the Grassmannian.
REFERENCES:
[KTW] | Allen Knutson, Terence Tao, Christopher Woodward, The honeycomb model of GL(n) tensor products II: Puzzles determine facets of the Littlewood-Richardson cone, Arxiv math/0107011 |
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import H_grassmannian_pieces
sage: H_grassmannian_pieces()
Nablas : [0\0/0, 0\10/1, 10\1/0, 1\0/10, 1\1/1]
Deltas : [0/0\0, 0/1\10, 1/10\0, 1/1\1, 10/0\1]
Defines the puzzle pieces used in two step flags.
This rule is currently only conjecturally true. See [BuchKreschTamvakis03].
REFERENCES:
[BuchKreschTamvakis03] |
|
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import H_two_step_pieces
sage: H_two_step_pieces()
Nablas : [(21)0\21/0, 0\(21)0/21, 0\0/0, 0\10/1, 0\20/2, 10\1/0, 10\2(10)/2, 1\0/10, 1\1/1, 1\21/2,
2(10)\2/10, 20\2/0, 21\0/(21)0, 21\2/1, 2\0/20, 2\1/21, 2\10/2(10), 2\2/2]
Deltas : [(21)0/0\21, 0/0\0, 0/1\10, 0/21\(21)0, 0/2\20, 1/10\0, 1/1\1, 1/2\21, 10/0\1, 10/2\2(10),
2(10)/10\2, 2/2(10)\10, 2/20\0, 2/21\1, 2/2\2, 20/0\2, 21/(21)0\0, 21/1\2]
Defines the puzzle pieces used in computing the K-theory of the Grassmannian.
REFERENCES:
[Buch00] |
|
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import K_grassmannian_pieces
sage: K_grassmannian_pieces()
Nablas : [0\0/0, 0\10/1, 0\K/1, 10\1/0, 1\0/10, 1\0/K, 1\1/1, K\1/0]
Deltas : [0/0\0, 0/1\10, 1/10\0, 1/1\1, 10/0\1, K/K\K]
Bases: sage.structure.unique_representation.UniqueRepresentation
Returns puzzle solver function used to create all puzzles with given boundary conditions.
This class implements a generic algorithm to solve Knutson-Tao puzzles. An instance of this class will be callable: the arguments are the labels of north-east and north-west sides of the puzzle boundary; the output is the list of the fillings of the puzzle with the specified pieces.
INPUT:
puzzle_pieces – takes either a collection of puzzle pieces or a string indicating a pre-programmed collection of puzzle pieces:
- H – cohomology of the Grassmannian
- HT – equivariant cohomology of the Grassmannian
- K – K-theory
- H2step – cohomology of the 2-step Grassmannian
- HT2step – equivariant cohomology of the 2-step Grassmannian
- BK – Belkale-Kumar puzzle pieces
max_letter – (default: None) None or a positive integer. This is only required only for Belkale-Kumar puzzles.
EXAMPLES:
Each puzzle piece is an edge-labelled triangle oriented in such a way that it has a south edge (called a delta piece) or a north edge (called a nabla piece). For example, the puzzle pieces corresponding to the cohomology of the Grassmannian are the following:
sage: from sage.combinat.knutson_tao_puzzles import H_grassmannian_pieces
sage: H_grassmannian_pieces()
Nablas : [0\0/0, 0\10/1, 10\1/0, 1\0/10, 1\1/1]
Deltas : [0/0\0, 0/1\10, 1/10\0, 1/1\1, 10/0\1]
In the string representation, the nabla pieces are depicted as
c\a/b, where is the label of the north edge,
is the label
of the south-east edge,
is the label of the south-west edge.
A similar string representation exists for the delta pieces.
To create a puzzle solver, one specifies a collection of puzzle pieces:
sage: KnutsonTaoPuzzleSolver(H_grassmannian_pieces())
Knutson-Tao puzzle solver with pieces:
Nablas : [0\0/0, 0\10/1, 10\1/0, 1\0/10, 1\1/1]
Deltas : [0/0\0, 0/1\10, 1/10\0, 1/1\1, 10/0\1]
The following shorthand to create the above puzzle solver is also supported:
sage: KnutsonTaoPuzzleSolver('H')
Knutson-Tao puzzle solver with pieces:
Nablas : [0\0/0, 0\10/1, 10\1/0, 1\0/10, 1\1/1]
Deltas : [0/0\0, 0/1\10, 1/10\0, 1/1\1, 10/0\1]
The solver will compute all fillings of the puzzle with the given puzzle pieces. The user specifies the labels of north-east and north-west sides of the puzzle boundary and the output is a list of the fillings of the puzzle with the specified pieces. For example, there is one solution to the puzzle whose north-west and north-east edges are both labeled ‘0’:
sage: ps = KnutsonTaoPuzzleSolver('H')
sage: ps('0', '0')
[{(1, 1): 0/0\0}]
There are two solutions to the puzzle whose north-west and north-east edges are both labeled ‘0101’:
sage: ps = KnutsonTaoPuzzleSolver('H')
sage: solns = ps('0101', '0101')
sage: len(solns)
2
sage: solns.sort(key=str)
sage: solns
[{(1, 2): 1/\0 0\/1, (1, 3): 0/\0 0\/0, (3, 3): 1/1\1, (4, 4): 10/0\1, (1, 4): 1/\0 0\/1, (1, 1): 0/0\0, (2, 3): 0/\10 1\/1, (2, 2): 1/1\1, (3, 4): 0/\0 1\/10, (2, 4): 1/\1 10\/0},
{(1, 2): 1/\1 10\/0, (1, 3): 0/\0 1\/10, (3, 3): 0/0\0, (4, 4): 1/1\1, (1, 4): 1/\0 0\/1, (1, 1): 0/1\10, (2, 3): 10/\1 0\/0, (2, 2): 0/0\0, (3, 4): 1/\0 0\/1, (2, 4): 1/\1 1\/1}]
The pieces in a puzzle filling are indexed by pairs of non-negative
integers with
, where
is the
length of the word labelling the triangle edge. The pieces indexed by
are the triangles along the south edge of the puzzle.
sage: f = solns[0]
sage: [f[i, i] for i in range(1,5)]
[0/0\0, 1/1\1, 1/1\1, 10/0\1]
The pieces indexed by for
are a pair consisting of
a delta piece and nabla piece glued together along the south edge and
north edge, respectively (these pairs are called rhombi).
sage: f = solns[0]
sage: f[1, 2]
1/\0 0\/1
There are various methods and options to display puzzle solutions. A single puzzle can be displayed using the plot method of the puzzle:
sage: ps = KnutsonTaoPuzzleSolver("H")
sage: puzzle = ps('0101','1001')[0]
sage: puzzle.plot() #not tested
sage: puzzle.plot(style='fill') #not tested
sage: puzzle.plot(style='edges') #not tested
To plot several puzzle solutions, use the plot method of the puzzle solver:
sage: ps = KnutsonTaoPuzzleSolver('K')
sage: solns = ps('0101', '0101')
sage: ps.plot(solns) # not tested
The code can also generate a PDF of a puzzle (using LaTeX and tikz):
sage: latex.extra_preamble(r'''\usepackage{tikz}''')
sage: ps = KnutsonTaoPuzzleSolver('H')
sage: solns = ps('0101', '0101')
sage: view(solns[0], viewer='pdf', tightpage=True) # not tested
Below are examples of using each of the currently supported puzzles.
Cohomology of the Grassmannian:
sage: ps = KnutsonTaoPuzzleSolver("H")
sage: solns = ps('0101', '0101')
sage: sorted(solns, key=str)
[{(1, 2): 1/\0 0\/1, (1, 3): 0/\0 0\/0, (3, 3): 1/1\1, (4, 4): 10/0\1, (1, 4): 1/\0 0\/1, (1, 1): 0/0\0, (2, 3): 0/\10 1\/1, (2, 2): 1/1\1, (3, 4): 0/\0 1\/10, (2, 4): 1/\1 10\/0},
{(1, 2): 1/\1 10\/0, (1, 3): 0/\0 1\/10, (3, 3): 0/0\0, (4, 4): 1/1\1, (1, 4): 1/\0 0\/1, (1, 1): 0/1\10, (2, 3): 10/\1 0\/0, (2, 2): 0/0\0, (3, 4): 1/\0 0\/1, (2, 4): 1/\1 1\/1}]
Equivariant puzzles:
sage: ps = KnutsonTaoPuzzleSolver("HT")
sage: solns = ps('0101', '0101')
sage: sorted(solns, key=str)
[{(1, 2): 1/\0 0\/1, (1, 3): 0/\0 0\/0, (3, 3): 0/0\0, (4, 4): 1/1\1, (1, 4): 1/\0 0\/1, (1, 1): 0/0\0, (2, 3): 0/\1 1\/0, (2, 2): 1/1\1, (3, 4): 1/\0 0\/1, (2, 4): 1/\1 1\/1},
{(1, 2): 1/\0 0\/1, (1, 3): 0/\0 0\/0, (3, 3): 1/1\1, (4, 4): 10/0\1, (1, 4): 1/\0 0\/1, (1, 1): 0/0\0, (2, 3): 0/\10 1\/1, (2, 2): 1/1\1, (3, 4): 0/\0 1\/10, (2, 4): 1/\1 10\/0},
{(1, 2): 1/\1 10\/0, (1, 3): 0/\0 1\/10, (3, 3): 0/0\0, (4, 4): 1/1\1, (1, 4): 1/\0 0\/1, (1, 1): 0/1\10, (2, 3): 10/\1 0\/0, (2, 2): 0/0\0, (3, 4): 1/\0 0\/1, (2, 4): 1/\1 1\/1}]
K-Theory puzzles:
sage: ps = KnutsonTaoPuzzleSolver("K")
sage: solns = ps('0101', '0101')
sage: sorted(solns, key=str)
[{(1, 2): 1/\0 0\/1, (1, 3): 0/\0 0\/0, (3, 3): 1/1\1, (4, 4): 10/0\1, (1, 4): 1/\0 0\/1, (1, 1): 0/0\0, (2, 3): 0/\10 1\/1, (2, 2): 1/1\1, (3, 4): 0/\0 1\/10, (2, 4): 1/\1 10\/0},
{(1, 2): 1/\1 10\/0, (1, 3): 0/\0 1\/10, (3, 3): 0/0\0, (4, 4): 1/1\1, (1, 4): 1/\0 0\/1, (1, 1): 0/1\10, (2, 3): 10/\1 0\/0, (2, 2): 0/0\0, (3, 4): 1/\0 0\/1, (2, 4): 1/\1 1\/1},
{(1, 2): 1/\1 10\/0, (1, 3): 0/\0 1\/K, (3, 3): 1/1\1, (4, 4): 10/0\1, (1, 4): 1/\0 0\/1, (1, 1): 0/1\10, (2, 3): K/\K 0\/1, (2, 2): 0/0\0, (3, 4): 0/\0 1\/10, (2, 4): 1/\1 K\/0}]
Two-step puzzles:
sage: ps = KnutsonTaoPuzzleSolver("H2step")
sage: solns = ps('01201', '01021')
sage: sorted(solns, key=str)
[{(1, 2): 1/\0 0\/1, (1, 3): 2/\0 0\/2, (3, 3): 1/1\1, (4, 5): 20/\2 1\/10, (4, 4): 1/1\1, (5, 5): 10/0\1, (1, 4): 0/\0 0\/0, (1, 1): 0/0\0, (1, 5): 1/\0 0\/1, (2, 3): 2/\2 21\/1, (2, 2): 1/2\21, (2, 5): 1/\1 10\/0, (3, 4): 21/\2 1\/1, (2, 4): 0/\10 2\/21, (3, 5): 0/\0 2\/20},
{(1, 2): 1/\1 10\/0, (1, 3): 2/\1 1\/2, (3, 3): 0/0\0, (4, 5): 2(10)/\2 0\/1, (4, 4): 0/0\0, (5, 5): 1/1\1, (1, 4): 0/\0 1\/10, (1, 1): 0/1\10, (1, 5): 1/\0 0\/1, (2, 3): 2/\2 20\/0, (2, 2): 0/2\20, (2, 5): 1/\1 1\/1, (3, 4): 20/\2 0\/0, (2, 4): 10/\1 2\/20, (3, 5): 1/\0 2\/2(10)},
{(1, 2): 1/\21 20\/0, (1, 3): 2/\2 21\/1, (3, 3): 1/1\1, (4, 5): 21/\2 1\/1, (4, 4): 10/0\1, (5, 5): 1/1\1, (1, 4): 0/\0 2\/20, (1, 1): 0/2\20, (1, 5): 1/\0 0\/1, (2, 3): 1/\0 0\/1, (2, 2): 0/0\0, (2, 5): 1/\1 2\/21, (3, 4): 0/\0 1\/10, (2, 4): 20/\2 0\/0, (3, 5): 21/\0 0\/21}]
Two-step equivariant puzzles:
sage: ps = KnutsonTaoPuzzleSolver("HT2step")
sage: solns = ps('10212', '12012')
sage: sorted(solns, key=str)
[{(1, 2): 0/\(21)0 1\/2, (1, 3): 2/\1 (21)0\/0, (3, 3): 0/0\0, (4, 5): 1/\1 2\/21, (4, 4): 2/2\2, (5, 5): 21/1\2, (1, 4): 1/\1 1\/1, (1, 1): 1/1\1, (1, 5): 2/\1 1\/2, (2, 3): 0/\2 2\/0, (2, 2): 2/2\2, (2, 5): 2/\2 21\/1, (3, 4): 2/\0 0\/2, (2, 4): 1/\21 2\/2, (3, 5): 1/\0 0\/1},
{(1, 2): 0/\(21)0 1\/2, (1, 3): 2/\1 (21)0\/0, (3, 3): 0/0\0, (4, 5): 2/\1 1\/2, (4, 4): 1/1\1, (5, 5): 2/2\2, (1, 4): 1/\1 1\/1, (1, 1): 1/1\1, (1, 5): 2/\1 1\/2, (2, 3): 0/\2 2\/0, (2, 2): 2/2\2, (2, 5): 2/\2 2\/2, (3, 4): 1/\0 0\/1, (2, 4): 1/\2 2\/1, (3, 5): 2/\0 0\/2},
{(1, 2): 0/\(21)0 1\/2, (1, 3): 2/\1 (21)0\/0, (3, 3): 2/2\2, (4, 5): 1/\1 2\/21, (4, 4): 20/0\2, (5, 5): 21/1\2, (1, 4): 1/\1 1\/1, (1, 1): 1/1\1, (1, 5): 2/\1 1\/2, (2, 3): 0/\20 2\/2, (2, 2): 2/2\2, (2, 5): 2/\2 21\/1, (3, 4): 0/\0 2\/20, (2, 4): 1/\21 20\/0, (3, 5): 1/\0 0\/1},
{(1, 2): 0/\1 1\/0, (1, 3): 2/\1 1\/2, (3, 3): 0/0\0, (4, 5): 1/\1 2\/21, (4, 4): 2/2\2, (5, 5): 21/1\2, (1, 4): 1/\1 1\/1, (1, 1): 1/1\1, (1, 5): 2/\1 1\/2, (2, 3): 2/\2 20\/0, (2, 2): 0/2\20, (2, 5): 2/\2 21\/1, (3, 4): 2/\0 0\/2, (2, 4): 1/\21 2\/2, (3, 5): 1/\0 0\/1},
{(1, 2): 0/\1 1\/0, (1, 3): 2/\1 1\/2, (3, 3): 0/0\0, (4, 5): 2/\1 1\/2, (4, 4): 1/1\1, (5, 5): 2/2\2, (1, 4): 1/\1 1\/1, (1, 1): 1/1\1, (1, 5): 2/\1 1\/2, (2, 3): 2/\2 20\/0, (2, 2): 0/2\20, (2, 5): 2/\2 2\/2, (3, 4): 1/\0 0\/1, (2, 4): 1/\2 2\/1, (3, 5): 2/\0 0\/2},
{(1, 2): 0/\10 1\/1, (1, 3): 2/\10 10\/2, (3, 3): 1/1\1, (4, 5): 10/\1 2\/20, (4, 4): 2/2\2, (5, 5): 20/0\2, (1, 4): 1/\1 10\/0, (1, 1): 1/1\1, (1, 5): 2/\1 1\/2, (2, 3): 2/\2 21\/1, (2, 2): 1/2\21, (2, 5): 2/\2 20\/0, (3, 4): 2/\1 1\/2, (2, 4): 0/\20 2\/2, (3, 5): 0/\0 1\/10},
{(1, 2): 0/\10 1\/1, (1, 3): 2/\10 10\/2, (3, 3): 1/1\1, (4, 5): 2/\1 1\/2, (4, 4): 10/0\1, (5, 5): 2/2\2, (1, 4): 1/\1 10\/0, (1, 1): 1/1\1, (1, 5): 2/\1 1\/2, (2, 3): 2/\2 21\/1, (2, 2): 1/2\21, (2, 5): 2/\2 2\/2, (3, 4): 0/\0 1\/10, (2, 4): 0/\2 2\/0, (3, 5): 2/\0 0\/2},
{(1, 2): 0/\20 21\/1, (1, 3): 2/\2 20\/0, (3, 3): 0/0\0, (4, 5): 2/\1 1\/2, (4, 4): 1/1\1, (5, 5): 2/2\2, (1, 4): 1/\1 2\/21, (1, 1): 1/2\21, (1, 5): 2/\1 1\/2, (2, 3): 0/\1 1\/0, (2, 2): 1/1\1, (2, 5): 2/\2 2\/2, (3, 4): 1/\0 0\/1, (2, 4): 21/\2 1\/1, (3, 5): 2/\0 0\/2},
{(1, 2): 0/\20 21\/1, (1, 3): 2/\2 20\/0, (3, 3): 1/1\1, (4, 5): 2/\1 1\/2, (4, 4): 10/0\1, (5, 5): 2/2\2, (1, 4): 1/\1 2\/21, (1, 1): 1/2\21, (1, 5): 2/\1 1\/2, (2, 3): 0/\10 1\/1, (2, 2): 1/1\1, (2, 5): 2/\2 2\/2, (3, 4): 0/\0 1\/10, (2, 4): 21/\2 10\/0, (3, 5): 2/\0 0\/2},
{(1, 2): 0/\21 21\/0, (1, 3): 2/\2 21\/1, (3, 3): 0/0\0, (4, 5): 2/\1 1\/2, (4, 4): 1/1\1, (5, 5): 2/2\2, (1, 4): 1/\1 2\/21, (1, 1): 1/2\21, (1, 5): 2/\1 1\/2, (2, 3): 1/\1 10\/0, (2, 2): 0/1\10, (2, 5): 2/\2 2\/2, (3, 4): 1/\0 0\/1, (2, 4): 21/\2 1\/1, (3, 5): 2/\0 0\/2}]
Belkale-Kumar puzzles (the following example is Figure 2 of [KnutsonPurbhoo10]):
sage: ps = KnutsonTaoPuzzleSolver('BK', 3)
sage: solns = ps('12132', '23112')
sage: len(solns)
1
sage: solns[0].south_labels()
('3', '2', '1', '2', '1')
sage: solns
[{(1, 2): 2/\3(2) 3(1)\/1, (1, 3): 1/\3(1) 3(2)\/2, (3, 3): 1/1\1, (4, 5): 1/\1 2\/2(1), (4, 4): 2/2\2, (5, 5): 2(1)/1\2, (1, 4): 3/\3 3(1)\/1, (1, 1): 1/3\3(1), (1, 5): 2/\2 3\/3(2), (2, 3): 2/\2 2(1)\/1, (2, 2): 1/2\2(1), (2, 5): 3(2)/\3 2(1)\/1, (3, 4): 2/\1 1\/2, (2, 4): 1/\2(1) 2\/2, (3, 5): 1/\1 1\/1}]
Return plot of puzzles.
INPUT:
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import KnutsonTaoPuzzleSolver
sage: ps = KnutsonTaoPuzzleSolver('K')
sage: solns = ps('0101', '0101')
sage: ps.plot(solns) # not tested
The puzzle pieces used for filling in the puzzles.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import KnutsonTaoPuzzleSolver
sage: ps = KnutsonTaoPuzzleSolver('H')
sage: ps.puzzle_pieces()
Nablas : [0\0/0, 0\10/1, 10\1/0, 1\0/10, 1\1/1]
Deltas : [0/0\0, 0/1\10, 1/10\0, 1/1\1, 10/0\1]
TESTS:
sage: from sage.combinat.knutson_tao_puzzles import KnutsonTaoPuzzleSolver
sage: ps = KnutsonTaoPuzzleSolver("H")
sage: ps('0101','1001')
[{(1, 2): 1/\1 10\/0, (1, 3): 0/\10 1\/1, (3, 3): 1/1\1, (4, 4): 10/0\1, (1, 4): 1/\1 10\/0,
(1, 1): 0/1\10, (2, 3): 1/\0 0\/1, (2, 2): 0/0\0, (3, 4): 0/\0 1\/10, (2, 4): 0/\0 0\/0}]
sage: ps('0101','1001',algorithm='pieces')
[{(1, 2): 1/\1 10\/0, (1, 3): 0/\10 1\/1, (3, 3): 1/1\1, (4, 4): 10/0\1, (1, 4): 1/\1 10\/0,
(2, 4): 0/\0 0\/0, (2, 3): 1/\0 0\/1, (2, 2): 0/0\0, (3, 4): 0/\0 1\/10, (1, 1): 0/1\10}]
Compute cohomology structure coefficients from puzzles.
INPUT:
OUTPUT: dictionary
EXAMPLES:
Note: In order to standardize the output of the following examples, we output a sorted list of items from the dictionary instead of the dictionary itself.
Grassmannian cohomology:
sage: ps = KnutsonTaoPuzzleSolver('H')
sage: cp = ps.structure_constants('0101', '0101')
sage: sorted(cp.items(), key=str)
[(('0', '1', '1', '0'), 1), (('1', '0', '0', '1'), 1)]
sage: ps.structure_constants('001001', '001010', '010100')
1
Equivariant cohomology:
sage: ps = KnutsonTaoPuzzleSolver('HT')
sage: cp = ps.structure_constants('0101', '0101')
sage: sorted(cp.items(), key=str)
[(('0', '1', '0', '1'), y2 - y3),
(('0', '1', '1', '0'), 1),
(('1', '0', '0', '1'), 1)]
K-theory:
sage: ps = KnutsonTaoPuzzleSolver('K')
sage: cp = ps.structure_constants('0101', '0101')
sage: sorted(cp.items(), key=str)
[(('0', '1', '1', '0'), 1), (('1', '0', '0', '1'), 1), (('1', '0', '1', '0'), -1)]
Two-step:
sage: ps = KnutsonTaoPuzzleSolver('H2step')
sage: cp = ps.structure_constants('01122', '01122')
sage: sorted(cp.items(), key=str)
[(('0', '1', '1', '2', '2'), 1)]
sage: cp = ps.structure_constants('01201', '01021')
sage: sorted(cp.items(), key=str)
[(('0', '2', '1', '1', '0'), 1),
(('1', '2', '0', '0', '1'), 1),
(('2', '0', '1', '0', '1'), 1)]
Two-step equivariant:
sage: ps = KnutsonTaoPuzzleSolver('HT2step')
sage: cp = ps.structure_constants('10212', '12012')
sage: sorted(cp.items(), key=str)
[(('1', '2', '0', '1', '2'), y1*y2 - y2*y3 - y1*y4 + y3*y4),
(('1', '2', '0', '2', '1'), y1 - y3),
(('1', '2', '1', '0', '2'), y2 - y4),
(('1', '2', '1', '2', '0'), 1),
(('1', '2', '2', '0', '1'), 1),
(('2', '1', '0', '1', '2'), y1 - y3),
(('2', '1', '1', '0', '2'), 1)]
Bases: sage.combinat.knutson_tao_puzzles.PuzzlePiece
Nabla Piece takes as input three labels, inputted as strings. They label the North, Southeast and Southwest edges, respectively.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import NablaPiece
sage: NablaPiece('a','b','c')
c\a/b
Rotates the Nabla piece by 120 degree clockwise.
OUTPUT:
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import NablaPiece
sage: nabla = NablaPiece('1','2','3')
sage: nabla.clockwise_rotation()
2\3/1
Return the tuple of edge names.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import NablaPiece
sage: nabla = NablaPiece('1','2','3')
sage: nabla.edges()
('north', 'south_east', 'south_west')
Rotates the Nabla piece by 180 degree.
OUTPUT:
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import NablaPiece
sage: nabla = NablaPiece('1','2','3')
sage: nabla.half_turn_rotation()
2/1\3
Bases: object
Create partial puzzles and provides methods to build puzzles from them.
Adds piece to partial puzzle.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece, PuzzleFilling
sage: piece = DeltaPiece('0','1','0')
sage: P = PuzzleFilling('0101','0101'); P
{}
sage: P.add_piece(piece); P
{(1, 4): 1/0\0}
Adds piece to partial puzzle.
INPUT:
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece, PuzzleFilling
sage: P = PuzzleFilling('0101','0101'); P
{}
sage: piece = DeltaPiece('0','1','0')
sage: pieces = [piece,piece]
sage: P.add_pieces(pieces)
sage: P
{(2, 4): 1/0\0, (1, 4): 1/0\0}
Return equivariant contributions from self in polynomial ring.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import KnutsonTaoPuzzleSolver
sage: ps = KnutsonTaoPuzzleSolver("HT")
sage: puzzles = ps('0101','1001')
sage: sorted([p.contribution() for p in puzzles], key=str)
[1, y1 - y3]
Return copy of self.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece, PuzzleFilling
sage: piece = DeltaPiece('0','1','0')
sage: P = PuzzleFilling('0101','0101'); P
{}
sage: PP = P.copy()
sage: P.add_piece(piece); P
{(1, 4): 1/0\0}
sage: PP
{}
Whether partial puzzle is complete (completely filled) or not.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzleFilling
sage: P = PuzzleFilling('0101','0101')
sage: P.is_completed()
False
sage: from sage.combinat.knutson_tao_puzzles import KnutsonTaoPuzzleSolver
sage: ps = KnutsonTaoPuzzleSolver("H")
sage: puzzle = ps('0101','1001')[0]
sage: puzzle.is_completed()
True
Checks whether kink coordinates of partial puzzle is in south corner.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzleFilling
sage: P = PuzzleFilling('0101','0101')
sage: P.is_in_south_edge()
False
Provides the coordinates of the kinks.
The kink coordinates are the coordinates up to which the puzzle has already been built. The kink starts in the north corner and then moves down the diagonals as the puzzles is built.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzleFilling
sage: P = PuzzleFilling('0101','0101')
sage: P
{}
sage: P.kink_coordinates()
(1, 4)
Return north east label of kink.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzleFilling
sage: P = PuzzleFilling('0101','0101')
sage: P.north_east_label_of_kink()
'0'
Return north-west label of kink.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzleFilling
sage: P = PuzzleFilling('0101','0101')
sage: P.north_west_label_of_kink()
'1'
Plots completed puzzle.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import KnutsonTaoPuzzleSolver
sage: ps = KnutsonTaoPuzzleSolver("H")
sage: puzzle = ps('0101','1001')[0]
sage: puzzle.plot() #not tested
sage: puzzle.plot(style='fill') #not tested
sage: puzzle.plot(style='edges') #not tested
Return south labels for completed puzzle.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import KnutsonTaoPuzzleSolver
sage: ps = KnutsonTaoPuzzleSolver("H")
sage: ps('0101','1001')[0].south_labels()
('1', '0', '1', '0')
Bases: object
Abstract class for puzzle pieces.
This abstract class contains information on how to test equality of puzzle pieces, and sets color and plotting options.
Returns the border of self.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: delta = DeltaPiece('a','b','c')
sage: delta.border()
('a', 'b', 'c')
Returns the color of self.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: delta = DeltaPiece('a','b','c')
sage: delta.color()
'white'
sage: delta = DeltaPiece('0','0','0')
sage: delta.color()
'red'
sage: delta = DeltaPiece('1','1','1')
sage: delta.color()
'blue'
sage: delta = DeltaPiece('2','2','2')
sage: delta.color()
'green'
sage: delta = DeltaPiece('2','K','2')
sage: delta.color()
'orange'
sage: delta = DeltaPiece('2','T1/2','2')
sage: delta.color()
'yellow'
Color of the specified edge of self (to be used when plotting the piece).
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: delta = DeltaPiece('1','0','10')
sage: delta.edge_color('south')
'blue'
sage: delta.edge_color('north_west')
'red'
sage: delta.edge_color('north_east')
'white'
Return the edge label of edge.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece
sage: delta = DeltaPiece('2','K','2')
sage: delta.edge_label('south')
'2'
sage: delta.edge_label('north_east')
'2'
sage: delta.edge_label('north_west')
'K'
Bases: object
Construct a valid set of puzzle pieces.
This class constructs the set of valid puzzle pieces. It can take a list of forbidden border labels as input. These labels are forbidden from appearing on the south edge of a puzzle filling. The user can add valid nabla or delta pieces and specify which rotations of these pieces are legal. For example, rotations=0 does not add any additional pieces (only the piece itself), rotations=60 adds six pieces (the pieces and its rotations by 60, 120, 180, 240, 300), etc..
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces, NablaPiece
sage: forbidden_border_labels = ['10']
sage: pieces = PuzzlePieces(forbidden_border_labels)
sage: pieces.add_piece(NablaPiece('0','0','0'), rotations=60)
sage: pieces.add_piece(NablaPiece('1','1','1'), rotations=60)
sage: pieces.add_piece(NablaPiece('1','0','10'), rotations=60)
sage: pieces
Nablas : [0\0/0, 0\10/1, 10\1/0, 1\0/10, 1\1/1]
Deltas : [0/0\0, 0/1\10, 1/10\0, 1/1\1, 10/0\1]
The user can obtain the list of valid rhombi pieces as follows:
sage: sorted([p for p in pieces.rhombus_pieces()], key=str)
[0/\0 0\/0, 0/\0 1\/10, 0/\10 10\/0, 0/\10 1\/1, 1/\0 0\/1,
1/\1 10\/0, 1/\1 1\/1, 10/\1 0\/0, 10/\1 1\/10]
Adds a nabla and delta piece with label1 and label2.
This method adds a nabla piece with edges label2T``label1``|``label2`` / label1. and a delta piece with edges label1/ T``label1``|``label2`` label2. It also adds T``label1``|``label2`` to the forbidden list.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces
sage: pieces = PuzzlePieces()
sage: pieces.add_T_piece('1','3')
sage: pieces
Nablas : [3\T1|3/1]
Deltas : [1/T1|3\3]
sage: pieces._forbidden_border_labels
['T1|3']
Adds forbidden border labels.
INPUT:
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces
sage: pieces = PuzzlePieces()
sage: pieces.add_forbidden_label('1')
sage: pieces._forbidden_border_labels
['1']
sage: pieces.add_forbidden_label('2')
sage: pieces._forbidden_border_labels
['1', '2']
Adds piece to the list of pieces.
INPUT:
The user can add valid nabla or delta pieces and specify which rotations of these pieces are legal. For example, rotations=0 does not add any additional pieces (only the piece itself), rotations=60 adds six pieces (namely three delta and three nabla pieces), while rotations=120 adds only delta or nabla (depending on which piece self is). rotations=180 adds the piece and its 180 degree rotation, i.e. one delta and one nabla piece.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces, DeltaPiece
sage: delta = DeltaPiece('a','b','c')
sage: pieces = PuzzlePieces()
sage: pieces
Nablas : []
Deltas : []
sage: pieces.add_piece(delta)
sage: pieces
Nablas : []
Deltas : [a/c\b, b/a\c, c/b\a]
sage: pieces = PuzzlePieces()
sage: pieces.add_piece(delta,rotations=0)
sage: pieces
Nablas : []
Deltas : [b/a\c]
sage: pieces = PuzzlePieces()
sage: pieces.add_piece(delta,rotations=60)
sage: pieces
Nablas : [a\b/c, b\c/a, c\a/b]
Deltas : [a/c\b, b/a\c, c/b\a]
Returns deltas with south edges not in the forbidden list.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces, DeltaPiece
sage: pieces = PuzzlePieces(['a'])
sage: delta = DeltaPiece('a','b','c')
sage: pieces.add_piece(delta,rotations=60)
sage: sorted([p for p in pieces.boundary_deltas()], key=str)
[a/c\b, c/b\a]
Returns the delta pieces as a set.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces, DeltaPiece
sage: pieces = PuzzlePieces()
sage: delta = DeltaPiece('a','b','c')
sage: pieces.add_piece(delta,rotations=60)
sage: sorted([p for p in pieces.delta_pieces()], key=str)
[a/c\b, b/a\c, c/b\a]
Returns the nabla pieces as a set.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces, DeltaPiece
sage: pieces = PuzzlePieces()
sage: delta = DeltaPiece('a','b','c')
sage: pieces.add_piece(delta,rotations=60)
sage: sorted([p for p in pieces.nabla_pieces()], key=str)
[a\b/c, b\c/a, c\a/b]
Returns a list of all allowable rhombus pieces.
Allowable rhombus pieces are those where the south edge of the delta piece equals the north edge of the nabla piece.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import PuzzlePieces, DeltaPiece
sage: pieces = PuzzlePieces()
sage: delta = DeltaPiece('a','b','c')
sage: pieces.add_piece(delta,rotations=60)
sage: sorted([p for p in pieces.rhombus_pieces()], key=str)
[a/\b b\/a, b/\c c\/b, c/\a a\/c]
Bases: sage.combinat.knutson_tao_puzzles.PuzzlePiece
Class of rhombi pieces.
To construct a rhombus piece we input a delta and a nabla piece. The delta and nabla pieces are joined along the south and north edge, respectively.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece, NablaPiece, RhombusPiece
sage: delta = DeltaPiece('1','2','3')
sage: nabla = NablaPiece('4','5','6')
sage: RhombusPiece(delta,nabla)
2/\3 6\/5
Return the tuple of edge names.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece, NablaPiece, RhombusPiece
sage: delta = DeltaPiece('1','2','3')
sage: nabla = NablaPiece('4','5','6')
sage: RhombusPiece(delta,nabla).edges()
('north_west', 'north_east', 'south_east', 'south_west')
Return the north piece.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece, NablaPiece, RhombusPiece
sage: delta = DeltaPiece('1','2','3')
sage: nabla = NablaPiece('4','5','6')
sage: r = RhombusPiece(delta,nabla)
sage: r.north_piece()
2/1\3
Return the south piece.
EXAMPLES:
sage: from sage.combinat.knutson_tao_puzzles import DeltaPiece, NablaPiece, RhombusPiece
sage: delta = DeltaPiece('1','2','3')
sage: nabla = NablaPiece('4','5','6')
sage: r = RhombusPiece(delta,nabla)
sage: r.south_piece()
6\4/5