From 5f69e2cbec0c0bf14938753459a0c7f4b70a9d76 Mon Sep 17 00:00:00 2001 From: cah Date: Mon, 23 Feb 2026 22:42:32 -0700 Subject: [PATCH] Add design doc for frame sync and code analysis Covers frame synchronization prototype (acquisition + re-sync) and four code analysis studies: rate comparison, base matrix quality, quantization sweep, and Shannon gap computation. Co-Authored-By: Claude Opus 4.6 --- ...-23-frame-sync-and-code-analysis-design.md | 153 ++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 docs/plans/2026-02-23-frame-sync-and-code-analysis-design.md diff --git a/docs/plans/2026-02-23-frame-sync-and-code-analysis-design.md b/docs/plans/2026-02-23-frame-sync-and-code-analysis-design.md new file mode 100644 index 0000000..1d64329 --- /dev/null +++ b/docs/plans/2026-02-23-frame-sync-and-code-analysis-design.md @@ -0,0 +1,153 @@ +# Frame Synchronization & Code Analysis Design + +## Context + +LDPC decoder for photon-starved optical communication (rate 1/8, n=256, k=32, Z=32). The receiver has no frame alignment — it must find codeword boundaries from a continuous stream of soft LLR values. Target operating point: 1-2 photons/slot (lambda_s). + +## Goals + +1. Prototype frame synchronization in Python (acquisition + re-sync) +2. Validate design decisions with four quantitative analyses: + - Rate comparison (is 1/8 the right rate?) + - Base matrix quality (how much performance is left on the table?) + - Quantization sweep (is 6-bit enough?) + - Shannon gap (how far from theoretical limits?) + +## Frame Synchronization + +### Stream Model + +Concatenate N encoded codewords into a continuous stream. Generate Poisson channel LLRs for the entire stream. Insert a random unknown offset (0-255 bits) at the start. The sync algorithm sees only the shifted stream. + +### Acquisition Algorithm (Scenario A) + +``` +for offset in 0..255: + window = stream_llr[offset : offset+256] + hard_bits = [0 if llr > 0 else 1 for llr in window] + syn_wt = compute_syndrome_weight(hard_bits) + if syn_wt < SCREENING_THRESHOLD: + decoded, converged, _, _ = decode(quantize(window)) + if converged: + # Confirm: decode next 2 frames at this offset + if confirm_sync(stream_llr, offset): + return offset # LOCKED +return SYNC_FAILED +``` + +Screening threshold: ~50 (out of 224 checks). Wrong offsets will have syndrome weight ~112 (random). Correct offset at operational SNR will be much lower. + +### Re-Sync (Scenario C) + +During steady-state decoding, monitor syndrome weight. If N consecutive frames fail to converge (syndrome_weight > 0 after max iterations), trigger re-acquisition: +1. Search offsets ±16 around last known good offset +2. If not found, full 0-255 search + +### Metrics + +- Acquisition success rate vs lambda_s +- Average offsets screened before lock +- Total cost in equivalent decode cycles +- False lock probability +- Re-sync success rate after simulated offset slip + +## Analysis 1: Rate Comparison + +### Codes Under Test + +All use Z=32, IRA staircase structure, same shift-value strategy. + +| Rate | M_BASE | N_BASE | n | k | +|------|--------|--------|-----|----| +| 1/2 | 1 | 2 | 64 | 32 | +| 1/3 | 2 | 3 | 96 | 32 | +| 1/4 | 3 | 4 | 128 | 32 | +| 1/6 | 5 | 6 | 192 | 32 | +| 1/8 | 7 | 8 | 256 | 32 | + +### Method + +For each rate, sweep lambda_s from 0.5 to 10 (step 0.5), 500 frames/point, lambda_b=0.1. Record FER and BER. + +### Key Output + +Threshold lambda_s (FER < 10%) for each rate. Directly answers whether rate 1/8 is necessary to reach 1-2 photons/slot. + +## Analysis 2: Base Matrix Quality + +### Matrices Under Test + +All rate 1/8 (7x8, Z=32): + +1. **Current staircase** — existing H_BASE. Col 7 has dv=1 (weak). +2. **Improved staircase** — add 1-2 extra connections to low-degree columns. Maintain lower-triangular parity for sequential encoding. +3. **PEG-constructed** — Progressive Edge Growth algorithm to maximize girth. Better degree distribution but encoding requires back-substitution. + +### Metrics + +- FER vs lambda_s at target range (0.5-5 photons) +- Tanner graph girth for each matrix +- VN/CN degree distributions +- Encoding complexity comparison + +## Analysis 3: Quantization Sweep + +### Method + +Fix lambda_s near decoding threshold (from analysis 1). Run decoder at quantization levels: 4, 5, 6, 8, 10 bits, and float32. Same code, same matrix, 500 frames. + +### Key Output + +FER vs quantization bits. Identifies the knee where adding more bits stops helping. Validates or challenges the 6-bit design choice. + +## Analysis 4: Shannon Gap + +### Method + +Compute Poisson channel capacity for binary-input OOK: + +``` +C = max_p H(Y) - p*H(Y|X=1) - (1-p)*H(Y|X=0) + +where Y|X=x ~ Poisson(x*lambda_s + lambda_b) +H(Y|X=x) = -sum_y P(y|x) * log2(P(y|x)) +``` + +Optimize over input probability p (though p=0.5 is near-optimal for the symmetric case). + +Find minimum lambda_s where C >= R for each rate tested in analysis 1. + +### Key Output + +Shannon limit lambda_s for rate 1/8 vs decoder operational threshold. Gap in dB tells us how much room for improvement exists. + +## Implementation Structure + +``` +model/ + ldpc_sim.py # existing (unchanged, provides encoder/decoder/channel) + frame_sync.py # NEW: frame sync simulation + ldpc_analysis.py # NEW: analyses 1-4 as subcommands +``` + +### frame_sync.py + +- Imports encoder, decoder, channel, syndrome check from ldpc_sim +- `--n-frames`: number of codewords in stream (default 20) +- `--sweep`: sweep lambda_s for acquisition success rate curve +- `--resync-test`: simulate offset slip and test re-acquisition +- Prints summary table + per-offset screening results + +### ldpc_analysis.py + +- Imports encoder, decoder, channel from ldpc_sim +- Subcommands: `--rate-sweep`, `--matrix-compare`, `--quant-sweep`, `--shannon-gap`, `--all` +- Each analysis prints a summary table to stdout +- Results saved to `data/analysis_results.json` +- `--n-frames` controls simulation length (default 500, increase for publication-quality) + +### Dependencies + +- numpy (already used by ldpc_sim.py) +- scipy (for Shannon gap — Poisson PMF, optimization) — new dependency +- No other external dependencies