TableauTuples

A TableauTuple is a tuple of tableaux. These objects arise naturally in representation theory of the wreath products of cyclic groups and the symmetric groups where the standard tableau tuples index bases for the ordinary irreducible representations. This generalises the well-known fact the ordinary irreducible representations of the symmetric groups have bases indexed by the standard tableaux of a given shape. More generally, TableauTuples, or multitableaux, appear in the representation theory of the degenerate and non-degenerate cyclotomic Hecke algebras and in the crystal theory of the integral highest weight representations of the affine special linear groups.

A TableauTuple is an ordered tuple \((t^{(1)}, t^{(2)}, \ldots, t^{(l)})\) of tableaux. The length of the tuple is its level and the tableaux \(t^{(1)}, t^{(2)}, \ldots, t^{(l)}\) are the components of the TableauTuple.

A tableaux can be thought of as the labelled diagram of a partition. Analogously, a TableauTuple is the labelled diagram of a PartitionTuple. That is, a TableauTuple is a tableau of PartitionTuple shape. As much as possible, TableauTuples behave in exactly the same way as Tableaux. There are obvious differences in that the cells of a partition are ordered pairs \((r, c)\), where \(r\) is a row index and \(c\) a column index, whereas the cells of a PartitionTuple are ordered triples \((k, r, c)\), with \(r\) and \(c\) as before and \(k\) indexes the component.

Frequently, we will call a TableauTuple a tableau, or a tableau of PartitionTuple shape. If the shape of the tableau is known this should not cause any confusion.

Warning

In sage the convention is that the \((k, r, c)\)-th entry of a tableau tuple \(t\) is the entry in row \(r\), column \(c\) and component \(k\) of the tableau. This is because it makes much more sense to let t[k] be component of the tableau. In particular, we want t(k,r,c) == t[k][r][c]. In the literature, the cells of a tableau tuple are usually written in the form \((r, c, k)\), where \(r\) is the row index, \(c\) is the column index, and \(k\) is the component index.

The same convention applies to the cells of PartitionTuples.

Note

As with partitions and tableaux, the cells are 0-based. For example, the (lexicographically) first cell in any non-empty tableau tuple is [0,0,0].

EXAMPLES:

sage: TableauTuple([[1,2,3],[4,5]])
[[1, 2, 3], [4, 5]]
sage: t = TableauTuple([ [[6,7],[8,9]],[[1,2,3],[4,5]] ]); t
([[6, 7], [8, 9]], [[1, 2, 3], [4, 5]])
sage: t.pp()
  6  7     1  2  3
  8  9     4  5
sage: t(0,0,1)
7
sage: t(1,0,1)
2
sage: t.shape()
([2, 2], [3, 2])
sage: t.size()
9
sage: t.level()
2
sage: t.components()
[[[6, 7], [8, 9]], [[1, 2, 3], [4, 5]]]
sage: t.entries()
[6, 7, 8, 9, 1, 2, 3, 4, 5]
sage: t.parent()
Tableau tuples
sage: t.category()
Category of elements of Tableau tuples

One reason for implementing TableauTuples is to be able to consider StandardTableauTuples. These objects arise in many areas of algebraic combinatorics. In particular, they index bases for the Specht modules of the cyclotomic Hecke algebras of type \(G(r,1,n)\). A StandardTableauTuple of tableau whose entries are increasing along rows and down columns in each component and which contain the numbers \(1,2, \ldots, n\), where the shape of the StandardTableauTuple is a PartitionTuple of \(n\).

sage: s = StandardTableauTuple([ [[1,2],[3]],[[4,5]]])
sage: s.category()
Category of elements of Standard tableau tuples
sage: t = TableauTuple([ [[1,2],[3]],[[4,5]]])
sage: t.is_standard(), t.is_column_strict(), t.is_row_strict()
(True, True, True)
sage: t.category()
Category of elements of Tableau tuples
sage: s == t
True
sage: s is t
False
sage: s == StandardTableauTuple(t)
True
sage: StandardTableauTuples([ [2,1],[1] ])[:]
[([[1, 2], [3]], [[4]]),
 ([[1, 3], [2]], [[4]]),
 ([[1, 2], [4]], [[3]]),
 ([[1, 3], [4]], [[2]]),
 ([[2, 3], [4]], [[1]]),
 ([[1, 4], [2]], [[3]]),
 ([[1, 4], [3]], [[2]]),
 ([[2, 4], [3]], [[1]])]

As tableaux (of partition shape) are in natural bijection with 1-tuples of tableaux all of the TableauTuple classes return an ordinary Tableau when given TableauTuple of level 1.

sage: TableauTuples( level=1 ) is Tableaux()
True
sage: TableauTuple([[1,2,3],[4,5]])
[[1, 2, 3], [4, 5]]
sage: TableauTuple([ [[1,2,3],[4,5]] ])
[[1, 2, 3], [4, 5]]
sage: TableauTuple([[1,2,3],[4,5]]) == Tableau([[1,2,3],[4,5]])
True

There is one situation where a 1-tuple of tableau is not actually a Tableau; tableaux generated by the StandardTableauTuples() iterators must have the correct parents, so in this one case 1-tuples of tableaux are different from Tableaux:

sage: StandardTableauTuples()[:10]
[(),
 ([[1]]),
 ([], []),
 ([[1, 2]]),
 ([[1], [2]]),
 ([[1]], []),
 ([], [[1]]),
 ([], [], []),
 ([[1, 2, 3]]),
 ([[1, 3], [2]])]

AUTHORS:

  • Andrew Mathas (2012-10-09): Initial version – heavily based on tableau.py by Mike Hansen (2007) and Jason Bandlow (2011).
  • Andrew Mathas (2016-08-11): Row standard tableaux added

Element classes:

Factory classes:

Parent classes:

Todo

Implement semistandard tableau tuples as defined in [DJM1998].

Much of the combinatorics implemented here is motivated by this and subsequent papers on the representation theory of these algebras.

sage.combinat.tableau_tuple.RowStandardTableauTuple

A class for row standard tableau tuples of shape a partition tuple.

A row standard tableau tuple of size \(n\) is an ordered tuple of row standard tableaux (see RowStandardTableau), with entries \(1, 2, \ldots, n\) such that, in each component, the entries are in increasing order along each row. If the tableau in component \(k\) has shape \(\lambda^{(k)}\) then \(\lambda=(\lambda^{(1)},\ldots,\lambda^{(l)}\) is a PartitionTuple.

Note

The tableaux appearing in a RowStandardTableauTuple are row strict, but individually they are not standard tableaux because the entries in any single component of a RowStandardTableauTuple will typically not be in bijection with \(\{1, 2, \ldots, n\}\).

INPUT:

  • t – a tableau, a list of (standard) tableau or an equivalent list

OUTPUT:

Note

Sage uses the English convention for (tuples of) partitions and tableaux: the longer rows are displayed on top. As with PartitionTuple, in sage the cells, or nodes, of partition tuples are 0-based. For example, the (lexicographically) first cell in any non-empty partition tuple is \([0,0,0]\). Further, the coordinates [k,r,c] in a TableauTuple refer to the component, row and column indices, respectively.

EXAMPLES:

sage: t = RowStandardTableauTuple([[[4,7],[3]],[[2,6,8],[1,5]],[[9]]]); t
([[4, 7], [3]], [[2, 6, 8], [1, 5]], [[9]])
sage: t.pp()
  4  7     2  6  8     9
  3        1  5
sage: t.shape()
([2, 1], [3, 2], [1])
sage: t[0].pp()  # pretty printing
  4  7
  3
sage: t.is_row_strict()
True
sage: t[0].is_standard()
False
sage: RowStandardTableauTuple([[],[],[]]) # An empty tableau tuple
([], [], [])
sage: RowStandardTableauTuple([[[4,5],[6]],[[1,2,3]]]) in StandardTableauTuples()
True
sage: RowStandardTableauTuple([[[5,6],[4]],[[1,2,3]]]) in StandardTableauTuples()
False

When using code that will generate a lot of tableaux, it is slightly more efficient to construct a RowStandardTableauTuple from the appropriate parent object:

sage: RST = RowStandardTableauTuples()
sage: RST([[[4,5],[7]],[[1,2,3],[6,8]],[[9]]])
([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])
sage.combinat.tableau_tuple.RowStandardTableauTuples

A factory class for the various classes of tuples of row standard tableau.

INPUT:

There are three optional arguments:

  • level – the level() of the tuples of tableaux
  • size – the size() of the tuples of tableaux
  • shape – a list or a partition tuple specifying the shape() of the row standard tableau tuples

It is not necessary to use the keywords. If they are not used then the first integer argument specifies the level() and the second the size() of the tableau tuples.

OUTPUT:

The appropriate subclass of RowStandardTableauTuples.

A tuple of row standard tableau is a tableau whose entries are positive integers which increase from left to right along the rows in each component. The entries do NOT need to increase from left to right along the components.

Note

Sage uses the English convention for (tuples of) partitions and tableaux: the longer rows are displayed on top. As with PartitionTuple, in sage the cells, or nodes, of partition tuples are 0-based. For example, the (lexicographically) first cell in any non-empty partition tuple is \([0,0,0]\).

EXAMPLES:

sage: tabs = RowStandardTableauTuples([[2],[1,1]]); tabs
Row standard tableau tuples of shape ([2], [1, 1])
sage: tabs.cardinality()
12
sage: tabs[:]
[([[3, 4]], [[2], [1]]),
 ([[2, 4]], [[3], [1]]),
 ([[1, 4]], [[3], [2]]),
 ([[1, 2]], [[4], [3]]),
 ([[1, 3]], [[4], [2]]),
 ([[2, 3]], [[4], [1]]),
 ([[1, 4]], [[2], [3]]),
 ([[1, 3]], [[2], [4]]),
 ([[1, 2]], [[3], [4]]),
 ([[2, 3]], [[1], [4]]),
 ([[2, 4]], [[1], [3]]),
 ([[3, 4]], [[1], [2]])]

sage: tabs = RowStandardTableauTuples(level=3); tabs
Row standard tableau tuples of level 3
sage: tabs[100]
([], [], [[2, 3], [1]])

sage: RowStandardTableauTuples()[0]
([])
sage.combinat.tableau_tuple.RowStandardTableauTuples_all

Default class of all RowStandardTableauTuples with an arbitrary level() and size().

sage.combinat.tableau_tuple.RowStandardTableauTuples_level

Class of all RowStandardTableauTuples with a fixed level and arbitrary size.

sage.combinat.tableau_tuple.RowStandardTableauTuples_level_size

Class of all RowStandardTableauTuples with a fixed level and a fixed size.

sage.combinat.tableau_tuple.RowStandardTableauTuples_residue

Class of all row standard tableau tuples with a fixed residue sequence.

Implicitly, this also specifies the quantum characteristic, multicharge and hence the level and size of the tableaux.

Note

This class is not intended to be called directly, but rather, it is accessed through the row standard tableaux.

EXAMPLES:

sage: RowStandardTableau([[3,4,5],[1,2]]).residue_sequence(2).row_standard_tableaux()
Row standard tableaux with 2-residue sequence (1,0,0,1,0) and multicharge (0)
sage: RowStandardTableau([[3,4,5],[1,2]]).residue_sequence(3).row_standard_tableaux()
Row standard tableaux with 3-residue sequence (2,0,0,1,2) and multicharge (0)
sage: RowStandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(2,(0,0)).row_standard_tableaux()
Row standard tableaux with 2-residue sequence (0,1,0,1,0,1,1) and multicharge (0,0)
sage: RowStandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(3,(0,1)).row_standard_tableaux()
Row standard tableaux with 3-residue sequence (1,2,0,0,0,1,2) and multicharge (0,1)
sage.combinat.tableau_tuple.RowStandardTableauTuples_residue_shape

All row standard tableau tuples with a fixed residue and shape.

INPUT:

  • shape – the shape of the partitions or partition tuples
  • residue – the residue sequence of the label

EXAMPLES:

sage: res = RowStandardTableauTuple([[[3,6],[1]],[[5,7],[4],[2]]]).residue_sequence(3,(0,0))
sage: tabs = res.row_standard_tableaux([[2,1],[2,1,1]]); tabs
Row standard (2,1|2,1^2)-tableaux with 3-residue sequence (2,1,0,2,0,1,1) and multicharge (0,0)
sage: tabs.shape()
([2, 1], [2, 1, 1])
sage: tabs.level()
2
sage: tabs[:6]
[([[5, 7], [4]], [[3, 6], [1], [2]]),
 ([[5, 7], [1]], [[3, 6], [4], [2]]),
 ([[3, 7], [4]], [[5, 6], [1], [2]]),
 ([[3, 7], [1]], [[5, 6], [4], [2]]),
 ([[5, 6], [4]], [[3, 7], [1], [2]]),
 ([[5, 6], [1]], [[3, 7], [4], [2]])]
sage.combinat.tableau_tuple.RowStandardTableauTuples_shape

Class of all RowStandardTableauTuples of a fixed shape.

sage.combinat.tableau_tuple.RowStandardTableauTuples_size

Class of all RowStandardTableauTuples with an arbitrary level and a fixed size.

sage.combinat.tableau_tuple.StandardTableauTuple

A class to model a standard tableau of shape a partition tuple. This is a tuple of standard tableau with entries \(1, 2, \ldots, n\), where \(n\) is the size of the underlying partition tuple, such that the entries increase along rows and down columns in each component of the tuple.

sage: s=StandardTableauTuple([[1,2,3],[4,5]]) sage: t=StandardTableauTuple([[1,2],[3,5],[4]]) sage: s.dominates(t) True sage: t.dominates(s) False sage: StandardTableauTuple([[1,2,3],[4,5]]) in RowStandardTableauTuples() True

The tableaux appearing in a StandardTableauTuple are both row and column strict, but individually they are not standard tableaux because the entries in any single component of a StandardTableauTuple will typically not be in bijection with \(\{1, 2, \ldots, n\}\).

INPUT:

  • t – a tableau, a list of (standard) tableau or an equivalent list

OUTPUT:

Note

Sage uses the English convention for (tuples of) partitions and tableaux: the longer rows are displayed on top. As with PartitionTuple, in sage the cells, or nodes, of partition tuples are 0-based. For example, the (lexicographically) first cell in any non-empty partition tuple is \([0,0,0]\). Further, the coordinates [k,r,c] in a TableauTuple refer to the component, row and column indices, respectively.

EXAMPLES:

sage: t=TableauTuple([ [[1,3,4],[7,9]], [[2,8,11],[6]], [[5,10]] ]); t
([[1, 3, 4], [7, 9]], [[2, 8, 11], [6]], [[5, 10]])
sage: t[0][0][0]
1
sage: t[1][1][0]
6
sage: t[2][0][0]
5
sage: t[2][0][1]
10

sage: t = StandardTableauTuple([[[4,5],[7]],[[1,2,3],[6,8]],[[9]]]); t
([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])
sage: t.pp()
  4  5     1  2  3     9
  7        6  8
sage: t.shape()
([2, 1], [3, 2], [1])
sage: t[0].pp()  # pretty printing
  4  5
  7
sage: t.is_standard()
True
sage: t[0].is_standard()
False
sage: StandardTableauTuple([[],[],[]]) # An empty tableau tuple
([], [], [])

When using code that will generate a lot of tableaux, it is slightly more efficient to construct a StandardTableauTuple from the appropriate parent object:

sage: STT = StandardTableauTuples()
sage: STT([[[4,5],[7]],[[1,2,3],[6,8]],[[9]]])
([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])
sage.combinat.tableau_tuple.StandardTableauTuples

A factory class for the various classes of tuples of standard tableau.

INPUT:

There are three optional arguments:

  • level – the level() of the tuples of tableaux
  • size – the size() of the tuples of tableaux
  • shape – a list or a partition tuple specifying the shape() of the standard tableau tuples

It is not necessary to use the keywords. If they are not used then the first integer argument specifies the level() and the second the size() of the tableau tuples.

OUTPUT:

The appropriate subclass of StandardTableauTuples.

A tuple of standard tableau is a tableau whose entries are positive integers which increase from left to right along the rows, and from top to bottom down the columns, in each component. The entries do NOT need to increase from left to right along the components.

Note

Sage uses the English convention for (tuples of) partitions and tableaux: the longer rows are displayed on top. As with PartitionTuple, in sage the cells, or nodes, of partition tuples are 0-based. For example, the (lexicographically) first cell in any non-empty partition tuple is \([0,0,0]\).

EXAMPLES:

sage: tabs=StandardTableauTuples([[3],[2,2]]); tabs
Standard tableau tuples of shape ([3], [2, 2])
sage: tabs.cardinality()
70
sage: tabs[10:16]
[([[1, 2, 3]], [[4, 6], [5, 7]]),
 ([[1, 2, 4]], [[3, 6], [5, 7]]),
 ([[1, 3, 4]], [[2, 6], [5, 7]]),
 ([[2, 3, 4]], [[1, 6], [5, 7]]),
 ([[1, 2, 5]], [[3, 6], [4, 7]]),
 ([[1, 3, 5]], [[2, 6], [4, 7]])]

sage: tabs=StandardTableauTuples(level=3); tabs
Standard tableau tuples of level 3
sage: tabs[100]
([[1, 2], [3]], [], [[4]])

sage: StandardTableauTuples()[0]
()
sage.combinat.tableau_tuple.StandardTableauTuples_all

Default class of all StandardTableauTuples with an arbitrary level() and size().

sage.combinat.tableau_tuple.StandardTableauTuples_level

Class of all StandardTableauTuples with a fixed level and arbitrary size.

sage.combinat.tableau_tuple.StandardTableauTuples_level_size

Class of all StandardTableauTuples with a fixed level and a fixed size.

sage.combinat.tableau_tuple.StandardTableauTuples_shape

Class of all StandardTableauTuples of a fixed shape.

sage.combinat.tableau_tuple.StandardTableauTuples_size

Class of all StandardTableauTuples with an arbitrary level and a fixed size.

sage.combinat.tableau_tuple.StandardTableaux_residue

Class of all standard tableau tuples with a fixed residue sequence.

Implicitly, this also specifies the quantum characteristic, multicharge and hence the level and size of the tableaux.

Note

This class is not intended to be called directly, but rather, it is accessed through the standard tableaux.

EXAMPLES:

sage: StandardTableau([[1,2,3],[4,5]]).residue_sequence(2).standard_tableaux()
Standard tableaux with 2-residue sequence (0,1,0,1,0) and multicharge (0)
sage: StandardTableau([[1,2,3],[4,5]]).residue_sequence(3).standard_tableaux()
Standard tableaux with 3-residue sequence (0,1,2,2,0) and multicharge (0)
sage: StandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(2,(0,0)).standard_tableaux()
Standard tableaux with 2-residue sequence (0,1,0,1,0,1,1) and multicharge (0,0)
sage: StandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(3,(0,1)).standard_tableaux()
Standard tableaux with 3-residue sequence (1,2,0,0,0,1,2) and multicharge (0,1)
sage.combinat.tableau_tuple.StandardTableaux_residue_shape

All standard tableau tuples with a fixed residue and shape.

INPUT:

  • shape – the shape of the partitions or partition tuples
  • residue – the residue sequence of the label

EXAMPLES:

sage: res = StandardTableauTuple([[[1,3],[6]],[[2,7],[4],[5]]]).residue_sequence(3,(0,0))
sage: tabs = res.standard_tableaux([[2,1],[2,1,1]]); tabs
Standard (2,1|2,1^2)-tableaux with 3-residue sequence (0,0,1,2,1,2,1) and multicharge (0,0)
sage: tabs.shape()
([2, 1], [2, 1, 1])
sage: tabs.level()
2
sage: tabs[:6]
[([[2, 7], [6]], [[1, 3], [4], [5]]),
 ([[1, 7], [6]], [[2, 3], [4], [5]]),
 ([[2, 3], [6]], [[1, 7], [4], [5]]),
 ([[1, 3], [6]], [[2, 7], [4], [5]]),
 ([[2, 5], [6]], [[1, 3], [4], [7]]),
 ([[1, 5], [6]], [[2, 3], [4], [7]])]
sage.combinat.tableau_tuple.TableauTuple

A class to model a tuple of tableaux.

INPUT:

  • t – a list or tuple of Tableau, a list or tuple of lists of lists

OUTPUT:

  • The Tableau tuple object constructed from t.

A TableauTuple is a tuple of tableau of shape a PartitionTuple. These combinatorial objects are useful is several areas of algebraic combinatorics. In particular, they are important in:

  • the representation theory of the complex reflection groups of type \(G(l,1,n)\) and the representation theory of the associated (degenerate and non-degenerate) Hecke algebras. See, for example, [DJM1998]
  • the crystal theory of (quantum) affine special linear groups and its integral highest weight modules and their canonical bases. See, for example, [BK2009].

These apparently different and unrelated contexts are, in fact, intimately related as in characteristic zero the cyclotomic Hecke algebras categorify the canonical bases of the integral highest weight modules of the quantum affine special linear groups.

The level() of a tableau tuple is the length of the tuples. This corresponds to the level of the corresponding highest weight module.

In sage a TableauTuple looks an behaves like a real tuple of (level 1) Tableaux. Many of the operations which are defined on Tableau extend to TableauTuples. Tableau tuples of level 1 are just ordinary Tableau.

In sage, the entries of Tableaux can be very general, including arbitrarily nested lists, so some lists can be interpreted either as a tuple of tableaux or simply as tableaux. If it is possible to interpret the input to TableauTuple as a tuple of tableaux then TableauTuple returns the corresponding tuple. Given a 1-tuple of tableaux the tableau itself is returned.

EXAMPLES:

sage: t = TableauTuple([ [[6,9,10],[11]], [[1,2,3],[4,5]], [[7],[8]] ]); t
([[6, 9, 10], [11]], [[1, 2, 3], [4, 5]], [[7], [8]])
sage: t.level()
3
sage: t.size()
11
sage: t.shape()
([3, 1], [3, 2], [1, 1])
sage: t.is_standard()
True
sage: t.pp() # pretty printing
 6  9 10     1  2  3     7
11           4  5        8
sage: t.category()
Category of elements of Tableau tuples
sage: t.parent()
Tableau tuples

sage: s = TableauTuple([ [['a','c','b'],['d','e']],[[(2,1)]]]); s
([['a', 'c', 'b'], ['d', 'e']], [[(2, 1)]])
sage: s.shape()
([3, 2], [1])
sage: s.size()
6

sage: TableauTuple([[],[],[]])  # The empty 3-tuple of tableaux
([], [], [])

sage: TableauTuple([[1,2,3],[4,5]])
[[1, 2, 3], [4, 5]]
sage: TableauTuple([[1,2,3],[4,5]]) == Tableau([[1,2,3],[4,5]])
True
sage.combinat.tableau_tuple.TableauTuples

A factory class for the various classes of tableau tuples.

INPUT:

There are three optional arguments:

  • shape – determines a PartitionTuple which gives the shape of the TableauTuples
  • level – the level of the tableau tuples (positive integer)
  • size – the size of the tableau tuples (non-negative integer)

It is not necessary to use the keywords. If they are not specified then the first integer argument specifies the level and the second the size of the tableaux.

OUTPUT:

  • The corresponding class of tableau tuples.

The entries of a tableau can be any sage object. Because of this, no enumeration of the set of TableauTuples is possible.

EXAMPLES:

sage: T3 = TableauTuples(3); T3
Tableau tuples of level 3
sage: [['a','b']] in TableauTuples()
True
sage: [['a','b']] in TableauTuples(level=3)
False
sage: t = TableauTuples(level=3)([[],[[1,1,1]],[]]); t
([], [[1, 1, 1]], [])
sage: t in T3
True
sage: t in TableauTuples()
True
sage: t in TableauTuples(size=3)
True
sage: t in TableauTuples(size=4)
False
sage: t in StandardTableauTuples()
False
sage: t.parent()
Tableau tuples of level 3
sage: t.category()
Category of elements of Tableau tuples of level 3
sage.combinat.tableau_tuple.TableauTuples_all

The parent class of all TableauTuples, with arbitrary level and size.

sage.combinat.tableau_tuple.TableauTuples_level

Class of all TableauTuples with a fixed level and arbitrary size.

sage.combinat.tableau_tuple.TableauTuples_level_size

Class of all TableauTuples with a fixed level and a fixed size.

sage.combinat.tableau_tuple.TableauTuples_size

Class of all TableauTuples with a arbitrary level and fixed size.