sine-Gordon Y-system plotter - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# sine-Gordon Y-system plotter

This class builds the triangulations associated to sine-Gordon and reduced sine-Gordon Y-systems as constructed in [NS].

AUTHORS:

- Salvatore Stella (2014-07-18): initial version

EXAMPLES:

A reduced sine-Gordon example with 3 generations:

Sage

    sage: Y = SineGordonYsystem('A',(6,4,3)); Y
    A sine-Gordon Y-system of type A with defining integer tuple (6, 4, 3)
    sage: Y.plot()     #not tested

Python

    >>> from sage.all import *
    >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3))); Y
    A sine-Gordon Y-system of type A with defining integer tuple (6, 4, 3)
    >>> Y.plot()     #not tested

The same integer tuple but for the non-reduced case:

Sage

    sage: Y = SineGordonYsystem('D',(6,4,3)); Y
    A sine-Gordon Y-system of type D with defining integer tuple (6, 4, 3)
    sage: Y.plot()     #not tested

[Python]

    >>> from sage.all import *
    >>> Y = SineGordonYsystem('D',(Integer(6),Integer(4),Integer(3))); Y
    A sine-Gordon Y-system of type D with defining integer tuple (6, 4, 3)
    >>> Y.plot()     #not tested

Todo

The code for plotting is extremely slow.

class sage.combinat.sine_gordon.SineGordonYsystem(X, na)

  Bases: `SageObject`

  A class to model a (reduced) sine-Gordon Y-system.

  Note that the generations, together with all integer tuples, in this implementation are numbered from 0 while in [NS] they are numbered from 1

  INPUT:

  - `X` – the type of the Y-system to construct (either ‘A’ or ‘D’)

  - `na` – the tuple of positive integers defining the Y-system with `na[0] > 2`

  See [NS]

  EXAMPLES:

  Sage

      sage: Y = SineGordonYsystem('A',(6,4,3)); Y
      A sine-Gordon Y-system of type A with defining integer tuple (6, 4, 3)
      sage: Y.intervals()
      (((0, 0, 'R'),),
       ((0, 17, 'L'),
        (17, 34, 'L'),
      ...
        (104, 105, 'R'),
        (105, 0, 'R')))
      sage: Y.triangulation()
      ((17, 89),
       (17, 72),
       (34, 72),
      ...
       (102, 105),
       (103, 105))
      sage: Y.plot()     #not tested

  Python

      >>> from sage.all import *
      >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3))); Y
      A sine-Gordon Y-system of type A with defining integer tuple (6, 4, 3)
      >>> Y.intervals()
      (((0, 0, 'R'),),
       ((0, 17, 'L'),
        (17, 34, 'L'),
      ...
        (104, 105, 'R'),
        (105, 0, 'R')))
      >>> Y.triangulation()
      ((17, 89),
       (17, 72),
       (34, 72),
      ...
       (102, 105),
       (103, 105))
      >>> Y.plot()     #not tested

  F()

    Return the number of generations in `self`.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.F()
        3

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.F()
        3

  intervals()

    Return, divided by generation, the list of intervals used to construct the initial triangulation.

    Each such interval is a triple `(p, q, X)` where `p` and `q` are the two extremal vertices of the interval and `X` is the type of the interval (one of ‘L’, ‘R’, ‘NL’, ‘NR’).

    ALGORITHM:

    The algorithm used here is the one described in section 5.1 of [NS]. The only difference is that we get rid of the special case of the first generation by treating the whole disk as a type ‘R’ interval.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.intervals()
        (((0, 0, 'R'),),
         ((0, 17, 'L'),
          (17, 34, 'L'),
        ...
          (104, 105, 'R'),
          (105, 0, 'R')))

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.intervals()
        (((0, 0, 'R'),),
         ((0, 17, 'L'),
          (17, 34, 'L'),
        ...
          (104, 105, 'R'),
          (105, 0, 'R')))

  na()

    Return the sequence of the integers \(n_a\) defining `self`.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.na()
        (6, 4, 3)

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.na()
        (6, 4, 3)

  pa()

    Return the sequence of integers `p_a`, i.e. the total number of intervals of types ‘NL’ and ‘NR’ in the `(a+1)`-th generation.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.pa()
        (1, 6, 25)

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.pa()
        (1, 6, 25)

  plot(**kwds)

    Plot the initial triangulation associated to `self`.

    INPUT:

    - `radius` – the radius of the disk; by default the length of the circle is the number of vertices

    - `points_color` – the color of the vertices; default ‘black’

    - `points_size` – the size of the vertices; default 7

    - `triangulation_color` – the color of the arcs; default ‘black’

    - `triangulation_thickness` – the thickness of the arcs; default 0.5

    - `shading_color` – the color of the shading used on neuter intervals; default ‘lightgray’

    - `reflections_color` – the color of the reflection axes; default ‘blue’

    - `reflections_thickness` – the thickness of the reflection axes; default 1

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.plot()                      # long time (2s)                        # needs sage.plot
        Graphics object consisting of 219 graphics primitives

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.plot()                      # long time (2s)                        # needs sage.plot
        Graphics object consisting of 219 graphics primitives

  qa()

    Return the sequence of integers `q_a`, i.e. the total number of intervals of types ‘L’ and ‘R’ in the `(a+1)`-th generation.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.qa()
        (6, 25, 81)

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.qa()
        (6, 25, 81)

  r()

    Return the number of vertices in the polygon realizing `self`.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.r()
        106

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.r()
        106

  rk()

    Return the sequence of integers `r^{(k)}`, i.e. the width of an interval of type ‘L’ or ‘R’ in the `k`-th generation.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.rk()
        (106, 17, 4)

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.rk()
        (106, 17, 4)

  triangulation()

    Return the initial triangulation of the polygon realizing `self` as a tuple of pairs of vertices.

    Warning

    In type ‘D’ the returned triangulation does NOT contain the two radii.

    ALGORITHM:

    We implement the four cases described by Figure 14 in [NS].

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.triangulation()
        ((17, 89),
         (17, 72),
        ...
         (102, 105),
         (103, 105))

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.triangulation()
        ((17, 89),
         (17, 72),
        ...
         (102, 105),
         (103, 105))

  type()

    Return the type of `self`.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.type()
        'A'

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.type()
        'A'

  vertices()

    Return the vertices of the polygon realizing `self` as the ring of integers modulo `self.r()`.

    EXAMPLES:

    Sage

        sage: Y = SineGordonYsystem('A',(6,4,3))
        sage: Y.vertices()
        Ring of integers modulo 106

    Python

        >>> from sage.all import *
        >>> Y = SineGordonYsystem('A',(Integer(6),Integer(4),Integer(3)))
        >>> Y.vertices()
        Ring of integers modulo 106