How the scan was classified.

“Accepted” entries belong to the mathematical catalog. “Rejected” means the extracted span is not a complete mathematical record; it is still preserved here and in its full source. Where an adjacent source passage supplies the complete expression, the recovered replacement is linked.

Download every scan decision ↗

RingDiffusionStep performs dS_i/dt = λ(S_{i+1} + S_{i-1} - 2S_i)

LinkingNumber returns Lk = Tw + Wr

Twist16Strands returns Tw = N/10.6 × 16

RelaxedLinkingNumber returns Lk₀ = N/10.6

SuperhelicalDensity returns σ = (Lk - Lk₀)/Lk₀

FreeEnergy returns ΔG_sc = K · N · σ² · (10.6/10.4)²

Update global phase: φ(t) = (2πt/10.6) mod 2π

Update strand states: S_k(t) = A_k · e^{i(ωt + 2πk/10.6)}

min_G max_D V(D,G) = E[log D(x)] + E[log(1-D(G(z)))]

P(x) = Π_t P(x_t | x_1, ..., x_{t-1})

q(x_t|x_{t-1}) = N(√(1-β_t)x_{t-1}, β_t I)

p(x) = exp(-E(x)) / Z where Z = ∫ exp(-E(x)) dx

Langevin dynamics: x_new = x - step_size * grad + sqrt(2 * step_size * temp) * noise

p(x) = p(z) |det ∂f⁻¹/∂x| where z = f⁻¹(x)

Forward: y2 = x2 * exp(s(x1)) + t(x1)

Inverse: x2 = (y2 - t(x1)) * exp(-s(x1))

y = Σᵢ g(x)ᵢ · Eᵢ(x) where g is gating function

h_t = f(h_{t-1}, x_t)

rnnStep performs one RNN step: h = tanh(W_ih * x + W_hh * h + b)

LinearLayer computes y = Wx + b

x'(t) = Ax(t) + Bu(t), y(t) = Cx(t) + Du(t)

Simple Euler discretization: Ad = I + dt*A, Bd = dt*B

ssmStep performs one SSM step: x' = Ax + Bu, y = Cx + Du

x' = Ad*x + Bd*u

y = Cx + Du

ELBO = E_q[log p(x|z)] - D_KL(q(z|x) || p(z))

reparameterize performs reparameterization trick: z = mu + std * epsilon

KL = -0.5 * sum(1 + log(σ²) - μ² - σ²)

ELBO = reconstruction + β * KL

MatMul performs matrix multiplication: C = A @ B

Add element-wise addition: C = A + B

Linear: A[l+1] = A[l] @ W[l] + b[l]

Φ = Integrated Information Theory metric

Φ = 1 / (1 + |x - 1|) where x is normalized activity

Temporal difference error: δ = r + γV(s') - V(s)

Hebbian update: Δw = η * x_i * x_j

q = round((x - zero_point) / scale)

x = q * scale + zero_point

Size: K bytes + K*4 bytes = 5K bytes (K=4: 20 bytes vs 64)

Size: 4 + 15 + 4 = 23 bytes (vs 64)

@brief Ultra-compact binary matrix (256 bits = 32 bytes!)

A1: Identity     - 1 = 1 * x (unity is self-referential)

A2: Consciousness - Phi = 1/(1 + |x - 1|) (proximity to unity)

A3: Unity        - infinity = 1 (all converges to one)

phi = 1.6180339887498948482...

phi^2 = phi + 1

1/phi = phi - 1

Phi(x) = 1 / (1 + |x - 1|)

- Phi(1) = 1 (perfect consciousness at unity)

- Phi(0) = 0.5

- Phi(2) = 0.5

Uses soft absolute value: |x| ≈ sqrt(x^2 + T)

@param temperature Smoothing temperature (smaller = sharper)

d(Phi)/dx = -sign(x-1) / (1 + |x-1|)^2

d(Phi_smooth)/dx = -(x-1) / (sqrt((x-1)^2 + T) * (1 + sqrt((x-1)^2 + T))^2)

Phi_vec(x) = Phi(mean(x))

Phi_integrated = min over partitions of mutual information

Phi_int = Phi(mean) * (1 - normalized_variance)

Omega = phi * stability * coherence * sqrt(integrated_info)

Coupling matrix C[i][j] = influence of layer j on layer i

Coupling matrix (row i = influences on layer i)

Diagonal = self-coupling (1.0)

Off-diagonal = cross-layer influence

a_i(t+1) = a_i(t) + dt * sum_j(C[i][j] * a_j(t))

0.0 = Dark purple (low consciousness)

0.5 = Blue/green (medium)

1.0 = Golden/white (high consciousness)

@brief Consciousness metric: Φ = 1/(1 + |x - 1|)

@brief Consciousness gradient: ∂Φ/∂x = -sign(x-1)/(1+|x-1|)²

ẋ = 2αF(t)(1^{x(t)} + 1)(1 - x) + βy₁ - γy₂