2d Substitutions¶
2d substitutions
EXAMPLES:
sage: from slabbe import Substitution2d
sage: A = [[0,1],[2,3]]
sage: B = [[4,5]]
sage: d = {0:A, 1:B}
sage: s = Substitution2d(d)
sage: s
Substitution 2d: {0: [[0, 1], [2, 3]], 1: [[4, 5]]}
Notice here that we are using Cartesian-like coordinates as opposed to matrix-like coordinates:
sage: image = s([[0]])
sage: image
[[0, 1], [2, 3]]
sage: x = 1
sage: y = 0
sage: image[x][y]
2
Computing the image of a 2-dimensional word:
sage: A = [[0,1],[2,3]]
sage: B = [[4,5],[6,7]]
sage: C = [[8,9]]
sage: d = {0:A, 1:B, 2:C}
sage: s = Substitution2d(d)
sage: table = [[0,1],[1,1]]
sage: s(table)
[[0, 1, 4, 5], [2, 3, 6, 7], [4, 5, 4, 5], [6, 7, 6, 7]]
- class slabbe.substitution_2d.Substitution2d(d)¶
Bases:
object
INPUT:
d
– dict, key -> value, where each value is a table such that table[x][y] refers to the tile at position (x,y) in cartesian coordinates (not in the matrix-like coordinates)
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[2,3]] sage: B = [[4,5]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: s Substitution 2d: {0: [[0, 1], [2, 3]], 1: [[4, 5]]}
Computing the iterative images of a letter under a 2-dimensional substitution:
sage: A = [[0,1],[2,0]] sage: B = [[2,1],[2,0]] sage: C = [[1,2],[1,1]] sage: d = {0:A, 1:B, 2:C} sage: s = Substitution2d(d) sage: s([[0]]) [[0, 1], [2, 0]] sage: s([[0]], 2) [[0, 1, 2, 1], [2, 0, 2, 0], [1, 2, 0, 1], [1, 1, 2, 0]] sage: s([[0]], 3) [[0, 1, 2, 1, 1, 2, 2, 1], [2, 0, 2, 0, 1, 1, 2, 0], [1, 2, 0, 1, 1, 2, 0, 1], [1, 1, 2, 0, 1, 1, 2, 0], [2, 1, 1, 2, 0, 1, 2, 1], [2, 0, 1, 1, 2, 0, 2, 0], [2, 1, 2, 1, 1, 2, 0, 1], [2, 0, 2, 0, 1, 1, 2, 0]]
Computing the product of two 2-dimensional substitutions:
sage: t = s*s
- apply_matrix_transformation(M)¶
INPUT:
M
– matrix in SL(2,Z)
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[0,1]] sage: B = [[1,0],[1,1]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: M = matrix(2, (1,1,0,1)) sage: s Substitution 2d: {0: [[0, 1], [0, 1]], 1: [[1, 0], [1, 1]]} sage: s.apply_matrix_transformation(M) Substitution 2d: {0: [[0, None], [0, 1], [None, 1]], 1: [[1, None], [1, 0], [None, 1]]}
- call_on_column(column, heights=None)¶
INPUT:
column
– listheights
– None or list (default:None
)
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[2,3]] sage: B = [[4],[5]] sage: C = [[6,7,8]] sage: d = {0:A, 1:B, 2:C} sage: s = Substitution2d(d) sage: s.call_on_column([0]) [[0, 1], [2, 3]] sage: s.call_on_column([0,1]) [[0, 1, 4], [2, 3, 5]] sage: s.call_on_column([0,1,1,0,0]) [[0, 1, 4, 4, 0, 1, 0, 1], [2, 3, 5, 5, 2, 3, 2, 3]]
It can compute the image of columns with
None
as entries:sage: s.call_on_column([0,None], heights=[2,3]) [[0, 1, None, None, None], [2, 3, None, None, None]] sage: s.call_on_column([0,None], heights=[2,2]) [[0, 1, None, None], [2, 3, None, None]] sage: s.call_on_column([None], heights=[3]) [[None, None, None]]
TESTS:
sage: s.call_on_column([]) [] sage: s.call_on_column([0,2]) Traceback (most recent call last): ... ValueError: the image of 2 in the column (=[0, 2]) has width 1 but the image of another has width 2
- call_on_row(row)¶
INPUT:
row
– list
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[2,3]] sage: B = [[4,5]] sage: C = [[6,7,8]] sage: d = {0:A, 1:B, 2:C} sage: s = Substitution2d(d) sage: row = [0,1,1,0] sage: s.call_on_row(row) [[0, 1], [2, 3], [4, 5], [4, 5], [0, 1], [2, 3]] sage: s.call_on_row([2]) [[6, 7, 8]]
TESTS:
sage: s.call_on_row([]) [] sage: s.call_on_row([1,2]) Traceback (most recent call last): ... ValueError: the image of the row contains columns of different height (={2, 3})
- codomain_alphabet()¶
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[5,6],[7,8]] sage: B = [[6,5],[9,8]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: s.codomain_alphabet() {5, 6, 7, 8, 9}
Blank
None
are ignored:sage: A = [[5,6],[7,8]] sage: B = [[6,5],[9,None]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: s.codomain_alphabet() {5, 6, 7, 8, 9}
- desubstitute(tiles, function=None)¶
Return the Wang tile set obtained from the desubstitution of the given Wang tile set.
INPUT:
tiles
– list of Wang tiles, each tile being a 4-tuple of (east, north, west, south) colorsfn
– a function (default:None
) to apply to the new colors which are tuple of previous colors
OUTPUT:
dict, key -> tile
- domain_alphabet()¶
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[5,6],[7,8]] sage: B = [[6,5],[9,8]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: s.domain_alphabet() {0, 1}
- fixed_point_tikz(seed, niterations=3)¶
Return a tikz representation of a fixed point defined by the give seed. In the image, rectangular boxes indicate the i-th image of each seed.
INPUT:
seed
– 2x2 matrixniterations
– (default:3
), number of iterations
OUTPUT
tikz picture
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[1,1],[1,1]] sage: B = [[0,0]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: tikz = s.fixed_point_tikz([[0,0],[0,0]]) sage: _ = tikz.pdf() # not tested
The substitution
s
is not prolongable, so the boxes in the image obtained from the square ofs
might better:sage: s2 = s*s sage: tikz = s2.fixed_point_tikz([[0,0],[0,0]]) sage: _ = tikz.pdf() # not tested
- classmethod from_1d_column_substitution(s)¶
INPUT:
s
– dict
EXAMPLES:
sage: from slabbe import Substitution2d sage: fibo = {0:[0,1], 1:[0]} sage: s = Substitution2d.from_1d_column_substitution(fibo) sage: s Substitution 2d: {0: [[0, 1]], 1: [[0]]}
- classmethod from_1d_row_column_substitutions(s_row, s_column)¶
INPUT:
s_row
– dicts_column
– dict
EXAMPLES:
sage: from slabbe import Substitution2d sage: fibo = {0:[0,1], 1:[0]} sage: s = Substitution2d.from_1d_row_column_substitutions(fibo, fibo) sage: s Substitution 2d: {0: [[0, 1], [2, 3]], 1: [[0], [2]], 2: [[0, 1]], 3: [[0]]}
- classmethod from_1d_row_substitution(s)¶
INPUT:
s
– dict
EXAMPLES:
sage: from slabbe import Substitution2d sage: fibo = {0:[0,1], 1:[0]} sage: s = Substitution2d.from_1d_row_substitution(fibo) sage: s Substitution 2d: {0: [[0], [1]], 1: [[0]]}
- classmethod from_permutation(d)¶
INPUT:
d
– dict
EXAMPLES:
sage: from slabbe import Substitution2d sage: s = Substitution2d.from_permutation({4:0, 5:1}) sage: s Substitution 2d: {4: [[0]], 5: [[1]]}
sage: A = [[5,6],[7,8]] sage: B = [[6,5],[9,8]] sage: t = Substitution2d({0:A, 1:B}) sage: t Substitution 2d: {0: [[5, 6], [7, 8]], 1: [[6, 5], [9, 8]]} sage: t*s Substitution 2d: {4: [[5, 6], [7, 8]], 5: [[6, 5], [9, 8]]}
sage: u = Substitution2d.from_permutation({5:0, 6:1, 7:2, 8:3, 9:4}) sage: u Substitution 2d: {5: [[0]], 6: [[1]], 7: [[2]], 8: [[3]], 9: [[4]]} sage: u * t Substitution 2d: {0: [[0, 1], [2, 3]], 1: [[1, 0], [4, 3]]}
- incidence_matrix()¶
Return the incidence matrix of self.
Some default ordering (sorted) is used for the domain and codomain alphabet.
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[2,3]] sage: B = [[4,5]] sage: C = [[6,7,8]] sage: d = {0:A, 1:B, 2:C} sage: s = Substitution2d(d) sage: s.incidence_matrix() [1 0 0] [1 0 0] [1 0 0] [1 0 0] [0 1 0] [0 1 0] [0 0 1] [0 0 1] [0 0 1]
- inverse()¶
Return the inverse of self (when self is a permutation).
EXAMPLES:
sage: from slabbe import Substitution2d sage: d = {0:7, 1:8} sage: s = Substitution2d.from_permutation(d) sage: s Substitution 2d: {0: [[7]], 1: [[8]]} sage: s.inverse() Substitution 2d: {7: [[0]], 8: [[1]]}
TESTS:
sage: s = Substitution2d({8: [[1]], 7: [[0,1]]}) sage: s.inverse() Traceback (most recent call last): ... ValueError: self must be a permutation but image of 7 is [[0, 1]]
- letter_to_letter_dict(pos=(0, 0))¶
Return the inverse of self (when self is a permutation).
INPUT:
pos
– tuple (default:(0,0)
), tuple of two integers
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[2,3]] sage: B = [[4,5]] sage: s = Substitution2d({0:A, 1:B}) sage: s Substitution 2d: {0: [[0, 1], [2, 3]], 1: [[4, 5]]} sage: s.letter_to_letter_dict(pos=(0,0)) {0: 0, 1: 4}
- lines_alphabet(direction='horizontal')¶
Return the possible alphabets on lines, i.e., the possible alphabet of letters that we see on a given line.
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[0,1]] sage: B = [[1,0],[1,1]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: sorted(s.lines_alphabet()) [(0,), (0, 1), (1,)] sage: sorted(s.lines_alphabet(direction='vertical')) [(0, 1), (1,)]
- list_2x2_factors(F=None)¶
Return the list of 2x2 factors in the associated substitutive shift. If a list of factors
F
is given, it restrict to the factors inside the image ofF
.INPUT:
self
– expansive and primitive 2d substitutionF
– list of factors in the domain orNone
, if given the output is restricted to the factors inF
OUTPUT:
list of tables
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[0,1]] sage: B = [[1,0],[1,1]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: sorted(s.list_2x2_factors()) [[[0, 0], [1, 0]], [[0, 1], [0, 1]], [[0, 1], [1, 0]], [[0, 1], [1, 1]], [[1, 0], [0, 0]], [[1, 0], [0, 1]], [[1, 0], [1, 0]], [[1, 0], [1, 1]], [[1, 1], [0, 0]], [[1, 1], [0, 1]], [[1, 1], [1, 0]], [[1, 1], [1, 1]]]
Restricting to the images of some factors:
sage: sorted(s.list_2x2_factors([A])) [[[0, 1], [0, 1]], [[1, 0], [1, 1]], [[1, 1], [1, 0]], [[1, 1], [1, 1]]] sage: sorted(s.list_2x2_factors([B])) [[[0, 0], [1, 0]], [[0, 1], [0, 1]], [[0, 1], [1, 0]], [[0, 1], [1, 1]], [[1, 0], [0, 1]], [[1, 0], [1, 1]], [[1, 1], [1, 0]]] sage: sorted(s.list_2x2_factors([A,B])) [[[0, 0], [1, 0]], [[0, 1], [0, 1]], [[0, 1], [1, 0]], [[0, 1], [1, 1]], [[1, 0], [0, 1]], [[1, 0], [1, 1]], [[1, 1], [1, 0]], [[1, 1], [1, 1]]] sage: s.list_2x2_factors([]) []
- list_dominoes(direction)¶
Return the list of 1x2 or 2x1 factors in the language of the associated substitutive shift.
INPUT:
self
– expansive and primitive 2d substitutiondirection
– string,'horizontal'
or'vertical'
OUTPUT:
list of tables
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[0,1]] sage: B = [[1,0],[1,1]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: sorted(s.list_dominoes(direction='horizontal')) [(0, 0), (0, 1), (1, 0), (1, 1)] sage: sorted(s.list_dominoes(direction='vertical')) [(0, 0), (0, 1), (1, 0), (1, 1)]
sage: A = [[3]] sage: B = [[3],[2]] sage: C = [[3,1]] sage: D = [[3,1],[2,0]] sage: d = {0:A, 1:B, 2:C, 3:D} sage: s = Substitution2d(d) sage: sorted(s.list_dominoes(direction='horizontal')) [(0, 1), (1, 0), (1, 1), (2, 3), (3, 2), (3, 3)] sage: sorted(s.list_dominoes(direction='vertical')) [(0, 2), (1, 3), (2, 0), (2, 2), (3, 1), (3, 3)]
- prolongable_origins()¶
Deprecated: Use
prolongable_seeds_graph()
instead. See trac ticket #123456 for details.
- prolongable_seeds_graph()¶
Return the directed graph of 2x2 factors where (u,v) is an edge if v is the seed at the origin of the image of u under self.
OUTPUT:
list of tuple (2x2 matrix, integer)
EXAMPLES:
sage: d = {0: [[17]], ....: 1: [[16]], ....: 2: [[15], [11]], ....: 3: [[13], [9]], ....: 4: [[17], [8]], ....: 5: [[16], [8]], ....: 6: [[15], [8]], ....: 7: [[14], [8]], ....: 8: [[14, 6]], ....: 9: [[17, 3]], ....: 10: [[16, 3]], ....: 11: [[14, 2]], ....: 12: [[15, 7], [11, 1]], ....: 13: [[14, 6], [11, 1]], ....: 14: [[13, 7], [9, 1]], ....: 15: [[12, 6], [9, 1]], ....: 16: [[18, 5], [10, 1]], ....: 17: [[13, 4], [9, 1]], ....: 18: [[14, 2], [8, 0]]} sage: from slabbe import Substitution2d sage: omega = Substitution2d(d) sage: G = omega.prolongable_seeds_graph() sage: G Looped digraph on 50 vertices
- prolongable_seeds_list()¶
Return the list of seed which are prolongable for some power of self.
OUTPUT:
list of cycles
EXAMPLES:
sage: d = {0: [[17]], ....: 1: [[16]], ....: 2: [[15], [11]], ....: 3: [[13], [9]], ....: 4: [[17], [8]], ....: 5: [[16], [8]], ....: 6: [[15], [8]], ....: 7: [[14], [8]], ....: 8: [[14, 6]], ....: 9: [[17, 3]], ....: 10: [[16, 3]], ....: 11: [[14, 2]], ....: 12: [[15, 7], [11, 1]], ....: 13: [[14, 6], [11, 1]], ....: 14: [[13, 7], [9, 1]], ....: 15: [[12, 6], [9, 1]], ....: 16: [[18, 5], [10, 1]], ....: 17: [[13, 4], [9, 1]], ....: 18: [[14, 2], [8, 0]]} sage: from slabbe import Substitution2d sage: omega = Substitution2d(d) sage: omega.prolongable_seeds_list() [[ [ 9 14] [17 13] [ 1 6], [16 15] ], [ [ 9 14] [17 13] [ 8 16], [ 6 5] ], [ [10 12] [16 15] [ 9 14], [ 3 7] ], [ [10 14] [16 13] [11 17], [ 2 4] ]]
- relabel_domain(other)¶
Return a permutation p such that self*p == other, if it exists.
INPUT:
other
– substitution 2d
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[0,1],[0,1]] sage: B = [[1,0],[1,1]] sage: s = Substitution2d({0:A, 1:B}) sage: t = Substitution2d({7:A, 8:B}) sage: s.relabel_domain(t) Substitution 2d: {7: [[0]], 8: [[1]]}
TESTS:
sage: s = Substitution2d({0:A, 1:B}) sage: s.relabel_domain(s) Substitution 2d: {0: [[0]], 1: [[1]]}
sage: s = Substitution2d({0:A, 1:B}) sage: t = Substitution2d({7:A, 8:B, 9:[[4]]}) sage: t.relabel_domain(s) Traceback (most recent call last): ... ValueError: image of letter 9 is [[4]] and is not in other sage: s.relabel_domain(t) Traceback (most recent call last): ... AssertionError: problem: self * p == other not satisfied
- reversal()¶
Return the reversal of self.
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[1,2],[3,4]] sage: B = [[5,6],[7,8]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d) sage: s.reversal() Substitution 2d: {0: [[4, 3], [2, 1]], 1: [[8, 7], [6, 5]]}
- split_letters_randomly(n_copies)¶
Return a substitution 2d obtained by spliting letters.
INPUT:
n_copies
– dict, letters to integers indicating the number of copies of each letter
OUTPUT
Substitution 2d
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[1,1],[1,1]] sage: B = [[0,0]] sage: d = {0:A, 1:B} sage: s = Substitution2d(d)
sage: n_copies = {0:2, 1:1} sage: s.split_letters_randomly(n_copies) # random Substitution 2d: {0: [[2, 2], [2, 2]], 1: [[2, 2], [2, 2]], 2: [[1, 0]]}
sage: n_copies = {0:2,1:3} sage: s.split_letters_randomly(n_copies) # random Substitution 2d: {0: [[3, 3], [4, 3]], 1: [[4, 2], [2, 2]], 2: [[0, 0]], 3: [[0, 1]], 4: [[1, 0]]}
sage: from slabbe import Substitution2d sage: from slabbe import GraphDirectedIteratedFunctionSystem as GIFS sage: fibo = {0:[0,1], 1:[0]} sage: s = Substitution2d.from_1d_row_column_substitutions(fibo, fibo) sage: n_copies = {0:2,1:1,2:1,3:1} sage: t = s.split_letters_randomly(n_copies) sage: ifs = GIFS.from_two_dimensional_substitution(t) sage: _ = ifs.galois_conjugate().plot(n_iterations=9)
sage: n_copies = {0:2,1:2,2:2,3:2} sage: t = s.split_letters_randomly(n_copies) sage: ifs = GIFS.from_two_dimensional_substitution(t) sage: _ = ifs.galois_conjugate().plot(n_iterations=9)
- stone_inflation_shapes()¶
Return a dictionary of letters of the domain alphabet associated to pairs
(width, height)
describing the rectangular shape associated to the given letter.Those rectangular shapes are such that the 2d substitution can be seen as stone inflation, see section 5.6 of [BG13].
INPUT:
self
– expansive and primitive 2d substitution
OUTPUT:
horizontal expansion in X-axis
vertical expansion in Y-axis
dictionary of
letter:(width, height)
EXAMPLES:
sage: from slabbe import Substitution2d sage: A = [[3]] sage: B = [[3],[2]] sage: C = [[3,1]] sage: D = [[3,1],[2,0]] sage: d = {0:A, 1:B, 2:C, 3:D} sage: s = Substitution2d(d) sage: rootX, rootY, stone_shapes = s.stone_inflation_shapes() sage: stone_shapes {0: (1, 1), 1: (rootX, 1), 2: (1, rootY), 3: (rootX, rootY)} sage: {a:(w.n(),h.n()) for a,(w,h) in stone_shapes.items()} {0: (1.00000000000000, 1.00000000000000), 1: (1.61803398874989, 1.00000000000000), 2: (1.00000000000000, 1.61803398874989), 3: (1.61803398874989, 1.61803398874989)}
- wang_tikz(domain_tiles, codomain_tiles, domain_color=None, codomain_color=None, domain_color_by_id=None, codomain_color_by_id=None, size=1, scale=1, font='\\\\normalsize', rotate=None, label_shift=0.2, id=True, edges=True, ncolumns=4, direction='right', extra_space=1)¶
Return the tikz code showing what the substitution A->B* does on Wang tiles.
INPUT:
domain_tiles
– tiles of the domaincodomain_tiles
– tiles of the codomaindomain_color
– dict (default:None
) from tile values -> tikz colorscodomain_color
– dict (default:None
) from tile values -> tikz colorsdomain_color_by_id
– dict (default:None
) from tile values -> tikz colorscodomain_color_by_id
– dict (default:None
) from tile values -> tikz colorssize
– number (default:1
), size of the tilescale
– number (default:1
), scale of tikzpicturefont
– string (default:r'\normalsize'
rotate
– list orNone
(default:None
) list of four angles in degrees like(0,0,0,0)
, the rotation angle to apply to each label of Wang tiles. IfNone
, it performs a 90 degres rotation for left and right labels taking more than one character.label_shift
– number (default:.2
) translation distance of the label from the edgeid
– boolean (default:True
), presence of the tile idncolumns
– integer (default:4
)edges
– bool (default:True
)direction
– string (default:'right'
) or'down'
extra_space
– number (default:1
), space between the tile and its image
OUTPUT:
dict, key -> tile
EXAMPLES:
sage: from slabbe import WangTileSet, Substitution2d sage: A = [[0,1,2],[1,0,0]] sage: B = [[0,1,2]] sage: d = {4:A, 5:B} sage: s = Substitution2d(d) sage: codomain_tiles = [(0,3,1,4), (1,4,0,3), (5,6,7,8)] sage: W = WangTileSet(codomain_tiles) sage: fn = lambda colors:''.join(map(str, colors)) sage: domain_tiles = W.desubstitute(s, fn) sage: tikz = s.wang_tikz(domain_tiles, codomain_tiles, rotate=(90,0,90,0)) sage: _ = tikz.pdf(view=False) # long time
Color tiles by their id:
sage: domain_color_by_id = {4:'red', 5:'blue'} sage: codomain_color_by_id = {0:'orange', 1:'green', 2:'yellow'} sage: tikz = s.wang_tikz(domain_tiles, codomain_tiles, ....: domain_color_by_id=domain_color_by_id, ....: codomain_color_by_id=codomain_color_by_id) sage: _ = tikz.pdf(view=False) # long time
Applying a transformation matrix:
sage: M = matrix(2, [1,1,0,1]) sage: sM = s.apply_matrix_transformation(M) sage: tikz = sM.wang_tikz(domain_tiles, codomain_tiles) sage: _ = tikz.pdf(view=False) # long time
Down direction:
sage: tikz = s.wang_tikz(domain_tiles, codomain_tiles, ....: direction='down') sage: _ = tikz.pdf(view=False) # long time
- wang_tiles_codomain_tikz(codomain_tiles, color=None, size=1, scale=1, font='\\\\normalsize', rotate=None, id=True, label=True, label_shift=0.2, edges=True, ncolumns=4, direction='right')¶
Return the tikz code of the image of the letters as a table of tikz tilings.
INPUT:
domain_tiles
– tiles of the domaincodomain_tiles
– tiles of the codomaindomain_color
– dict (default:None
) from tile values -> tikz colorscodomain_color
– dict (default:None
) from tile values -> tikz colorssize
– number (default:1
), size of the tilescale
– number (default:1
), scale of tikzpicturefont
– string (default:r'\normalsize'
rotate
– list orNone
(default:None
) list of four angles in degrees like(0,0,0,0)
, the rotation angle to apply to each label of Wang tiles. IfNone
, it performs a 90 degres rotation for left and right labels taking more than one character.id
– boolean (default:True
), presence of the tile idlabel
– boolean (default:True
)label_shift
– number (default:.2
) translation distance of the label from the edgeedges
– bool (default:True
)ncolumns
– integer (default:4
)
OUTPUT:
tikzpicture
EXAMPLES:
sage: from slabbe import WangTileSet, Substitution2d sage: A = [[0,1,2],[1,0,0]] sage: B = [[0,1,2]] sage: d = {4:A, 5:B} sage: s = Substitution2d(d) sage: codomain_tiles = [(0,3,1,4), (1,4,0,3), (5,6,7,8)] sage: W = WangTileSet(codomain_tiles) sage: t = s.wang_tiles_codomain_tikz(W) sage: _ = t.pdf(view=False)
- slabbe.substitution_2d.set_of_factors(table, shape, avoid_border=0)¶
Return the set of factors of given shape in the table.
INPUT
table
– list of listsshape
– list, list of coordinatesavoid_border
– integer (default: 0), the size of the borderto avoid during the computation
OUTPUT:
set of tuple of integers
EXAMPLES:
sage: from slabbe.substitution_2d import set_of_factors sage: table = [[0,1,2], [3,4,5], [6,7,8]] sage: set_of_factors(table, shape=[(0,0), (1,0), (0,1), (1,1)]) {(0, 3, 1, 4), (1, 4, 2, 5), (3, 6, 4, 7), (4, 7, 5, 8)}