What this measures The encoder measures inter-symbol periodicity at lag k. If knowing X_i−k significantly reduces uncertainty about X_i, the data has a stride-k structure the encoder can exploit. Stride detection is independent of bit-plane structure — a file can score well on bit-plane metrics but also have strong stride correlation.

Stride confidence = (H(k=1) − H(k_winner)) / H(k=1). Near 0% means no useful stride structure. 20%+ means the encoder will find meaningful stride correlation.

Note: Analysis is performed on up to 200,000 bytes (the file analysis cap). The encoder applies its own 1 MB cap internally; for files larger than 200 KB, stride results may not reflect full-file periodicity.

Reading this view The swept bit starts near its natural set-frequency. After the L0 bit-clearing pass, it collapses to 0.0 in the aligned layer — that's the structural claim. The Bit column in the Decay Profile shows which bit was targeted at each layer.

What this measures Even-alignment increases mod-N alignment because rounding odd values down promotes divisibility. This quantifies how much latent mod-N structure is unlocked for free by a single bit-plane pass.

How this works Raw data has H bits/byte of Shannon entropy. After bit-plane decomposition, the aligned stream and each flag layer's bitset carry their own entropy. If H(aligned) + H(flags) < H(raw), entropy was genuinely reduced — the data had structure the bit-plane pass could separate. If it equals or exceeds the input, the decomposition relocated entropy without reducing it. Both are real findings.

Flag entropy model: each flag layer is treated as a bitset of N bits with K set. Entropy = N × H(K/N) where H is the binary entropy function. This measures the information content of knowing which positions were flagged.

This page's entropy model uses fixed bit-0 (LSB clearing) as a controlled target to isolate its entropy contribution — one of eight possible targets. The Decay Profile and encoder use adaptive bit selection (sparsest bit per layer), which is why halt depths there may differ. The table below extends this fixed-bit-0 analysis to all 8 positions for comparison.

The core hypothesis In structured data, the LSB (bit 0) carries disproportionately less entropy than higher-order bits because value clustering means the LSB is quantization noise on top of a smoother signal. The bit-plane pass strips that noise and encodes it separately. For uniform random data, every bit carries identical entropy (~1.0 bit) — the decomposition can only relocate, not reduce. The asymmetry in this profile is the mechanistic explanation of AIM's structural claim.

Reading the chart: A bit near 1.0 is carrying maximum entropy (set in ~50% of values). A bit near 0.0 is nearly deterministic — almost always set or almost always clear. Bits far from 1.0 are the cheap ones: they cost little to encode separately, and separating them exposes the smoother structure underneath.

Cross-reference: The Bit Clearing Sweep shows which bit position produces the fewest total flags. The Entropy Analysis shows which produces the lowest total output entropy. This page explains why they answer slightly different questions — fewer flags ≠ lower entropy if the aligned stream picks up entropy from the clearing operation.

Five modes, one question: does AIM decomposition make data more compressible?

Note: modes 1–4 simulate full-depth recursion. The actual encoder halts early via HALT_ANS_STRIDE for structured data — see the Predicted Halt section below and the Decay Profile page for the estimated cutoff.

Blob — aligned bytes + all flag layers concatenated, single gzip. Baseline: forces gzip to handle heterogeneous content in one pass. (Full depth.)

Generic split — each stream independently gzip'd, sizes summed. Better, but applies gzip uniformly to every layer regardless of size — tiny layers get hit with header overhead that exceeds their content. (Full depth.)

Targeted split — per-layer optimal selection: bitset-raw, delta-raw, bitset+gzip, delta+gzip, picks smallest. Skips gzip for layers below ~32 bytes. This is what the three-stream architecture delivers. (Full depth.)

Targeted + final gzip — outer gzip applied to the full targeted-encoded concatenation. (Full depth.)

Predicted halt (Mode 5) — estimated output size if HALT_ANS_STRIDE fires at the predicted depth. Uses the HALT predictor from the Decay Profile page. This is the most realistic estimate of what the actual encoder would produce for structured data.

Ratio < 1.0 = AIM wins.

The invariant When dataset length is a multiple of 8, the bit-plane recursion tree is perfectly symmetric at every depth — no remainder elements to break parity propagation. This means: even byte 0 → terminal halt at 0 (complete structural collapse); odd byte 0 → terminal halt at 1 (irreducible LSB). This is deterministic, not probabilistic. It is a zero-cost integrity check: compute the prediction before reconstruction, compare after. If they disagree, reconstruction failed.

Why it matters beyond integrity: It tells you something real about the data. A dataset that predicts and delivers terminal 0 has had its arithmetic structure completely resolved — every layer found structure all the way down. Terminal 1 means an irreducible identity remains — the last LSB the transform couldn't absorb.

What the fingerprint captures Two datasets with identical Shannon entropy can have completely different fingerprints. Random noise and natural language both run 13 layers — but their bit distributions at L0 cleanly separate them (random: flat ~0.5; language: clustered at bits 5–6 from ASCII 32–127). The fingerprint is the structural class signature: not what the data means, but what kind of mathematical object it is at the byte level.

Practical use beyond compression: An unknown binary file that fingerprints as "structured / rapid collapse" is likely a numerical sequence or table. "Language / ASCII" means text-like encoding. "Uniform noise" means the data is either truly random or already compressed/encrypted (which looks the same to this instrument). "Oscillating deep" is a gradient or ramp. These classifications work without knowing the file's domain, format, or meaning.

Interpretation Single even-alignment is the baseline. Each mod-N column shows the total flag count when mod-N is interleaved. A value lower than Single would be a genuine win; in practice, chaining consistently produces more flags than single even-alignment alone.

Why chaining fails Flag positions from an even-alignment pass are indices in a position space — they carry no reason to exhibit modular structure. A mod-N pass on those positions generates flag ratios of 0.75–0.93 at every layer, spreading entropy across more layers without reducing it. The mod-N operation is looking for periodic structure in a list of index values that have none. This is not a failure of mod-N as an operation — it's a failure of target selection. The Seer step (Part 1 of the AIM formula) would reject this application: studying position indices through a modular lens reveals no coherent relationship to the target.

How to read this Each bit position defines a different structural target. Clearing bit b means: if a value has that bit set, subtract 2^b and record the position as a flag. This is identical to what AIM does for bit 0 (subtract 1 from odd values), generalized to any power of two.

Fewer total flags = more structure. If a bit is already clear in most values, few positions get flagged and the recursion terminates quickly. That means the data is naturally aligned to that bit's boundary — a genuine structural property. The sweep finds which power-of-two boundary the data is most aligned to, without assuming it's always 2 (even-alignment).

AIM Tree vs linear chain A disconnected chain splits the decomposition into two branches: Branch A recurses on even-pass flag positions; Branch B recurses on mod-N positions from aligned values. Both are lossless. The cost is the sum of both branch totals.

Predictor formula (from §N1): For each bit b, split the data into two sub-distributions: values with bit b set (cleared to aligned values) and values with bit b clear (unchanged). Predicted net = p×H_set + (1−p)×H_clear + H(p) − H(raw). If predicted_net < −raw_H×0.01, predict "reduction". The winner is the most negative predicted_net.