\(\nu\)-Tamari lattice - Combinatorics

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

# \(\nu\)-Tamari lattice

A class of the \(\nu\)-Tamari lattice, and \((\delta,\nu)\)-Tamari lattice (or alt \(\nu\)-Tamari lattices), see [PRV2017] and [CC2023] for details.

These lattices depend on a parameter \(\nu\) where \(\nu\) is a path of North and East steps. The alt \(\nu\)-Tamari lattice depends on an additional parameter \(\delta\), which is an increment vector with respect to \(\nu\).

The elements are `nu-Dyck paths` which are weakly above \(\nu\).

To use the provided functionality, you should import \(\nu\)-Tamari lattices by typing:

Sage

    sage: from sage.combinat.nu_tamari_lattice import NuTamariLattice, AltNuTamariLattice

Python

    >>> from sage.all import *
    >>> from sage.combinat.nu_tamari_lattice import NuTamariLattice, AltNuTamariLattice

Then,

Sage

    sage: NuTamariLattice([1,1,1,0,0,1,1,0])
    Finite lattice containing 6 elements
    sage: NuTamariLattice([0,0,0,1,1,0,0,1])
    Finite lattice containing 40 elements
    sage: AltNuTamariLattice([0,0,0,1,1,0,0,1])
    Finite lattice containing 40 elements
    sage: AltNuTamariLattice([0,0,0,1,1,0,0,1], [0,1,0])
    Finite lattice containing 40 elements

[Python]

    >>> from sage.all import *
    >>> NuTamariLattice([Integer(1),Integer(1),Integer(1),Integer(0),Integer(0),Integer(1),Integer(1),Integer(0)])
    Finite lattice containing 6 elements
    >>> NuTamariLattice([Integer(0),Integer(0),Integer(0),Integer(1),Integer(1),Integer(0),Integer(0),Integer(1)])
    Finite lattice containing 40 elements
    >>> AltNuTamariLattice([Integer(0),Integer(0),Integer(0),Integer(1),Integer(1),Integer(0),Integer(0),Integer(1)])
    Finite lattice containing 40 elements
    >>> AltNuTamariLattice([Integer(0),Integer(0),Integer(0),Integer(1),Integer(1),Integer(0),Integer(0),Integer(1)], [Integer(0),Integer(1),Integer(0)])
    Finite lattice containing 40 elements

The classical Tamari lattices and the Generalized Tamari lattices are special cases of this construction and are also available with this poset:

Sage

    sage: NuTamariLattice([1,0,1,0,1,0])
    Finite lattice containing 5 elements

    sage: NuTamariLattice([1,0,0,1,0,0,1,0,0])
    Finite lattice containing 12 elements

Python

    >>> from sage.all import *
    >>> NuTamariLattice([Integer(1),Integer(0),Integer(1),Integer(0),Integer(1),Integer(0)])
    Finite lattice containing 5 elements

    >>> NuTamariLattice([Integer(1),Integer(0),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0),Integer(0)])
    Finite lattice containing 12 elements

See also

For more detailed information see `NuTamariLattice()` and `AltNuTamariLattice()`. For more information on the standard Tamari lattice see `sage.combinat.tamari_lattices.TamariLattice()`, `sage.combinat.tamari_lattices.GeneralizedTamariLattice()`

AUTHORS:

- Aram Dermenjian (2020-09-26): initial version

- Clément Chenevière (2024-02-01): added the alt \(\nu\)-Tamari lattices

sage.combinat.nu_tamari_lattice.AltNuTamariLattice(nu, delta=None)

  Return the \((\delta,\nu)\)-Tamari lattice (or alt \(\nu\)-Tamari lattice).

  For more information, see [CC2023].

  The path \(\nu\) is a path of North steps (represented as \(1\) s) and East steps (represented as \(0\) s).

  The vector \(\delta = (\delta_1, \dots, \delta_n)\) is an increment vector with respect to the path \(\nu\), that is to say \(\delta_i \leq \nu_i\), where \(\nu_i\) is the number of \(0\) s following the \(i\)-th \(1\) of \(\nu\). If not provided, \(\delta\) is set by default to produce the classical \(\nu\)-Tamari lattice.

  INPUT:

  - \(\nu\) – list of 0s and 1s or a string of 0s and 1s

  - \(\delta\) – list of nonnegative integers

  OUTPUT: a finite lattice

  EXAMPLES:

  Sage

      sage: from sage.combinat.nu_tamari_lattice import AltNuTamariLattice, NuTamariLattice
      sage: AltNuTamariLattice('01001', [0, 0])
      Finite lattice containing 7 elements
      sage: AltNuTamariLattice('01001', [1, 0])
      Finite lattice containing 7 elements
      sage: AltNuTamariLattice('01001') == AltNuTamariLattice('01001', [2, 0])
      True
      sage: nu = '00100100101'; P = AltNuTamariLattice(nu); Q = NuTamariLattice(nu); P.is_isomorphic(Q)
      True

  Python

      >>> from sage.all import *
      >>> from sage.combinat.nu_tamari_lattice import AltNuTamariLattice, NuTamariLattice
      >>> AltNuTamariLattice('01001', [Integer(0), Integer(0)])
      Finite lattice containing 7 elements
      >>> AltNuTamariLattice('01001', [Integer(1), Integer(0)])
      Finite lattice containing 7 elements
      >>> AltNuTamariLattice('01001') == AltNuTamariLattice('01001', [Integer(2), Integer(0)])
      True
      >>> nu = '00100100101'; P = AltNuTamariLattice(nu); Q = NuTamariLattice(nu); P.is_isomorphic(Q)
      True

  REFERENCES:

  - [PRV2017]

  - [CC2023]

sage.combinat.nu_tamari_lattice.NuTamariLattice(nu)

  Return the \(\nu\)-Tamari lattice.

  INPUT:

  - \(\nu\) – list of 0s and 1s or a string of 0s and 1s

  OUTPUT: a finite lattice

  The elements of the lattice are `nu-Dyck paths` weakly above \(\nu\).

  The usual Tamari lattice is the special case where \(\nu = (NE)^h\) where \(h\) is the height.

  Other special cases give the \(m\)-Tamari lattices studied in [BMFPR].

  EXAMPLES:

  Sage

      sage: from sage.combinat.nu_tamari_lattice import NuTamariLattice
      sage: NuTamariLattice([1,0,1,0,0,1,0])
      Finite lattice containing 7 elements
      sage: NuTamariLattice([1,0,1,0,1,0])
      Finite lattice containing 5 elements
      sage: NuTamariLattice([1,0,1,0,1,0,1,0])
      Finite lattice containing 14 elements
      sage: NuTamariLattice([1,0,1,0,1,0,0,0,1])
      Finite lattice containing 24 elements

  Python

      >>> from sage.all import *
      >>> from sage.combinat.nu_tamari_lattice import NuTamariLattice
      >>> NuTamariLattice([Integer(1),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0)])
      Finite lattice containing 7 elements
      >>> NuTamariLattice([Integer(1),Integer(0),Integer(1),Integer(0),Integer(1),Integer(0)])
      Finite lattice containing 5 elements
      >>> NuTamariLattice([Integer(1),Integer(0),Integer(1),Integer(0),Integer(1),Integer(0),Integer(1),Integer(0)])
      Finite lattice containing 14 elements
      >>> NuTamariLattice([Integer(1),Integer(0),Integer(1),Integer(0),Integer(1),Integer(0),Integer(0),Integer(0),Integer(1)])
      Finite lattice containing 24 elements

sage.combinat.nu_tamari_lattice.delta_swap(p, k, delta)

  Perform a covering move in the \((\delta,\nu)\)-Tamari lattice (or alt \(\nu\)-Tamari lattice, see [CC2023]).

  The letter at position \(k\) is a North step of the \(\nu\)-Dyck word \(p\), and must be preceded by an East step.

  The vector \(\delta = (\delta_1, \dots, \delta_n)\) is an increment vector with respect to the path \(\nu\), that is to say \(\delta_i \leq \nu_i\), where \(\nu_i\) is the number of East steps following the \(i\)-th North step of \(\nu\).

  INPUT:

  - `p` – a \(\nu\)-Dyck word

  - `k` – integer between \(0\) and `p.length()-1`

  - `delta` – list of nonnegative integers of length `p.height()`

  OUTPUT: a \(\nu\)-Dyck word

  EXAMPLES:

  Sage

      sage: from sage.combinat.nu_tamari_lattice import delta_swap
      sage: delta_swap(NuDyckWord('0101', '0101'), 3, delta = [1, 0])
      [0, 1, 1, 0]
      sage: delta_swap(NuDyckWord('1001110100', '0100010111'), 3, [3, 1, 0, 0, 0])
      [1, 0, 1, 1, 1, 0, 0, 1, 0, 0]
      sage: delta_swap(NuDyckWord('10100101000', '01001000110'), 2, [2, 3, 0, 1])
      [1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0]
      sage: delta_swap(NuDyckWord('10100101000', '01001000110'), 2, [1, 1, 0, 0])
      [1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]

  Python

      >>> from sage.all import *
      >>> from sage.combinat.nu_tamari_lattice import delta_swap
      >>> delta_swap(NuDyckWord('0101', '0101'), Integer(3), delta = [Integer(1), Integer(0)])
      [0, 1, 1, 0]
      >>> delta_swap(NuDyckWord('1001110100', '0100010111'), Integer(3), [Integer(3), Integer(1), Integer(0), Integer(0), Integer(0)])
      [1, 0, 1, 1, 1, 0, 0, 1, 0, 0]
      >>> delta_swap(NuDyckWord('10100101000', '01001000110'), Integer(2), [Integer(2), Integer(3), Integer(0), Integer(1)])
      [1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0]
      >>> delta_swap(NuDyckWord('10100101000', '01001000110'), Integer(2), [Integer(1), Integer(1), Integer(0), Integer(0)])
      [1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]