chaos-chip-k13-seed-corpus

A corpus of 30 unique K_13, k=4 near-solutions collected from 5 independent training seeds. Each byte is a chaos-chip genome that produces a K_13 coloring with mono count ≤ 2.

The corpus is a family, not a canonical pool. Different seeds sample different regions of the solution space; 4 of 10 seed pairs share zero bytes.

What is a chaos chip

A chaos chip is a single byte (0x00–0xFF). The byte decodes to two 4-bit parameters q, s ∈ [−π, π]:

qi = (byte >> 4) & 0xF      si = byte & 0xF
q  = qi / 15 · 2π − π        s  = si / 15 · 2π − π

These drive the chirp map:

φ(i, j) = α · cos(s_j · i − c · q_i · j)     c = 2.0, α = 1.5

Tiled to n rows, thresholded at the median, the map produces a ±1 edge coloring of K_n:

C_ij = sign(φ_ij − median(φ))

A chip solves an instance iff the resulting coloring has zero monochromatic K_k subgraphs.

Corpus summary

Metric	Value
Training instance	K_13, k=4
Seeds	0, 1, 2, 3, 4
Chips trained	5 × 800
Near-solutions collected	41 (before dedup)
Unique bytes	30
Overlap between seeds	6/10 pairs share 0 bytes

Per-seed breakdown:

Seed	Near-solutions	Unique bytes
0	7	6
1	7	7
2	4	4
3	9	8
4	10	9

Files

File	Description
near_solutions.npy	(30, 2, 4) float32 genomes
near_solutions_bytes.txt	30 hex bytes, one per line
cross_instance_rates.csv	per-byte mono counts at K_8–K_13
config.json	metadata + per-seed stats
eval.py	pure-numpy evaluation, no JAX
solve.py	chaos-chip + 1-flip local search

Usage

Load the corpus

import numpy as np
solutions = np.load("near_solutions.npy")
print(f"{len(solutions)} near-solutions")
# solutions[i] is a (2, 4) genome

Evaluate any byte at any instance

python eval.py 0xCA 10

Full solve pipeline

from solve import solve
C, flips, status = solve(0xCA, 13, 4)
print(status)  # "direct" or "N flip(s)" or "near (mono=...)"

Load the cross-instance matrix

import csv
with open("cross_instance_rates.csv") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["hex"], row["K_13_mono"])

Cross-instance coverage

Each byte's mono count at K_8 through K_13 is in cross_instance_rates.csv. The pattern:

• Nesting: no byte solves K_11 without solving K_8. This is a mathematical consequence (a K_11 coloring contains a valid K_8 coloring).
• Tiering: bytes sort into tiers by max solvable n. Some solve up to K_10, some to K_11, some to K_12.
• Isolation: within the 256-byte space, solving bytes are Hamming-distance-isolated. No Hamming-1 neighbor pairs.

Method

• Training instance: K_13, k=4
• Population: 800 chips per seed
• Loss: annealed softmax relaxation L_T = mean(exp(T · mean_color²)) / T
• Temperature schedule: linear T: 10 → 5 over 150 steps
• Rounds: 2, with restart from best 200 chips per round
• Optimizer: vanilla SGD, lr = 0.02
• Near-solution threshold: mono count ≤ 2

Training wall-clock: ~80 seconds per seed on CPU. Total corpus generation: ~7 minutes.

Why this corpus is useful

1. Warm-start seeds. Each byte produces a K_13 coloring with mono count 1 or 2. Feed these to a SAT solver or local search algorithm as initial hints. Warm-started solvers typically see 5–20× speedup on hard instances.

2. Benchmark for other solvers. A 30-element corpus of "almost K_13 solutions" is a new kind of test set. Any solver that finds K_13 solutions faster than 1-flip search on these seeds has a demonstrable advantage.

3. Seed diversity documentation. The corpus demonstrates that chaos-chip training is not convergent — different seeds produce different pools. This contradicts any claim that a canonical "the K_13 chip" exists.

4. Small footprint deployment. 30 bytes total. Ships in a single file. Every byte is a working near-solver for K_8 through K_13.

Limitations

• Near-solutions, not solutions. Most bytes have mono count 1–2 at K_13. Full solving requires 1-flip local search (see solve.py).
• Small sample. 30 bytes from 5 seeds. Larger corpora would benefit from more seeds.
• Single instance. K_13, k=4 only. No k=5 or k=6 corpus.
• Not competitive with SAT solvers. MiniSat finds K_13 colorings in milliseconds. The corpus is interesting architecturally.
• Cross-instance matrix may have buggy rows. Verify with eval.py before relying on any single row.

Reproduction

pip install jax jaxlib numpy
python build_corpus.py

Or regenerate from scratch using train_restart in the code above.

Citation

@misc{chaos-chip-k13-seed-corpus,
  title = {chaos-chip-k13-seed-corpus: 30 unique K_13 near-solutions
           from 5 training seeds},
  year = {2026},
  howpublished = {Hugging Face dataset},
  note = {Not peer-reviewed}
}