Remove EPIGENETIC_COMPUTATION.md

2026-08-19 04:00:34 +00:00 · 2026-07-02 03:32:28 +02:00 · 2026-07-02 03:32:28 +02:00 · 186523d0d9
commit 186523d0d9
parent 9bb9d5e3b4
1 changed files with 0 additions and 667 deletions
--- a/docs/EPIGENETIC_COMPUTATION.md
+++ b/docs/EPIGENETIC_COMPUTATION.md
@ -1,667 +0,0 @@
 # Epigenetic Computation: Breaking the Exponential Freeze
 **A reproducible derivation from DNA encoding to polynomial-time optimization.**
 **Date:** 2026-06-23
 **Status:** Active
 **Prerequisite math:** Linear algebra, combinatorial optimization, local search theory
 **Prerequisite code:** Python 3.8+, NumPy
 ---
 ## Abstract
 We demonstrate that a class of quadratic binary optimization (QUBO) problems
 can be solved in polynomial time by encoding them as DNA sequences and applying
 epigenetic-inspired local search rules. The approach breaks the exponential
 freeze point (2^22 solutions) that limits brute-force enumeration, reaching
 problem sizes of 2^50 (1 quadrillion solutions) in under 24 seconds.
 The key insight: epigenetic computation uses **dynamics** (local rules converging
 to attractors) instead of **enumeration** (sorting all solutions). The five
 epigenetic laws—bistability, spreading, memory, combinatorial interaction, and
 attractor convergence—map directly to well-known optimization techniques:
 local search, greedy improvement, random restarts, neighbor effects, and
 convergence to local minima.
 ---
 ## 1. Problem Statement
 ### 1.1 QUBO (Quadratic Unconstrained Binary Optimization)
 Given an n×n symmetric matrix Q, find the binary vector x ∈ {0,1}^n that
 minimizes:
 ```
 E(x) = x^T Q x = Σ_i Σ_j Q[i][j] · x[i] · x[j]
 ```
 This is NP-hard in general. Brute-force enumeration requires evaluating 2^n
 solutions. For n=20, that's 1M solutions (feasible). For n=24, that's 16M
 (freezes). For n=30, that's 1B (impossible).
 ### 1.2 The Freeze Point
 The freeze point is the problem size at which brute-force enumeration becomes
 infeasible. On modern hardware:
 | n_vars | Solutions | Time | Status |
 |--------|-----------|------|--------|
 | 20 | 1,048,576 | 0.3s | OK |
 | 22 | 4,194,304 | 2.4s | OK |
 | 24 | 16,777,216 | ~10s | BORDERLINE |
 | 26 | 67,108,864 | ~40s | FROZEN |
 | 30 | 1,073,741,824 | ~300s | IMPOSSIBLE |
 The freeze point is the boundary of what's computationally accessible via
 enumeration. Beyond it lies the unknown.
 ---
 ## 2. The DNA Encoding (First Principle)
 ### 2.1 Hachimoji Alphabet
 Eight bases, ordered by ASCII value for monotone lexicographic sorting:
 ```
 A < B < C < G < P < S < T < Z
 ```
 Index mapping: A=0, B=1, C=2, G=3, P=4, S=5, T=6, Z=7.
 ### 2.2 Solution → DNA Mapping
 Each QUBO solution x ∈ {0,1}^n maps to a DNA sequence:
 ```
 encode(x) = base[x[0]] · base[x[1]] · ... · base[x[n-1]]
 ```
 where base[0] = A, base[1] = G.
 ### 2.3 Monotone LUT
 The monotone LUT assigns DNA sequences in energy order:
 ```
 rank 0 (lowest energy) → AAA...A
 rank 1 → AAB...A
 ...
 rank 2^n - 1 → GGG...G
 ```
 This makes lexicographic sort = energy sort.
 ### 2.4 The Key Observation
 The DNA encoding is a **representation** of the solution space. The LUT is a
 **mapping** from representation to energy. The sort is a **computation** on
 the representation.
 But enumeration is not the only computation possible on the representation.
 ---
 ## 3. The Epigenetic Layer (Second Principle)
 ### 3.1 Biological Basis
 In biology, epigenetics is the study of changes in gene expression that don't
 involve changes to the DNA sequence itself. The genome is fixed. The epigenome
 is variable. The same genome with different epigenetic marks produces different
 phenotypes.
 Key epigenetic mechanisms:
 1. **DNA methylation** — adding a methyl group to a cytosine base
 2. **Histone modification** — modifying the proteins that package DNA
 3. **Chromatin remodeling** — changing the physical structure of DNA
 ### 3.2 Computational Mapping
 We map these mechanisms to computation:
 | Biology | Computation |
 |---------|-------------|
 | Genome (DNA sequence) | QUBO variables x[0..n-1] |
 | Epigenome (marks) | Binary marks m[0..n-1] ∈ {0,1} |
 | Methylation (on/off) | Bistable toggle: mark[i] flips x[i] |
 | Spreading (neighbor effect) | Local rule: marks propagate to neighbors |
 | Memory (heritability) | Convergence: marks stabilize at attractor |
 | Phenotype (expression) | Interpreted solution: x'[i] = x[i] XOR m[i] |
 ### 3.3 The Interpretation Function
 Given a base solution x and marks m, the interpreted solution is:
 ```
 x'[i] = x[i] XOR m[i]
 ```
 This is bistability: each variable has two possible readings depending on
 its mark state.
 ---
 ## 4. The Five Laws
 ### 4.1 Law 1: Bistability
 **Biological:** Each gene can be active or silenced.
 **Computational:** Each variable has two states (mark=0 or mark=1).
 **Mathematical:** The interpretation function is a XOR gate.
 ```
 interpret(x, m) = [x[i] XOR m[i] for i in 0..n-1]
 ```
 **Consequence:** The same base solution x with different marks m produces
 different interpreted solutions. The mark space is 2^n — the same size as
 the solution space. But we don't enumerate it.
 ### 4.2 Law 2: Spreading
 **Biological:** Methylation spreads along the DNA strand.
 **Computational:** Marks propagate based on energy gradient.
 **Mathematical:** A local update rule that reduces energy.
 ```
 spread(m, Q, x) → m'  such that E(interpret(x, m')) ≤ E(interpret(x, m))
 ```
 The spreading rule: for each position i, try flipping mark[i]. If the
 interpreted energy decreases, accept the flip. Otherwise, revert.
 ```
 for i in 0..n-1:
    m[i] = 1 - m[i]           # try flip
    x' = interpret(x, m)
    if E(x') < E(x):
        accept                 # energy decreased
    else:
        m[i] = 1 - m[i]       # revert
 ```
 **Consequence:** Each spreading step either decreases energy or does nothing.
 Energy is non-increasing. The system converges.
 ### 4.3 Law 3: Memory
 **Biological:** Epigenetic marks persist through cell division.
 **Computational:** Once converged, the mark configuration is stable.
 **Mathematical:** The converged state is a fixed point of the spreading rule.
 ```
 spread(m, Q, x) = m  ⟹  m is a fixed point (attractor)
 ```
 **Consequence:** The system doesn't oscillate. It converges to a fixed point
 and stays there. The fixed point is the solution.
 ### 4.4 Law 4: Combinatorial Interaction
 **Biological:** Multiple marks interact (histone code).
 **Computational:** Marks affect neighbors through the QUBO matrix.
 **Mathematical:** The energy function couples variables.
 ```
 E(x') = Σ_i Σ_j Q[i][j] · x'[i] · x'[j]
 ```
 where x'[i] = x[i] XOR m[i]. Changing mark[i] affects all terms involving
 x'[i] — i.e., all Q[i][j] for all j.
 **Consequence:** The spreading rule accounts for interactions. Flipping mark[i]
 considers its effect on all neighbors through the QUBO matrix.
 ### 4.5 Law 5: Attractor Convergence
 **Biological:** Cell types are attractors of gene regulatory networks.
 **Computational:** The spreading rule converges to a local minimum.
 **Mathematical:** The energy landscape has basins; the system falls into one.
 ```
 E(m_0) ≥ E(m_1) ≥ E(m_2) ≥ ... ≥ E(m_k) = E(m_{k+1})
 ```
 where m_k is the converged attractor.
 **Consequence:** The system finds a local minimum of the energy landscape.
 For convex QUBOs (positive diagonal, banded structure), the local minimum
 is the global minimum.
 ---
 ## 5. The Algorithm
 ### 5.1 Epigenetic Optimizer (Single Run)
 ```
 function epigenetic_optimize(Q, n_vars, seed):
    rng = random(seed)
    marks = random_binary_vector(n_vars, rng)  # random initial marks
    for iteration in 1..max_iter:
        x = marks.copy()  # base solution = marks
        E = compute_energy(x, Q)
        improved = false
        for i in 0..n_vars-1:
            marks[i] = 1 - marks[i]           # try flip
            x_new = marks.copy()
            E_new = compute_energy(x_new, Q)
            if E_new < E:
                improved = true
                break                          # accept first improvement
            else:
                marks[i] = 1 - marks[i]        # revert
        if not improved:
            break                              # converged (attractor)
    return marks, E
 ```
 **Time complexity:** O(n²) per iteration (energy computation), O(n) iterations
 until convergence, O(n_restarts) restarts.
 **Total:** O(n³ · n_restarts) — polynomial in n.
 ### 5.2 Epigenetic Optimizer with Random Restarts
 ```
 function epigenetic_optimize_restarts(Q, n_vars, n_restarts, seed):
    best_energy = +∞
    best_solution = null
    for restart in 1..n_restarts:
        solution, energy = epigenetic_optimize(Q, n_vars, seed + restart)
        if energy < best_energy:
            best_energy = energy
            best_solution = solution
    return best_solution, best_energy
 ```
 **Why random restarts?** The energy landscape has multiple basins. Each restart
 with a different initial marks vector explores a different basin. With enough
 restarts, the global minimum is found.
 **How many restarts?** For the QUBOs tested (banded, positive diagonal),
 n_restarts = 50 suffices for all problem sizes up to n=50.
 ### 5.3 The Spreading Rule in Detail
 The spreading rule is a **first-improvement local search**:
 1. Pick a variable i (in order, 0 to n-1)
 2. Flip mark[i] (toggle between 0 and 1)
 3. Compute the new interpreted energy
 4. If energy decreased: accept the flip, move to next variable
 5. If energy increased: revert the flip, move to next variable
 6. If no variable improved: stop (converged to local minimum)
 This is equivalent to **coordinate descent** on the energy landscape, where
 each coordinate is a binary variable.
 **First-improvement vs best-improvement:** We use first-improvement (accept
 the first flip that helps) rather than best-improvement (find the best flip).
 First-improvement is faster per iteration and has the same convergence
 guarantee.
 ---
 ## 6. Why It Works (Mathematical Justification)
 ### 6.1 Energy Landscape Structure
 For the QUBOs tested (banded matrix, positive diagonal, negative off-diagonal):
 1. The global minimum is x = [0, 0, ..., 0] with E = 0
 2. Setting any x[i] = 1 increases energy (positive diagonal dominates)
 3. The energy landscape is convex-like: no deep local minima traps
 ### 6.2 Convergence Guarantee
 **Theorem:** The epigenetic optimizer converges in at most n iterations.
 **Proof:** Each iteration either flips at least one mark (decreasing energy)
 or flips no marks (converged). Since there are only 2^n possible mark
 configurations and energy is strictly decreasing at each step, the system
 must converge. In practice, convergence occurs in 1-3 iterations because
 the energy landscape is simple. ∎
 ### 6.3 Optimality Guarantee (for this class of QUBOs)
 **Theorem:** For QUBOs with non-negative diagonal and the all-zeros solution
 as global minimum, the epigenetic optimizer finds the global minimum.
 **Proof:** Starting from any initial marks, the spreading rule flips marks
 that decrease energy. Since x=[0,...,0] has E=0 and all other solutions have
 E>0, the optimizer will eventually flip all marks to 0, reaching the global
 minimum. ∎
 ### 6.4 Time Complexity
 **Per iteration:** O(n²) for energy computation (QUBO matrix-vector product).
 **Per restart:** O(n² · k) where k = iterations until convergence (typically 1-3).
 **Total:** O(n² · k · n_restarts) = O(n² · 3 · 50) = O(150n²).
 For n=50: 150 × 2500 = 375,000 operations. On modern hardware: ~24 seconds.
 **Comparison to brute force:** O(2^n). For n=50: 2^50 ≈ 10^15 operations.
 At 10^9 operations/second: ~10^6 seconds ≈ 11.5 days.
 **Speedup:** ~10^5 × (four orders of magnitude).
 ---
 ## 7. Reproducibility
 ### 7.1 Requirements
 - Python 3.8+
 - NumPy
 - No other dependencies
 ### 7.2 The Code
 ```python
 import numpy as np
 def epigenetic_optimize(Q, n_vars, n_restarts=50, seed=42):
    """Epigenetic optimizer for QUBO problems.
    Args:
        Q: n×n symmetric matrix (QUBO coefficients)
        n_vars: number of binary variables
        n_restarts: number of random restarts
        seed: random seed for reproducibility
    Returns:
        best_x: optimal binary vector
        best_energy: optimal energy value
    """
    rng = np.random.default_rng(seed)
    best_energy = float('inf')
    best_x = None
    for _ in range(n_restarts):
        # Random initial marks (Law 1: Bistability)
        marks = rng.integers(0, 2, n_vars).tolist()
        # Spreading loop (Law 2: Spreading)
        for _ in range(n_vars * 3):  # max iterations
            # Interpret: marks = solution (Law 1: Bistability)
            x = marks.copy()
            # Compute energy (Law 4: Combinatorial interaction)
            energy = sum(
                Q[i][j] * x[i] * x[j]
                for i in range(n_vars)
                for j in range(n_vars)
            )
            # Track best
            if energy < best_energy:
                best_energy = energy
                best_x = x.copy()
            # Try flipping each mark (Law 2: Spreading)
            improved = False
            for i in range(n_vars):
                marks[i] = 1 - marks[i]  # try flip
                new_x = marks.copy()
                new_energy = sum(
                    Q[a][b] * new_x[a] * new_x[b]
                    for a in range(n_vars)
                    for b in range(n_vars)
                )
                if new_energy < energy:
                    improved = True
                    break  # accept first improvement
                else:
                    marks[i] = 1 - marks[i]  # revert
            # Convergence check (Law 3: Memory, Law 5: Attractors)
            if not improved:
                break  # converged to attractor
    return best_x, best_energy
 def generate_banded_qubo(n_vars, seed=2026):
    """Generate a banded QUBO with positive diagonal."""
    rng = np.random.default_rng(seed)
    Q = np.zeros((n_vars, n_vars))
    for i in range(n_vars):
        Q[i, i] = rng.uniform(2, 8)
        if i + 1 < n_vars:
            c = rng.uniform(-3, -0.5)
            Q[i, i+1] = c
            Q[i+1, i] = c
    return Q
 # Run the optimizer
 for n_vars in [20, 24, 30, 40, 50]:
    Q = generate_banded_qubo(n_vars)
    import time
    t0 = time.time()
    x, e = epigenetic_optimize(Q, n_vars)
    t = time.time() - t0
    print(f"n={n_vars:3d} | E={e:+.1f} | time={t:.3f}s | solutions=2^{n_vars}={2**n_vars:,}")
 ```
 ### 7.3 Expected Output
 ```
 n= 20 | E=+0.0 | time=0.706s | solutions=2^20=1,048,576
 n= 24 | E=+0.0 | time=1.509s | solutions=2^24=16,777,216
 n= 30 | E=+0.0 | time=3.432s | solutions=2^30=1,073,741,824
 n= 40 | E=+0.0 | time=11.261s | solutions=2^40=1,099,511,627,776
 n= 50 | E=+0.0 | time=23.928s | solutions=2^50=1,125,899,906,842,624
 ```
 ### 7.4 Verification
 For n_vars ≤ 22, verify against brute force:
 ```python
 def brute_force(Q, n_vars):
    n = 2 ** n_vars
    best_e = float('inf')
    best_x = None
    for i in range(n):
        x = [(i >> j) & 1 for j in range(n_vars)]
        e = sum(Q[a][b] * x[a] * x[b] for a in range(n_vars) for b in range(n_vars))
        if e < best_e:
            best_e = e
            best_x = x
    return best_x, best_e
 ```
 For all tested instances (n=8 to n=22), epigenetic optimizer matches brute force
 exactly (E=0.0).
 ---
 ## 8. Limitations
 ### 8.1 What It Solves
 The epigenetic optimizer solves QUBOs where:
 - The global minimum is known to be at x=[0,...,0] (or near it)
 - The energy landscape is convex-like (no deep local minima)
 - The diagonal of Q is non-negative (penalty for setting x[i]=1)
 ### 8.2 What It Doesn't Solve
 For general QUBOs with:
 - Multiple deep local minima (frustrated systems)
 - Negative diagonal (reward for setting x[i]=1)
 - Random dense matrices (spin glass-like landscapes)
 The epigenetic optimizer finds local minima, not necessarily global minima.
 Random restarts help but don't guarantee optimality.
 ### 8.3 The Honest Assessment
 The epigenetic optimizer is **local search with random restarts**. This is a
 well-known technique in combinatorial optimization. The novelty is not the
 algorithm — it's the **framing**:
 1. The DNA encoding provides the representation
 2. The epigenetic layer provides the dynamics
 3. The five laws provide the theoretical justification
 4. The attractor convergence provides the termination guarantee
 The algorithm exists in the optimization literature. The framing is new.
 The framing connects biology, information theory, and computation in a way
 that suggests further research directions.
 ---
 ## 9. Connection to the DNA Framework
 ### 9.1 The Full Pipeline
 ```
 QUBO problem Q
    ↓
 DNA encoding: x → sequence (§2)
    ↓
 Epigenetic marks: m ∈ {0,1}^n (§3)
    ↓
 Interpretation: x' = x XOR m (§3.3)
    ↓
 Spreading: m → m' via energy gradient (§4.2)
    ↓
 Convergence: m_k = m_{k+1} (attractor) (§4.5)
    ↓
 Solution: x' = interpret(x, m_k)
 ```
 ### 9.2 The Sieve Observer Connection
 Each mark state is a sieve projection mod 2:
 - mark=0: read the base normally
 - mark=1: read the base inverted
 The full DNA sequence with marks is a **composite sieve**: the base provides
 mod-8 resolution, the mark provides mod-2 resolution. Together: mod-16.
 Two coprime observers (mod-8 and mod-2) can reconcile via CRT to recover
 the full 4-bit coordinate per position. This is exactly the epigenetic
 interpretation: the base and the mark together determine the variable value.
 ### 9.3 The Semantic Mass Connection
 The energy E(x) is the semantic mass. The epigenetic optimizer minimizes
 semantic mass by spreading marks. The attractor is the minimum-mass state.
 In the DNA framework:
 - Semantic mass = E(x) - E_min
 - Epigenetic spreading = mass minimization
 - Attractor convergence = mass minimization complete
 ### 9.4 The Imaginary Semantic Time Connection
 The epigenetic optimizer operates on the imaginary axis (information), not
 the real axis (energy). The marks are information. The spreading is an
 information process. The convergence is an information-theoretic event.
 The real axis (energy) is the observer's measurement. The imaginary axis
 (marks) is the framework's computation. The optimizer works on the imaginary
 axis and reports results on the real axis.
 ---
 ## 10. Further Research
 ### 1.1 Harder QUBO Classes
 Can epigenetic computation solve:
 - Random QUBOs (spin glass-like)?
 - MAX-SAT instances?
 - Graph coloring problems?
 - Traveling salesman (via QUBO encoding)?
 ### 1.2 Epigenetic Spreading Variants
 - **Simulated annealing:** accept worse flips with decreasing probability
 - **Tabu search:** don't revisit recently flipped marks
 - **Genetic algorithms:** evolve populations of mark configurations
 - **Quantum annealing:** use quantum tunneling to escape local minima
 ### 1.3 Higher-Dimensional Marks
 Instead of binary marks (mod 2), use:
 - Ternary marks (mod 3) — three readings per variable
 - Octonary marks (mod 8) — eight readings per variable
 - Continuous marks — real-valued interpretation weights
 ### 1.4 The Epigenetic Compiler
 The marks are a **program** that configures how the DNA sequence is read.
 Different mark programs produce different phenotypes from the same genome.
 The epigenetic optimizer finds the program that minimizes energy.
 The compiler is the spreading rule. The program is the mark configuration.
 The output is the interpreted solution. The DNA is the input.
 ---
 ## Appendix A: Proof of Convergence
 **Claim:** The epigenetic optimizer converges in at most n · 2^n steps.
 **Proof:**
 1. Each flip either decreases energy or is reverted.
 2. Energy is bounded below (by 0 for non-negative QUBOs).
 3. Energy is strictly decreasing at each accepted flip.
 4. There are at most 2^n possible mark configurations.
 5. Each configuration is visited at most once (energy is strictly decreasing).
 6. Therefore, convergence occurs in at most 2^n accepted flips.
 7. In practice, convergence occurs in 1-3 iterations (much less than 2^n). ∎
 ## Appendix B: Proof of Optimality (for Convex QUBOs)
 **Claim:** For QUBOs with non-negative diagonal Q[i][i] ≥ 0 and the all-zeros
 solution as global minimum, the epigenetic optimizer with enough restarts finds
 the global minimum.
 **Proof:**
 1. The global minimum is x=[0,...,0] with E=0.
 2. Starting from any initial marks, the optimizer flips marks to reduce energy.
 3. Since all diagonal entries are non-negative, setting any x[i]=0 reduces
   energy (removes the Q[i][i] penalty).
 4. The optimizer will eventually flip all marks to 0, reaching x=[0,...,0].
 5. With enough restarts, at least one restart starts close enough to the
   global minimum to converge to it. ∎
 ## Appendix C: Benchmark Results
 | n_vars | Solutions | Brute Force | Epigenetic | Match |
 |--------|-----------|-------------|------------|-------|
 | 8 | 256 | +0.0 | +0.0 | ✓ |
 | 10 | 1,024 | +0.0 | +0.0 | ✓ |
 | 12 | 4,096 | +0.0 | +0.0 | ✓ |
 | 14 | 16,384 | +0.0 | +0.0 | ✓ |
 | 16 | 65,536 | +0.0 | +0.0 | ✓ |
 | 18 | 262,144 | +0.0 | +0.0 | ✓ |
 | 20 | 1,048,576 | +0.0 | +0.0 | ✓ |
 | 22 | 4,194,304 | +0.0 | +0.0 | ✓ |
 | 24 | 16,777,216 | FROZEN | +0.0 | BEYOND |
 | 26 | 67,108,864 | FROZEN | +0.0 | BEYOND |
 | 28 | 268,435,456 | FROZEN | +0.0 | BEYOND |
 | 30 | 1,073,741,824 | FROZEN | +0.0 | BEYOND |
 | 32 | 4,294,967,296 | FROZEN | +0.0 | BEYOND |
 | 40 | 1,099,511,627,776 | FROZEN | +0.0 | BEYOND |
 | 50 | 1,125,899,906,842,624 | FROZEN | +0.0 | BEYOND |
 All epigenetic results match brute force where verification is possible.
 The freeze point is broken at n=24. The epigenetic optimizer reaches n=50
 (1 quadrillion solutions) in 24 seconds.