Number of integers in flattened representation. :return: Length of flattened tuple :rtype: int

Return flattened tuple of all integers. :return: Flattened tuple :rtype: tuple

Substitute values into the nested structure. :param values: Values to substitute :type values: tuple :return

Compute the composition β ∘ α: <m>_* → <p>_*. :param beta: Second morphism to compose (must have domain = self.codomain)

Compute the layout associated to a nested tuple morphism. :param morphism: Input nested tuple morphism :type morphism: Nest_morphism

Compute the layout L_f associated to a tuple morphism f. :param morphism: Input tuple morphism :type morphism: Tuple_morphism :r

Generate a random tuple morphism. :param domain: Domain tuple (optional) :type domain: tuple or None :param codomain: Codomain t

Compute coalescence of the morphism. :return: Coalesced morphism :rtype: Nest_morphism

Generate a random profile (nested tuple with all zeros). :param length: Number of zeros in flattened tuple :type length: int :pa

Compute the complement of f. :return: Complement morphism :rtype: Nest_morphism :raises ValueError: If not c

Number of top-level modes. :return: Rank of the nested tuple :rtype: int

Get i-th mode as a NestedTuple (1-indexed). :param i: Mode index (1-based) :type i: int :return: i-th mode

Product of all integers in the nested tuple. :return: Product of all entries :rtype: int

Check if self refines other. S refines T if: 1. S = T, or 2. T = size(S), or 3. rank(S) = rank(T)

Get relative mode with respect to another NestedTuple. :param i: Index (1-based) :type i: int :param other:

Generate a random nested tuple morphism. :param domain: Domain nested tuple (optional) :type domain: NestedTuple or None :param

Compute concatenation (f,g) of nested tuple morphisms. :param g: Second morphism :type g: Nest_morphism :ret

Product of codomain entries. :return: Cosize :rtype: int

Compute the flattening of a given layout. :param layout: Input layout :type layout: cute.Layout :return: Flattened layout :r

Generate a random complementable tuple morphism. Creates a morphism with 0 < length(domain) < length(codomain). :param min_leng

Generate a tuple of k distinct integers sampled uniformly from {1,...,m}. :param m: Upper bound of the set (inclusive) :type m: int

Flatten to a Tuple_morphism. :return: Flattened morphism :rtype: Tuple_morphism

Compute logical product. :param other: Second factor :type other: Nest_morphism :return: Product :rt

Product of codomain entries. :return: Size of codomain :rtype: int

Check if morphisms α and β have disjoint images. :param beta: Other morphism with same codomain :type beta: Fin_morp

Check if the morphism is coalesced. :return: True if coalesced :rtype: bool

Compute logical division. :param other: Denominator morphism :type other: Nest_morphism :return: Quotient

Compute mutual refinement of two nested tuples. Given nested tuples T and U, computes T' and U' such that: 1. T' refines T 2. U'

Build a single picture with one set of (s{i}). - If domain.depth() <= 1: skip tree half entirely. - Mode roots m<i>: * if root_y_

Generate a random NestedTuple containing exactly `length` integers. :param length: Number of integers in flattened tuple :type lengt

Return sorted version of the morphism. :return: Sorted morphism :rtype: Tuple_morphism

Remove all ones from domain and codomain. :return: Squeezed morphism :rtype: Tuple_morphism

Draw two tree halves sharing a single integer leaf stack (duplicates supported). Left = P, Right = Q. Each side is resolved to GLOBAL leaf in

On an index-mapped tree, collect the (global) leaf indices under 'tree'.

Return a new tree with leaves replaced by their GLOBAL leaf indices. Each time a value v is encountered, pop the leftmost index from value_po

Create a visible root node for EVERY top-level item in the INDEXED tree: • Leaf item: label is the leaf value (via values_by_index); draw a

Compute the complement of f. :return: Complement morphism :rtype: Tuple_morphism :raises ValueError: If not

Compute composition g ∘ f. :param g: Second morphism :type g: Nest_morphism :return: Composition :rt

Compute concatenation of morphisms with same codomain and disjoint images. :param g: Second morphism :type g: Tuple_

Compute the nested concatenation (L_1, L_2) of layouts. :param base: First layout :type base: cute.Layout :param stack: Second l

Get i-th entry (1-indexed). :param i: Index (1-based) :type i: int :return: Value at index i :rtype:

Factorize morphism through a subtuple of its codomain. :param subtuple: Codomain indices (1-based) :type subtuple: T

Check if morphism is complementable. :return: True if complementable :rtype: bool

Check if nested tuple morphism is complementable. :return: True if complementable :rtype: bool

Check if morphism is complementary to other morphism. :param other: Other morphism :type other: Nest_morphism

Check if f is an isomorphism. :return: True if isomorphism :rtype: bool

Check if f is an isomorphism. :return: True if isomorphism :rtype: bool

Check if the nested tuple morphism is sorted. :return: True if sorted :rtype: bool

Return profile (structure with all zeros). :return: Profile of the nested tuple :rtype: NestedTuple

Pullback morphism along a refinement. :param refinement: Refinement of codomain :type refinement: NestedTuple

Pushforward morphism along a refinement. :param refinement: Refinement of domain :type refinement: NestedTuple

Generate a random morphism in Fin_*. :param domain: Domain size (optional) :type domain: int or None :param codomain: Codomain s

Generate a pair of tuple morphisms with same codomain and disjoint images. :param min_length: Minimum length :type min_length: int

Generate a random complementable nested tuple morphism. :return: Random complementable morphism :rtype: Nest_morphism

Generate a pair of tuple morphisms f, g where g divides f. g is injective and codomain(g) = domain(f). :param min_length: Minim

Generate a pair of mutually refinable nested tuples. :return: Pair of mutually refinable nested tuples :rtype: Tuple[NestedTuple, N

Generate a pair of tuple morphisms admissible for product operation. :param min_length: Minimum length :type min_length: int :pa

Product of domain entries. :return: Size of domain :rtype: int

Sort a flat layout by stride values, breaking ties by shape. :param flat_layout: Input flat layout :type flat_layout: cute.Layout

Compute sublength up to position i. :param i: Position (1-based) :type i: int :param refined: Reference Nest

Compute the wedge sum α ∨ β: <m+p>_* → <n>_*. Morphisms must have same codomain and disjoint images. :param

Check if nested morphism coalescence agrees with layout coalescence. :param f: Nest morphism to test :type f: Nest_morphism :ret

Check if nested tuple morphism complement agrees with layout complement. :param f: Morphism to test :type f: Nest_morphism :retu

Check if nested morphism composition agrees with layout composition. :param f: First morphism :type f: Nest_morphism :param g: S

Check if nested morphism concatenation agrees with layout concatenation. :param f: First morphism :type f: Nest_morphism :param

Custom representation without trailing commas for single elements. :param obj: Object to represent :return: String r

Generator for flattening nested structure. :param obj: Object to flatten :yield: Integer values

Build junctions for an INDEXED tree (leaves are global indices). Junction x uses uniform subdivision depth/(max_layers_root+1) from root_x →

Recursively validate the nested structure. :param obj: Object to validate :return: True if valid :rtype: boo

Validate that the input data defines a valid morphism in E_0. :raises ValueError: If the morphism is invalid

Verify that the input data defines a valid morphism in Tuple category. :raises ValueError: If morphism is invalid

Verify that the input data defines a valid morphism. :raises ValueError: If morphism is invalid

Check if morphism coalescence agrees with layout coalescence. :param f: Tuple morphism to test :type f: Tuple_morphism :return:

Check if morphism complement agrees with layout complement. :param f: Morphism to test :type f: Tuple_morphism :return: True if

Compute composition g ∘ f. :param g: Second morphism (must have domain = self.codomain) :type g: Tuple_morphism

Check if morphism composition agrees with layout composition. :param f: First morphism :type f: Tuple_morphism :param g: Second

Check if weak composition algorithm produces correct result. :param f: First morphism :type f: Nest_morphism :param g: Second mo

Compute a nested tuple morphism from a tractable layout. Given a tractable layout L, produces a nested tuple morphism f with L_f = L.

Compute a tuple morphism from a tractable flat layout. Given a tractable flat layout L, produces the standard representation f_L of L.

Check if morphism concatenation agrees with layout concatenation. :param f: First morphism :type f: Tuple_morphism :param g: Sec

Maximum depth of nesting in the nested tuple. An integer has depth 1, a flat tuple has depth 1, a nested tuple has depth 1 +

Compute the flat concatenation concat(L_1, L_2) of flat layouts. :param base: First layout :type base: cute.Layout :param stack:

Compute flat division self / other. :param other: Denominator morphism :type other: Tuple_morphism :return:

Check if flat division of morphisms agrees with layout division. :param f: Numerator morphism :type f: Tuple_morphism :param g:

Compute flat product self × other. :param other: Second factor :type other: Tuple_morphism :return: Product

Check if flat product of morphisms agrees with layout product. :param f: First factor morphism :type f: Tuple_morphism :param g:

Return flat leaf indices covered by `mode` (advancing by .length()).

Check if morphisms have disjoint images. :param g: Other morphism :type g: Tuple_morphism :return: True if d

Check if morphisms have disjoint images. :param g: Second morphism :type g: Nest_morphism :return: True if d

Check if the morphism is sorted. :return: True if sorted :rtype: bool

Check if a given layout is tractable. A layout is tractable if each stride divides evenly into the next stride times shape product.

Main function for testing.