# hierarchy
nests or layers segments recursively to create deep structural repetition and variation - supporting fractal forms, mosaics, and branching trees.

## introduction
the `hierarchy` domain resides in the structure layer, building nested segment architectures by recursively subdividing or combining segments defined by `segmentation`.\
it determines how segments are layered across multiple levels, producing trees, fractals, or mosaic-like tilings.\
all hierarchies are static: once parameters `a` and `b` are set, the complete multi-level structure is precomputed with no runtime side-effects.
## overview
each form constructs a multi-level segmentation map over a fixed total duration:
- `nested_equal`
  - behavior: every segment is split into d equal parts at each level
  - analogy: russian nesting dolls of identical slices
  - parameters:
    - `a`: subdivisions per segment (2–8)
    - `b`: recursion depth (1–4 levels)
- `recursive_ratio`
  - behavior: applies a geometric partition (ratio r) recursively to each segment
  - analogy: fractal columns whose widths grow by a fixed factor
  - parameters:
    - `a`: growth ratio r (1.1–3.0)
    - `b`: recursion depth (1–4)
- `fractal_tree`
  - behavior: constructs a branching tree where each segment splits into k child segments at every node
  - analogy: a genealogical tree or plant branching pattern
  - parameters:
    - `a`: branch factor k (2–5)
    - `b`: tree depth (1–4)
- `mosaic_pattern`
  - behavior: uses a predefined ratio pattern to subdivide each segment, repeating that pattern recursively
  - analogy: recursive mosaic tiling with a fixed tile shape
  - parameters:
    - `a`: pattern selector (chooses one of five built-in ratio arrays)
    - `b`: recursion depth (1–4)
## parameter behavior summary
- `nested_equal`
  - `a`: how many equal parts each segment yields
  - `b`: how many levels of recursion
- `recursive_ratio`
  - `a`: constant ratio for geometric splits
  - `b`: recursion levels
- `fractal_tree`
  - `a`: number of child branches per segment
  - `b`: depth of branching
- `mosaic_pattern`
  - `a`: index selecting a fixed ratio pattern
  - `b`: recursion levels
## why these were chosen
- archetypal coverage: spans the principal recursive paradigms - uniform, proportional, branching, and patterned subdivision
- orthogonal logic: each form embodies a distinct nesting principle, irreducible to the others
- full pre-computation: given `a`, `b`, the entire hierarchy is determined offline, ensuring repeatability
- two-parameter purity: every form navigates its space with exactly two meaningful controls
## what is not included
- event-driven or onset-based recursion: belongs in the onset layer
- segment reordering or permutation: handled by the `ordering` domain
- context-sensitive or dynamic grammars: outside static hierarchy scope
- overlapping/non-nested windows (e.g. sliding): not part of hierarchical segmentation
## conclusion
the `hierarchy` domain's four forms deliver a compact, deterministic toolkit for multi-level temporal architectures - enabling deep, repeatable structures that integrate seamlessly with upstream segmentation and downstream ordering, without any runtime complexity.