Blob algebras - Combinatorics

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

# Blob algebras

AUTHORS:

- Travis Scrimshaw (2020-05-16): Initial version

class sage.combinat.blob_algebra.BlobAlgebra(k, q1, q2, q3, base_ring, prefix)

  Bases: `CombinatorialFreeModule`

  The blob algebra.

  The blob algebra (also known as the Temperley-Lieb algebra of type \(B\) in [ILZ2018], but is a quotient of the Temperley-Lieb algebra of type \(B\) defined in [Graham1985]) is a diagram-type algebra introduced in [MS1994] whose basis consists of `Temperley-Lieb diagrams`, noncrossing perfect matchings, that may contain blobs on strands that can be deformed so that the blob touches the left side (which we can think of as a frozen pole).

  The form we give here has 3 parameters, the natural one from the `Temperley-Lieb algebra`, one for the idempotent relation, and one for a loop with a blob.

  INPUT:

  - `k` – the order

  - `q1` – the loop parameter

  - `q2` – the idempotent parameter

  - `q3` – the blob loop parameter

  EXAMPLES:

  Sage

      sage: R.<q,r,s> = ZZ[]
      sage: B4 = algebras.Blob(4, q, r, s)
      sage: B = sorted(B4.basis())
      sage: B[14]
      B({{-4, -3}}, {{-2, -1}, {1, 2}, {3, 4}})
      sage: B[40]
      B({{3, 4}}, {{-4, -3}, {-2, -1}, {1, 2}})
      sage: B[14] * B[40]
      q*r*s*B({}, {{-4, -3}, {-2, -1}, {1, 2}, {3, 4}})

  Python

      >>> from sage.all import *
      >>> R = ZZ['q, r, s']; (q, r, s,) = R._first_ngens(3)
      >>> B4 = algebras.Blob(Integer(4), q, r, s)
      >>> B = sorted(B4.basis())
      >>> B[Integer(14)]
      B({{-4, -3}}, {{-2, -1}, {1, 2}, {3, 4}})
      >>> B[Integer(40)]
      B({{3, 4}}, {{-4, -3}, {-2, -1}, {1, 2}})
      >>> B[Integer(14)] * B[Integer(40)]
      q*r*s*B({}, {{-4, -3}, {-2, -1}, {1, 2}, {3, 4}})

  REFERENCES:

  - [MS1994]

  - [ILZ2018]

  one_basis()

    Return the index of the basis element \(1\).

    EXAMPLES:

    Sage

        sage: R.<q,r,s> = ZZ[]
        sage: B4 = algebras.Blob(4, q, r, s)
        sage: B4.one_basis()
        ({}, {{-4, 4}, {-3, 3}, {-2, 2}, {-1, 1}})

    Python

        >>> from sage.all import *
        >>> R = ZZ['q, r, s']; (q, r, s,) = R._first_ngens(3)
        >>> B4 = algebras.Blob(Integer(4), q, r, s)
        >>> B4.one_basis()
        ({}, {{-4, 4}, {-3, 3}, {-2, 2}, {-1, 1}})

  order()

    Return the order of `self`.

    The order of a partition algebra is defined as half of the number of nodes in the diagrams.

    EXAMPLES:

    Sage

        sage: R.<q,r,s> = ZZ[]
        sage: B4 = algebras.Blob(4, q, r, s)
        sage: B4.order()
        4

    Python

        >>> from sage.all import *
        >>> R = ZZ['q, r, s']; (q, r, s,) = R._first_ngens(3)
        >>> B4 = algebras.Blob(Integer(4), q, r, s)
        >>> B4.order()
        4

  product_on_basis(top, bot)

    Return the product of the basis elements indexed by `top` and `bot`.

    EXAMPLES:

    Sage

        sage: R.<q,r,s> = ZZ[]
        sage: B4 = algebras.Blob(4, q, r, s)
        sage: B = B4.basis()
        sage: BD = sorted(B.keys())
        sage: BD[14]
        ({{-4, -3}}, {{-2, -1}, {1, 2}, {3, 4}})
        sage: BD[40]
        ({{3, 4}}, {{-4, -3}, {-2, -1}, {1, 2}})
        sage: B4.product_on_basis(BD[14], BD[40])
        q*r*s*B({}, {{-4, -3}, {-2, -1}, {1, 2}, {3, 4}})
        sage: all(len((x*y).support()) == 1 for x in B for y in B)
        True

    Python

        >>> from sage.all import *
        >>> R = ZZ['q, r, s']; (q, r, s,) = R._first_ngens(3)
        >>> B4 = algebras.Blob(Integer(4), q, r, s)
        >>> B = B4.basis()
        >>> BD = sorted(B.keys())
        >>> BD[Integer(14)]
        ({{-4, -3}}, {{-2, -1}, {1, 2}, {3, 4}})
        >>> BD[Integer(40)]
        ({{3, 4}}, {{-4, -3}, {-2, -1}, {1, 2}})
        >>> B4.product_on_basis(BD[Integer(14)], BD[Integer(40)])
        q*r*s*B({}, {{-4, -3}, {-2, -1}, {1, 2}, {3, 4}})
        >>> all(len((x*y).support()) == Integer(1) for x in B for y in B)
        True

class sage.combinat.blob_algebra.BlobDiagram(parent, marked, unmarked)

  Bases: `Element`

  A blob diagram.

  A blob diagram consists of a perfect matching of the set \(\{1, \ldots, n\} \sqcup \{-1, \ldots, -n\}\) such that the result is a noncrossing matching (a `Temperley-Lieb diagram`), divided into two sets of pairs: one for the pairs with blobs and one for those without. The blobed pairs must either be either the leftmost propagating strand or to the left of it and not nested.

  temperley_lieb_diagram()

    Return the Temperley-Lieb diagram corresponding to `self`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.blob_algebra import BlobDiagrams
        sage: BD4 = BlobDiagrams(4)
        sage: B = BD4([[1,-3]], [[2,-4], [3,4], [-1,-2]])
        sage: B.temperley_lieb_diagram()
        {{-4, 2}, {-3, 1}, {-2, -1}, {3, 4}}

    Python

        >>> from sage.all import *
        >>> from sage.combinat.blob_algebra import BlobDiagrams
        >>> BD4 = BlobDiagrams(Integer(4))
        >>> B = BD4([[Integer(1),-Integer(3)]], [[Integer(2),-Integer(4)], [Integer(3),Integer(4)], [-Integer(1),-Integer(2)]])
        >>> B.temperley_lieb_diagram()
        {{-4, 2}, {-3, 1}, {-2, -1}, {3, 4}}

class sage.combinat.blob_algebra.BlobDiagrams(n)

  Bases: `Parent`, `UniqueRepresentation`

  The set of all blob diagrams.

  Element

    alias of `BlobDiagram`

  base_set()

    Return the base set of `self`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.blob_algebra import BlobDiagrams
        sage: BD4 = BlobDiagrams(4)
        sage: sorted(BD4.base_set())
        [-4, -3, -2, -1, 1, 2, 3, 4]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.blob_algebra import BlobDiagrams
        >>> BD4 = BlobDiagrams(Integer(4))
        >>> sorted(BD4.base_set())
        [-4, -3, -2, -1, 1, 2, 3, 4]

  cardinality()

    Return the cardinality of `self`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.blob_algebra import BlobDiagrams
        sage: BD4 = BlobDiagrams(4)
        sage: BD4.cardinality()
        70

    Python

        >>> from sage.all import *
        >>> from sage.combinat.blob_algebra import BlobDiagrams
        >>> BD4 = BlobDiagrams(Integer(4))
        >>> BD4.cardinality()
        70

  order()

    Return the order of `self`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.blob_algebra import BlobDiagrams
        sage: BD4 = BlobDiagrams(4)
        sage: BD4.order()
        4

    Python

        >>> from sage.all import *
        >>> from sage.combinat.blob_algebra import BlobDiagrams
        >>> BD4 = BlobDiagrams(Integer(4))
        >>> BD4.order()
        4