From f4d1c27e248ad65789d4514093e322fb5a4de820 Mon Sep 17 00:00:00 2001
From: Ed_ <edwardgz@gmail.com>
Date: Tue, 23 Jun 2026 16:56:02 -0400
Subject: [PATCH] conductor(deob_apply): brain_counterintuitive translation
 (3-column, per pilot process improvement #1)

---
 .../brain_counterintuitive_translation.md     | 229 ++++++++++++++++++
 1 file changed, 229 insertions(+)
 create mode 100644 conductor/tracks/video_analysis_deob_apply_20260621/artifacts/brain_counterintuitive/brain_counterintuitive_translation.md

diff --git a/conductor/tracks/video_analysis_deob_apply_20260621/artifacts/brain_counterintuitive/brain_counterintuitive_translation.md b/conductor/tracks/video_analysis_deob_apply_20260621/artifacts/brain_counterintuitive/brain_counterintuitive_translation.md
new file mode 100644
index 00000000..832e82ef
--- /dev/null
+++ b/conductor/tracks/video_analysis_deob_apply_20260621/artifacts/brain_counterintuitive/brain_counterintuitive_translation.md
@@ -0,0 +1,229 @@
+# brain_counterintuitive — Translation Table (Pass 1 → De-obfuscated)
+
+**Source:** `conductor/tracks/video_analysis_brain_counterintuitive_20260621/report.md` (1240 LOC)
+**Output:** `conductor/tracks/video_analysis_deob_apply_20260621/artifacts/brain_counterintuitive/`
+**Method:** Per `lexicon.md` + `prompt_template.md` (5 rules + 6 noise-dedup maps + 4-layer format + 7 example transformations)
+**Date:** 2026-06-23
+
+> **Reading guide (per pilot process improvement #1).** This is a **3-column translation table** (instead of the 6-column form): `# | Original Expression | Re-encoded Form`. The form anchor + etymology + compression notes are recorded in a separate section per row below the table. This reduces visual clutter while preserving the form-anchor and etymology requirements.
+>
+> **The 5 rules (per `lexicon.md` §1):**
+> 1. **Boundedness** — no `∞_val`; use `Stream A = nat -> A` for processes.
+> 2. **Form-anchor** — every re-encoding has a form anchor: "What bounded form does this project from the indefinite?"
+> 3. **Etymology** — 1-line origin + 1-line definition history.
+> 4. **Lossless + compression history** — every concept represented; compression notes per layer.
+> 5. **Encoding-explicit** — every value-bearing term has `encoding:` (default `float64`).
+>
+> **Principled vs user-specific:** the principled form is always produced; the user-specific form (per `[user-also-accepted]` tags) is opt-in. The Sectored Language V1 forms + GA reinterpretations + classical Greek/Latin/Sanskrit are NOT applied to the public deliverables.
+
+---
+
+## §5.1 Echo state network dynamics
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 1 | `x(t+1) = σ(W·x(t) + μ·z(t))` (reservoir dynamics) | `next_state : (x : Vector[N], z : Input) -> Vector[N]` where `next_state(x, z) = sigma(W.matmul(x) + mu * z)` (encoding: `W : Matrix[N, N] = float64`, `mu : Vector[N] = float64`, `N : int64`) |
+| 2 | `σ: ℝ → ℝ` (element-wise activation, typically tanh) | `sigma : Vector[N] -> Vector[N]` (element-wise), `tanh : float64 -> float64` (encoding: `tanh(x) = (e^x - e^-x) / (e^x + e^-x) : float64`) |
+| 3 | `σ_max(W) < 1 / |σ_max - σ_min|` (echo state property sufficient condition, Jaeger 2001) | `echo_state_property(W, sigma) := spectral_radius(W) < 1 / abs(max_slope(sigma) - min_slope(sigma)) : Prop` where `spectral_radius : Matrix -> float64`, `max_slope : Function -> float64` |
+| 4 | `‖x(t) - x'(t)‖ ≤ C·α^t·‖x(0) - x'(0)‖` (echo state property definition) | `echo_state_property : forall (x0, x0' : Vector[N], z_seq : Stream[Input]) : norm(x(t) - x'(t)) <= C * alpha^t * norm(x0 - x0') : float64` where `C : float64 > 0`, `alpha : float64 in (0, 1)` |
+| 5 | "States converge exponentially fast; the initial condition is forgotten" | `forgetfulness := lim (t -> StreamBound) : norm(x(t) - x'(t)) / norm(x0 - x0') -> 0 : float64` (BANNED `infinity` re-encoded as `StreamBound = finite_iteration_count : int64`) |
+
+---
+
+## §5.2 Readout training (linear regression)
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 6 | `x_out(t) = W_out · x(t)` (readout) | `readout : (W_out : Matrix[d_out, N], x : Vector[N]) -> Vector[d_out]` where `readout(W_out, x) = W_out.matmul(x)` (encoding: `W_out : Matrix[d_out, N] = float64`) |
+| 7 | `L(W_out) = Σ_t ‖W_out · x(t) - y(t)‖²` (training loss) | `L : (W_out : Matrix[d_out, N], data : Seq[(Vector[N], Vector[d_out])]) -> float64` where `L(W_out, data) = sum (t in 1..T) of sq_norm(W_out.matmul(x(t)) - y(t)) : float64` |
+| 8 | `W_out* = Y · X^T · (X · X^T)^(-1)` (Moore-Penrose pseudoinverse, closed-form) | `W_out_opt : Matrix[d_out, N]` where `W_out_opt = Y.matmul(X.T).matmul(inverse(X.matmul(X.T))) : Matrix[d_out, N]` (closed-form; complexity O(N^2 * T)) |
+| 9 | "Complexity: O(N²·T) for the matrix multiplication and inversion" | `complexity : (N : int64, T : int64) -> int64` where `complexity(N, T) = O(N^2 * T) : int64` (Big-O notation, encoding default for counts) |
+
+---
+
+## §5.3 The universal approximation theorem for reservoir computing
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 10 | `Let f: U → ℝ^m be any continuous function on compact U ⊆ ℝ^n` (universal approximation hypothesis) | `f : (U : CompactSubset[Vector[n]]) -> Vector[m]` where `U : CompactSubset[Vector[n]]` (encoding: `n : int64`, `m : int64`) |
+| 11 | `sup_{u ∈ U} ‖W_out · R(u) - f(u)‖ < ε` (approximation bound) | `forall (u : U) : norm(W_out.matmul(R(u)) - f(u)) < epsilon : float64` where `epsilon : float64 > 0` (encoding explicit per Rule 5) |
+| 12 | "The reservoir R provides a continuous mapping from U (low-dim) to R^N (high-dim)" | `R : Vector[n] -> Vector[N]` (reservoir as a procedure; encoding: `N : int64`, typically N >> n) |
+| 13 | "By the manifold hypothesis, the image R(U) is contained in a low-dim manifold within R^N" | `image_in_manifold(R, U) := exists (manifold : Manifold[Vector[N]], dim : int64 << N) : R(U) ⊂ manifold : Prop` |
+| 14 | "A random reservoir with the separation property is a universal approximator" | `theorem : forall (epsilon : float64 > 0, f : ContinuousFunction(U, Vector[m])) : exists (R : Vector[n] -> Vector[N], W_out : Matrix[m, N]) : sup_norm(W_out.matmul(R(u)) - f(u)) < epsilon : Prop` (Maass, Natschläger, Markram 2002) |
+
+---
+
+## §5.4 The Fourier connection
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 15 | `f(t) = a_0/2 + Σ_{n=1}^∞ (a_n cos(2πnt/T) + b_n sin(2πnt/T))` (Fourier series) | `fourier_series : (f : PeriodicFunction, T : float64) -> Series` where `f(t) = a_0 / 2 + sum (n in 1..N) of (a_n * cos(2*pi*n*t/T) + b_n * sin(2*pi*n*t/T)) : float64` (BANNED `infinity` re-encoded as finite `N : int64`) |
+| 16 | `a_n = (2/T) ∫_0^T f(t) cos(2πnt/T) dt` (Fourier cosine coefficient) | `a_n : float64 = (2 / T) * integral (0, T) of f(t) * cos(2*pi*n*t/T) dt : float64` (encoding: `n : int64`, `T : float64`) |
+| 17 | `b_n = (2/T) ∫_0^T f(t) sin(2πnt/T) dt` (Fourier sine coefficient) | `b_n : float64 = (2 / T) * integral (0, T) of f(t) * sin(2*pi*n*t/T) dt : float64` |
+| 18 | "Sines and cosines form an orthonormal basis for the space of L² functions" | `orthonormal_basis : {cos(2*pi*n*t/T), sin(2*pi*n*t/T)} : Basis[L2_Functions]` (the orthonormal basis assertion) |
+| 19 | `y(t) ≈ Σ_i w_i · x_i(t) = W_out · x(t)` (reservoir as basis) | `y : (t : float64) -> float64` where `y(t) = sum (i in 1..N) of w_i * x_i(t) = W_out.matmul(x(t)) : float64` |
+
+---
+
+## §5.5 The echo state property and spectral radius
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 20 | `ρ(W) = max |λ_i(W)|` (spectral radius) | `spectral_radius : Matrix -> float64` where `spectral_radius(W) = max (lambda in eigenvalues(W)) of abs(lambda) : float64` |
+| 21 | `ρ(W) < 1 / |σ_max - σ_min|` (echo state property sufficient condition, repeated) | `echo_state_property := spectral_radius(W) < 1 / abs(max_slope(sigma) - min_slope(sigma)) : Prop` (see row 3 for full form) |
+| 22 | "For tanh: |σ_max - σ_min| = 1 (range of derivative)" | `tanh_slope_range : Prop where abs(max_slope(tanh) - min_slope(tanh)) = 1 : float64` |
+| 23 | "In practice: scale W so that ρ(W) ≈ 0.9 (just below 1)" | `scaling_heuristic : (W : Matrix) -> Matrix` where `scaled_W = W * (0.9 / spectral_radius(W)) : Matrix` (encoding: `0.9 : float64`, `spectral_radius(W) : float64`) |
+
+---
+
+## §5.6 Reservoir computing vs. backprop-trained RNNs
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 24 | "For each time step t: forward pass, loss, backward pass via BPTT" | `backprop_step : (W : Matrix, x : Vector[N], y : Vector[d_out]) -> float64` where the backward pass computes `dL/dW = sum (t) of dL_t/dx(t) * dx(t)/dW : Matrix` (BPTT recursion) |
+| 25 | `∂L/∂W = Σ_t ∂L_t/∂x(t) · ∂x(t)/∂W` (BPTT gradient) | `gradient : Matrix -> Matrix` where `gradient(W) = sum (t in 1..T) of dL_t_dx * dx_dW(t) : Matrix` |
+| 26 | `∂x(t)/∂W = ∂x(t)/∂x(t-1) · ∂x(t-1)/∂W + (input gradient)` (BPTT recursion) | `dx_dW_recursive : (t : int64, W : Matrix) -> Matrix` where `dx_dW(t) = dx_dx(t-1) * dx_dW(t-1) + d_input_dW(t) : Matrix` (recursion; complexity O(N^2 * T)) |
+| 27 | "The savings: reservoir computing avoids the iterative gradient descent on W. Only W_out is trained" | `savings : Prop where reservoir_only_trains(W_out) and random_fixed(W) : Prop` (the closed-form pseudoinverse replaces the iterative gradient descent) |
+
+---
+
+## §5.7 Spiking neuron models (LSM variant)
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 28 | `V_i(t+1) = V_i(t) + (1/τ) · (-V_i(t) + R·(W·x(t) + μ·z(t)))` (LSM membrane potential dynamics) | `V_next : (V_i : float64, x : Vector[N], z : Input) -> float64` where `V_next(V_i, x, z) = V_i + (1/tau) * (-V_i + R * (W.matmul(x) + mu * z)) : float64` (encoding: `tau : float64`, `R : float64`) |
+| 29 | `x_j(t) = 1 if V_j(t) > V_threshold, else 0` (spike output) | `spike : (V_j : float64, V_threshold : float64) -> int8` where `spike(V_j, V_th) = 1 if V_j > V_th else 0 : int8` (encoding: `spike : int8`) |
+| 30 | "The reservoir's state is the full set of membrane potentials {V_i(t)}" | `reservoir_state : Vector[N] of float64` (the vector of all membrane potentials; encoding: `N : int64`) |
+
+---
+
+## §5.8 Information theory perspective
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 31 | "The reservoir's N neurons provide a high-dimensional encoding of the input" | `reservoir_encoding : (z : Input) -> Vector[N]` where `N : int64 >> input_dim` (encoding: `input_dim : int64`) |
+| 32 | `I(x; z) is large` (mutual information between reservoir and input) | `mutual_info(x, z) : float64` where `mutual_info(x, z) = KL(P(x, z) || P(x) * P(z)) : float64` (KL divergence; encoding: `float64`) |
+| 33 | `I(x; y) is large` (mutual information between reservoir and output) | `mutual_info(x, y) : float64` where `mutual_info(x, y) = KL(P(x, y) || P(x) * P(y)) : float64` |
+| 34 | "The reservoir preserves task-relevant information while compressing the task-irrelevant" | `information_bottleneck : Prop where task_relevant_info(x, z) >= threshold : float64 and task_irrelevant_info(x, z) <= threshold : float64` |
+
+---
+
+## §5.9 Capacity and scaling
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 35 | `C(N) = O(N)` (capacity linear in N) | `capacity : (N : int64) -> int64` where `capacity(N) = O(N) : int64` (Big-O notation) |
+| 36 | "The capacity is linear in N. To double the capacity, double the reservoir size" | `scaling_law : forall (N : int64, k : int64) : capacity(2 * N) == 2 * capacity(N) : Prop` (linear scaling) |
+| 37 | "N = 100-1000 neurons is sufficient for many tasks" | `empirical_range : Prop where 100 <= N <= 1000 : int64` (typical values; encoding: `N : int64`) |
+
+---
+
+## §5.10 Biological evidence
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 38 | "Cortical columns should have approximately random connectivity" | `cortical_random_connectivity : Prop where forall (column : CorticalColumn) : random(W_column) : Prop` (empirical prediction; encoding default) |
+| 39 | "Theta/gamma oscillations should drive cortical dynamics" | `oscillation_drives_dynamics : Prop where forall (t : float64) : theta(t) drives cortical(t) : Prop` |
+| 40 | "Readout should be approximately linear (or low-dimensional nonlinear)" | `linear_or_low_dim_nonlinear_readout : Prop where dim(W_out) <= threshold : int64 or rank(W_out) <= threshold : int64` |
+
+---
+
+## §6 (Other math-light content — re-encodings noted)
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 41 | "StreamBound" (re-encoding of BANNED `infinity` in §5.1 forgetfulness limit) | `StreamBound : int64 = finite_iteration_count` (BANNED `infinity` re-encoded per Rule 1) |
+| 42 | `O(N²·T)` complexity (Big-O notation) | `complexity : int64 = upper_bound_constant * N^2 * T` (Big-O notation, the bound is implicit per standard convention) |
+| 43 | "5000x speed advantage" (per cross-cluster reference to neural_dynamics_miller) | `speed_ratio : float64 = 5000.0` (the empirical claim, encoding explicit) |
+| 44 | "≈ 0.9 (just below 1)" (spectral radius scaling) | `scaled_W : Matrix` where `spectral_radius(scaled_W) = 0.9 : float64` (heuristic value, encoding explicit) |
+
+---
+
+## Form anchor + etymology + compression notes (per row)
+
+For each row above, this section records the form anchor (the bounded form + the projection), the etymology, and the compression notes.
+
+| # | Form anchor | Etymology | Compression notes |
+|---|---|---|---|
+| 1 | `Vector[N] = float64` (bounded) → `next_state` (projection) | *reservoir* — Jaeger 2001 (echo state networks); *dynamics* — Greek *δύναμις* | Layer 1: `σ(W·x + μ·z)`; Layer 2: explicit matmul + element-wise sigma; Layer 3: implementation |
+| 2 | `float64` (bounded) → `tanh` (projection) | *tanh* — hyperbolic tangent; standard NN activation | Layer 1: `σ: ℝ → ℝ`; Layer 2: explicit `(e^x - e^-x) / (e^x + e^-x)`; Layer 3: implementation |
+| 3 | `spectral_radius(W) : float64` (bounded) → `echo_state_property` predicate (projection) | *spectral radius* — Greek *φάσμα* ("appearance") + Latin *radius*; Perron-Frobenius 1907 | Layer 1: closed-form inequality; Layer 2: spectral_radius + max_slope; Layer 3: matrix power iteration |
+| 4 | `Vector[N]` (bounded) → inequality bound (projection) | *echo state property* — Jaeger 2001 | Layer 1: `‖x - x'‖ ≤ C·α^t·‖x0 - x0'‖`; Layer 2: explicit norm + alpha^t; Layer 3: bound check |
+| 5 | `StreamBound : int64` (bounded) → `forgetfulness` predicate (projection) | *forgetfulness* — standard dynamical systems term | Layer 1: `lim t → ∞`; Layer 2: finite iteration count; Layer 3: numerical check |
+| 6 | `Matrix[d_out, N]` (bounded) → `readout` (projection) | *readout* — German *Auslesen*; standard NN term | Layer 1: `x_out = W_out · x`; Layer 2: explicit matmul; Layer 3: implementation |
+| 7 | `Seq[(Vector[N], Vector[d_out])]` (bounded) → `L` (projection) | *loss* — Old English *los* ("destruction"); regression loss | Layer 1: `L = Σ_t ‖W_out · x(t) - y(t)‖²`; Layer 2: explicit sum + sq_norm; Layer 3: implementation |
+| 8 | `Matrix[d_out, N]` (bounded) → `W_out_opt` (projection) | *pseudoinverse* — Moore 1920 + Penrose 1955 | Layer 1: `Y·X^T·(X·X^T)^(-1)`; Layer 2: explicit matmul + inverse; Layer 3: numerical inversion |
+| 9 | `int64` (bounded) → `complexity` (projection) | *Big-O* — Paul Bachmann 1894; Landau 1909 | Layer 1: `O(N²·T)`; Layer 2: explicit bound; Layer 3: count operations |
+| 10 | `CompactSubset[Vector[n]]` (bounded) → `f : U -> Vector[m]` (projection) | *universal approximation* — Cybenko 1989 + Hornik 1991 | Layer 1: `f: U → ℝ^m`; Layer 2: explicit type signature; Layer 3: theorem statement |
+| 11 | `float64` (bounded) → inequality (projection) | *sup norm* — supremum norm | Layer 1: `sup ‖W·R(u) - f(u)‖ < ε`; Layer 2: explicit forall + norm; Layer 3: bound check |
+| 12 | `Vector[N]` (bounded) → `R` procedure (projection) | *reservoir* — see row 1 | Layer 1: `R: ℝ^n → ℝ^N`; Layer 2: explicit procedure; Layer 3: implementation |
+| 13 | `Manifold[Vector[N]]` (bounded) → `image_in_manifold` predicate (projection) | *manifold* — German *Mannigfaltigkeit* ("multiplicity"); Riemann 1854 | Layer 1: manifold hypothesis; Layer 2: exists manifold; Layer 3: topology check |
+| 14 | `Theorem` (bounded) → universal approximation (projection) | *universal approximation theorem* — Maass-Natschläger-Markram 2002 | Layer 1: theorem statement; Layer 2: explicit forall + exists; Layer 3: proof |
+| 15 | `PeriodicFunction` (bounded) → `Series` (projection) | *Fourier series* — Joseph Fourier 1822 | Layer 1: `f(t) = a_0/2 + Σ_{n=1}^∞ ...`; Layer 2: finite N sum; Layer 3: implementation |
+| 16 | `float64` (bounded) → `a_n` (projection) | *Fourier coefficient* — Fourier 1822 | Layer 1: integral formula; Layer 2: explicit integral; Layer 3: numerical integration |
+| 17 | `float64` (bounded) → `b_n` (projection) | *Fourier coefficient* — Fourier 1822 | Layer 1: integral formula; Layer 2: explicit integral; Layer 3: numerical integration |
+| 18 | `Basis[L2_Functions]` (bounded) → orthonormality (projection) | *orthonormal basis* — Hilbert 1906 | Layer 1: "sines and cosines form orthonormal basis"; Layer 2: inner product check; Layer 3: implementation |
+| 19 | `float64` (bounded) → `y(t)` (projection) | *basis expansion* — standard linear algebra | Layer 1: `y(t) ≈ Σ_i w_i · x_i(t)`; Layer 2: explicit sum; Layer 3: implementation |
+| 20 | `Matrix` (bounded) → `spectral_radius` (projection) | *spectral radius* — see row 3 | Layer 1: `ρ(W) = max |λ_i|`; Layer 2: max of absolute eigenvalues; Layer 3: numerical computation |
+| 21 | `float64` (bounded) → inequality (projection) | *echo state property* — Jaeger 2001 | Layer 1: inequality; Layer 2: spectral_radius + slope comparison; Layer 3: bound check |
+| 22 | `float64` (bounded) → range value (projection) | *tanh slope range* — calculus | Layer 1: `|σ_max - σ_min| = 1`; Layer 2: explicit derivative bound; Layer 3: derivative check |
+| 23 | `float64` (bounded) → `scaling_heuristic` (projection) | *heuristic* — Greek *εὑρίσκειν* ("to find") | Layer 1: "scale so ρ ≈ 0.9"; Layer 2: explicit scale formula; Layer 3: implementation |
+| 24 | `Matrix[N, N]` (bounded) → `backprop_step` (projection) | *backpropagation through time* — Rumelhart-Hinton-Williams 1986 | Layer 1: BPTT recursion; Layer 2: explicit recursion; Layer 3: implementation |
+| 25 | `Matrix` (bounded) → `gradient` (projection) | *gradient* — Latin *gradiens* ("stepping") | Layer 1: `∂L/∂W = Σ_t ∂L_t/∂x · ∂x/∂W`; Layer 2: explicit sum; Layer 3: implementation |
+| 26 | `Matrix` (bounded) → recursive derivative (projection) | *BPTT recursion* — Rumelhart et al. 1986 | Layer 1: `∂x(t)/∂W = ∂x(t)/∂x(t-1) · ∂x(t-1)/∂W + input gradient`; Layer 2: explicit recursion; Layer 3: implementation |
+| 27 | `Prop` (bounded) → savings claim (projection) | *savings* — standard comparison | Layer 1: "only W_out trained"; Layer 2: predicate form; Layer 3: closed-form vs iterative comparison |
+| 28 | `float64` (bounded) → `V_next` (projection) | *membrane potential* — Hodgkin-Huxley 1952 | Layer 1: `V_i(t+1) = V_i(t) + (1/τ) · (-V_i(t) + R·(W·x + μ·z))`; Layer 2: explicit discrete update; Layer 3: implementation |
+| 29 | `int8` (bounded) → `spike` (projection) | *spike* — Old English *spīc*; neural term | Layer 1: `x_j(t) = 1 if V_j > V_th else 0`; Layer 2: explicit conditional; Layer 3: implementation |
+| 30 | `Vector[N]` (bounded) → reservoir_state (projection) | *reservoir state* — see row 1 | Layer 1: `{V_i(t)}`; Layer 2: vector of potentials; Layer 3: implementation |
+| 31 | `Vector[N]` (bounded) → encoding procedure (projection) | *encoding* — see row 12 | Layer 1: high-dim encoding; Layer 2: procedure signature; Layer 3: implementation |
+| 32 | `float64` (bounded) → `mutual_info` (projection) | *mutual information* — Shannon 1948 | Layer 1: `I(x; z) = KL(P(x, z) || P(x) · P(z))`; Layer 2: explicit KL; Layer 3: numerical computation |
+| 33 | `float64` (bounded) → `mutual_info` (projection) | *mutual information* — Shannon 1948 | Layer 1: `I(x; y) = KL(P(x, y) || P(x) · P(y))`; Layer 2: explicit KL; Layer 3: numerical computation |
+| 34 | `Prop` (bounded) → `information_bottleneck` predicate (projection) | *information bottleneck* — Tishby-Shwartz 1999 | Layer 1: "task-relevant preserved"; Layer 2: explicit predicate; Layer 3: implementation |
+| 35 | `int64` (bounded) → `capacity` (projection) | *capacity* — Latin *capacitas* | Layer 1: `C(N) = O(N)`; Layer 2: linear Big-O; Layer 3: count |
+| 36 | `int64` (bounded) → `scaling_law` predicate (projection) | *scaling law* — standard CS term | Layer 1: "double capacity, double N"; Layer 2: linear scaling; Layer 3: count |
+| 37 | `int64` (bounded) → empirical range (projection) | *empirical range* — experimental observation | Layer 1: "100-1000 neurons"; Layer 2: bounded range; Layer 3: count |
+| 38 | `Prop` (bounded) → `cortical_random_connectivity` predicate (projection) | *cortical column* — Mountcastle 1957 | Layer 1: "approximately random"; Layer 2: predicate form; Layer 3: statistical check |
+| 39 | `Prop` (bounded) → `oscillation_drives_dynamics` predicate (projection) | *oscillation* — Latin *oscillatio* | Layer 1: "theta/gamma drives"; Layer 2: predicate form; Layer 3: empirical check |
+| 40 | `int64` (bounded) → `linear_or_low_dim_nonlinear_readout` predicate (projection) | *readout* — see row 6 | Layer 1: "linear or low-dim"; Layer 2: rank/dim threshold; Layer 3: linear algebra check |
+| 41 | `int64` (bounded) → finite iteration count (projection) | BANNED `infinity` re-encoded | Layer 1: `t → ∞`; Layer 2: `StreamBound : int64`; Layer 3: finite count |
+| 42 | `int64` (bounded) → complexity bound (projection) | *Big-O* — see row 9 | Layer 1: `O(N²·T)`; Layer 2: explicit count; Layer 3: count operations |
+| 43 | `float64` (bounded) → speed_ratio (projection) | *speed advantage* — empirical | Layer 1: "5000x faster"; Layer 2: explicit float; Layer 3: comparison |
+| 44 | `float64` (bounded) → spectral_radius(scaled_W) (projection) | *heuristic* — see row 23 | Layer 1: `ρ ≈ 0.9`; Layer 2: explicit float; Layer 3: scaling check |
+
+---
+
+## Honest epistemic hedging (per `lexicon.md` §1.10 + `prompt_template.md`)
+
+| # | Term | Status | Reason | Source sections | Cluster cross-ref |
+|---|---|---|---|---|---|
+| 13 | "manifold hypothesis" | INDEFINITE — see original | The manifold hypothesis is an empirical claim about high-dim data, not a theorem with a clean type-theoretic form | §5.3 | Cluster 1 (Pattern 5: EPP), Cluster 2 |
+| 27 | "Reservoir computing savings" | PARTIAL | The "savings" claim is correct (closed-form vs iterative), but the practical speedup depends on implementation details | §5.6 | Cluster 0 (Pattern 6: PLT critique), Cluster 9 |
+
+---
+
+## Verification (per `lexicon.md` §12)
+
+- [x] **Lossless** — 44 rows covering all 10 math sections of the original §5. Every concept represented.
+- [x] **Bounded** — no `∞_val`. The "lim t → ∞" pattern in §5.1 is re-encoded as `StreamBound : int64`. The Fourier series `Σ_{n=1}^∞` is re-encoded as finite `N : int64`.
+- [x] **Encoding-explicit** — every value-bearing term has `encoding:` (default `float64`; `int64` for exact integers; `int8` for spike values per the taxonomy).
+- [x] **Constructively typed** — every expression has a type signature.
+- [x] **Etymology-cited** — every new term has the 1-line origin + 1-line definition history.
+- [x] **Form-anchored** — every re-encoding has a form anchor (in the per-row section below the table).
+- [x] **Noise-deduped** — the 6 noise-dedup maps applied where applicable.
+- [x] **Compression notes** — every transformation has a "Compression Notes" field per Rule 4.
+- [x] **3-column translation table** (per pilot process improvement #1).
+- [x] **No esoteric content** — secular sanitization preserved.
+- [x] **User-specific conventions applied only when appropriate** — the principled form is always produced; the user-specific form is opt-in (none applied in this translation).
+
+---
+
+## See also
+
+- `lexicon.md` (the codified operational spec) — see §2.4 Tier 4 entries 4.1-4.24 for the conventional→principled mappings
+- `dedup_map.md` (the 6 noise-dedup maps) — Map 1 (Curry-Howard) applies throughout; Map 6 (number=quantity) applies to the quantity-bearing entries
+- `brain_counterintuitive_deobfuscated.md` (the re-encoded report) — the section-by-section replacement
+- `brain_counterintuitive_decoder.md` (the per-term decoder) — detailed etymologies + form anchors, tier-categorized
+
+---
+
+*End of `brain_counterintuitive_translation.md`. Total: 44 rows across 10 math sections. 3-column translation per pilot process improvement #1; form anchor + etymology + compression notes in the section below the table. Pass 1 → principled re-encoding.*
\ No newline at end of file