# advanced ideas and concepts for control and variation
generative mutation, statistics, and hybrid reasoning

# mutation
mutation introduces controlled variability to sequences or templates over time. it enables evolving patterns, generative variation, and non-repetitive textures in synthesis and composition.

## templates
a template is a base sequence or pattern—a blueprint of values or onsets. mutations operate on copies of this template rather than the original, ensuring you always have a known starting point.
* static template: the original, unaltered sequence
* working copy: the mutable instance derived from the template

## mutation operations
mutations modify the working copy via operations such as:
* random perturbation: add noise or jitter to values or intervals
* rotational shift: cyclically rotate sequence elements
* value mapping: remap elements through functions or lookup tables
* structural swap: exchange segments or sub-sequences
* parameter tweak: adjust global parameters (e.g. scale factor, offset)

## accumulation
accumulating mutations means each mutation builds upon the previous state, leading to gradually evolving sequences.
* successive random perturbations can drift the pattern over time
* repeated rotations or swaps can generate complex, emergent transformations
* accumulation can be bounded (e.g. clamp values) or unbounded, depending on desired effect

## reset strategies
to prevent unbounded drift and reintroduce periodic structure, mutations can be reset:
* fixed-interval reset: revert the working copy to the template every *n* beats, measures, or seconds
* arbitrary/conditional reset: trigger reset upon events (e.g. new section, user action, threshold crossing)
* partial reset: restore only specific elements or parameters, leaving others mutated

## combined schemes
by combining accumulation and reset, you can craft rich generative behaviors:
* sawtooth evolution: accumulate mutation for *n* cycles, then reset, creating repeating yet evolving motifs
* random walk with anchor: small random steps accumulate, but occasional resets prevent runaway divergence
* template branching: maintain multiple templates; switch the working copy’s template at reset points to jump between stylistic variants

by leveraging templates, accumulation, and reset strategies, you can generate sequences that balance predictability (through resets to known templates) with novelty (through cumulative mutation), yielding dynamic and engaging musical structures.

## transfer: comparison with functional programming
* Per-element change
  * Functional analogue: `map`
  * Purpose: non-accumulating mutations
* Cumulative mutation
  * Functional analogue: `fold`, `scanl`
  * Purpose: accumulation over time
* Generative unfolding
  * Functional analogue: `unfold`
  * Purpose: procedural generation from a template
* Evolving stateful system
  * Functional analogue: `state monad`
  * Purpose: handles resets, random mutation, and branching

# statistics for generative parameter arrays
this section defines statistical tools to analyze, compare, and generate time-variant parameter patterns. by summarizing complex detail into concise metrics, you can guide monte-carlo generators, target specific pattern characteristics, or blend existing motifs.

## roles of statistics
* abstraction: distill a full sequence into a few descriptive values
* comparison: measure similarity or difference between patterns
* generation target: drive random or procedural generators toward desired statistical profiles
* pattern blending: adjust or interpolate segments so their statistics converge or diverge
* difference analysis: compute stats on first-order differences (i.e. Δ\[n] = x\[n] – x\[n–1]) to control variability or smoothness

note: pointwise interpolation creates similarity by direct value blending, while statistics-based methods operate on aggregated properties.

## core descriptive measures
### mean (mu)

```text
mu = (1/N) * sum_{i=1 to N} x_i
```

use: center generated values so total “energy” or centroid aligns with target.

### median
the middle value when data are sorted.
use: ensure half the values lie above and half below, giving robustness to outliers.

### standard deviation (sigma)

```text
sigma = sqrt((1/N) * sum_{i=1 to N} (x_i - mu)^2)
```

use: control overall variability or “jitter” of parameters.

### range

```text
range = max(x) - min(x)
```

use: bound generated values within desired dynamic or spectral limits.

### minimum / maximum
`min(x)`, `max(x)`
use: clamp generation or normalization processes.

## higher-order moments

### skewness (gamma1)

```text
gamma1 = ((1/N) * sum_{i=1 to N} (x_i - mu)^3) / sigma^3
```

use: bias generation toward longer tails of high or low values.

### kurtosis (gamma2)

```text
gamma2 = ((1/N) * sum_{i=1 to N} (x_i - mu)^4) / sigma^4 - 3
```

use: distinguish between flat vs. heavy-tailed distributions.

## spatial/statistical centroids

### center of mass (COM)

```text
COM = (sum_{i=1 to N} (i * x_i)) / (sum_{i=1 to N} x_i)
```

use: measure where energy or weight concentrates in time or frequency.

## pattern-specific metrics

### unique subsequence count
count of distinct overlapping subsequences up to length L.
low example: `11111`, `112112` → few unique patterns
high example: `12345`, `112212` → many unique patterns
use: quantify repetitiveness or novelty.

### distribution of differences
apply any of the above statistics (mean, sigma, skew) to

```text
Δ[n] = x[n] - x[n-1]
```

use: control smoothness vs. abrupt changes in envelopes or sequences.