POLER-Quantum-RS

.poler / .pqw — POLER Quantum Weights + POLER Quantum Core. Бинарный формат фазовых весов POLER[Ψ] и вычислительное ядро на Rust — экосистема POLER-Quantum. Кирпичи RQ1, RQ3, RQ4, RQ5, RQ6 из rust-core-roadmap.md: контейнер состояния (pqw), statevector-движок с Born-сэмплированием (pqc), zero-storage стриминг, χ²-паритет с Qiskit, петля фазового обучения Born и движок потокового Active Inference.

Оба крейта собираются без единой внешней зависимости — ни serde, ни memmap2, ни faer, ни rand: SHA-256 (FIPS 180-4), FNV-1a64, mmap, xoshiro256++, HTTP-клиент и SIMD-ядра реализованы внутри, финальный бинарник автономен и воспроизводим.

Почему не GGUF / SafeTensors / .pt

Критерий	Обычные форматы	.poler / .pqw
Хранение весов	INT4/INT8-сетки + scale-множители на блок	фазовые триты {−1, 0, +1} + 6-битная кривизна σ
Загрузка в память	пошаговое чтение и распаковка в RAM	zero-copy mmap: файл = память, «instant cold start»
Сжатие	фиксированная битность на всю матрицу	sparse LENS: дуги с |p| < ε не хранятся вовсе
Аппаратная адаптация	требует FP32/FP16 FMA-умножителей	multiplier-less: трит = знак, σ/63 — shift-and-add
Контроль шума	ошибки квантования накапливаются	McWeeny-инвариант P² = P вшит в заголовок

Формат v1 — байтовая карта

0x00   8    magic "POLER_QW"
0x08   4    format_version (u32 LE, = 1)
0x0C   4    d_pol (u32 LE)
0x10   16   гиперпараметры: eta, gamma, rho, epsilon_threshold (f32 LE × 4)
0x20   8    McWeeny: max |λ² − λ| по хранимым дугам (f64 LE)
0x28   24   payload digest: SHA-256(topology ‖ phases), усечённый до 24 байт
0x40   64   таблица смещений: topology/phase offset+len, nnz, flags,
             reserved (= 0), header checksum (FNV-1a64 по 0x00..0x78)
0x80   ...  sparse LENS-топология: nnz × u16 (d_pol ≤ 65536) или nnz × u32 LE
       ...  фазовые блоки: 1 байт на дугу —
             биты 0..1: трит {−1, 0, +1}; биты 2..7: кривизна σ ∈ [0, 63]
EOF

Декодирование дуги: p̂ = trit · (σ / 63), фазовый угол θ̂ = arccos(p̂) — готовый угол для анзаца Ry(arccos p). Граница ошибки квантования |p̂ − p| ≤ 1/126. Полная спецификация — docs/pqw-format.md.

Формат v2 (v0.2.0) — Packed4: 4 трита на байт

Плотный тритовый снимок для сошедшихся/обученных состояний: magic POLER_Q2, топологии нет, фазовые блоки — ceil(d_pol/4) байтов (0b00 → 0, 0b01 → +1, 0b10 → −1, 0b11 → Reserved, пары в LE-порядке). Ровно 4x сжатие фазовых блоков относительно v1 (d = 65536 → 16 КиБ); для плотного тритового состояния файл целиком мельчает ≥ 8x (4096 дуг: 12 416 → 1152 байта). Читатель понимает все поколения; sparse-семантика v2 эквивалентна v1 (Zero ≡ фон ≡ монета).

# use pqw::PqwWriter;
let bytes = PqwWriter::new(4096)?
    .add_state(&dense_trit_state)?   // |p| ≥ 0.5 → ±1, иначе фон Zero
    .to_bytes_packed()?;             // magic POLER_Q2, 128 + 1024 байта
# Ok::<(), pqw::PqwError>(())

Формат v3 (v0.3.4) — POLER_Q3: фазы + гироскоп J = A − Aᵀ

Топологическая секция (пустая в v2) заполняется кососимметричным резонансным оператором J = A − Aᵀ: направленная циркуляция смысла между дугами. Фазы — те же Packed4, гироскопная секция следует за ними: 32 B служебных (окно W, счётчик тактов t, масштаб) + пары верхнего треугольника по 5 байт (u16 + u16 + i8-вес; d_pol ≤ 65536). reserved-слово заголовка хранит счётчик тактов, флаг GYRO обязателен, digest покрывает фазы + гироскоп. Полная спецификация — docs/pqw-format.md §13.

Быстрый старт

use pqw::{PqwReader, PqwWriter, Mmap};
use std::path::Path;

// Запись: явные дуги или плотное состояние с LENS-фильтром |p| ≥ ε
let mut w = PqwWriter::new(4096)?;
w.hyperparams(0.01, 0.1, 0.99, 0.05);
w.add_phase(7, 0.5)?;              // явная дуга — LENS не фильтрует
// w.add_state(&dense_state)?;     // плотный режим: |p| < ε не попадёт в файл
w.write_to("state.poler")?;

// Чтение: zero-copy mmap (unix), без распаковки
let map = Mmap::open(Path::new("state.poler"))?;
let r = PqwReader::from_bytes(map.as_slice())?;
for (index, p) in r.decoded() {
    // (index, p̂) — срезы заимствованы напрямую из отображения файла
}
r.verify_payload()?;               // digest payload — опционально и лениво

McWeeny-инвариант

Трит — предельная точка потока очистки P_new = 3P² − 2P³ (McWeeny, 1960): кубит с треком p имеет собственное значение λ = (1+p)/2, и один шаг потока λ' = 3λ² − 2λ³ стягивает сильные треки к чистым фазам ±1 за 1–2 такта. Записанный в заголовок max |λ² − λ| измеряет отклонение от идемпотентности P² = P на момент записи; API восстанавливает инвариант на лету:

let purified = reader.purified();          // 2 шага: 0.9 → 0.9997
let deep = reader.purify_steps(5);         // глубокая очистка при необходимости
let residual = reader.mcweeny_residual();  // подпись из заголовка

Zero-storage стриминг (v0.1.2, RQ3)

Text Chunk ──ε-density──▶ Sparse Graph ──in-memory .pqw──▶ pqc::Ansatz ──Born──▶ QCM

Сквозной конвейер без единого обращения к диску: текстовый чанк кодируется в фазовое состояние (Unicode-токены → FNV-1a64 → ε-плотность LENS), собирается в контейнер .pqw прямо в RAM (write_to_vec), валидируется zero-copy (from_bytes) и немедленно превращается в Born-выстрелы и метрику когерентности QCM = 1 − Σ h₂(P(b_q=1))/d_pol. d = 512: ~105 мкс на сквозной прогон (бюджет RQ3 — 2 мс).

use pqc::stream::ZeroStoragePipeline;
use pqc::Rng;

let pipe = ZeroStoragePipeline::new(512, 0.2)?.with_shots(256);
let mut rng = Rng::seed_from_u64(42);
let report = pipe.run("текстовый чанк…", &mut rng)?;
println!("nnz={}, QCM={:.4}", report.nnz, report.coherence.qcm_theory);

Петля фазового обучения Born (v0.2.0, RQ5)

pqc::learn::BornOptimizer — замкнутый цикл «измерение → градиент → фазовый шаг» без Python/PyTorch/Qiskit: Born-выстрелы дают несмещённую оценку параметра p_emp = 1 − 2·N₁/N, градиент по фазе — параметрический сдвиг ∇_θ = −√(1−p²)·∇_p, шаг — тяжёлый шар с проектором причинности Π_Λ и McWeeny-пурификацией каждые K шагов:

# use pqc::{Ansatz, BornOptimizer, LoadOptions, quadratic_target};
let target = vec![0.9, -0.9, 0.8, -0.8];
let mut ansatz = Ansatz::from_phases(&[0.1, -0.1, 0.2, -0.2],
                                     &LoadOptions::default())?;
let mut opt = BornOptimizer::new(0.25, 0.9, 4096).with_seed(42);
opt.run(&mut ansatz, quadratic_target(&target), 10)?;  // сходимость
# Ok::<(), pqc::PqcError>(())

Сходимость за ≤ 10 шагов на обоих движках (product d=512: ↓ в 32×), отслеживание regime-jump'ов (γ ≈ 0.5), пурификация до чистых тритов (residual < 1e−6), побитовая воспроизводимость при фиксированном сиде. Стоимость шага: d=512 — ~2 мс, d=4096 — ~16 мс (1024 выстрела).

Zero-Storage Streaming Learning Engine (v0.3.0, RQ6 — Active Inference)

Веб-текст/HTML ──strip_html──▶ TF-IDF ε-плотность ──▶ LENS-CSR
      ──▶ Packed4 (реюз буфера, RAM) ──▶ коммутатор [F, DM]_S
      ──▶ ActiveInference: η(t) = η₀·e^(−βΣ) Born-шаг ──▶ QCM

pqc::stream_engine::StreamEngine — монолитный цикл непрерывного фазового инференса и потокового обучения целиком в RAM: TF-IDF ε-плотность (idf давит сквозной шум потока, отличительные токены усиливаются), LENS-дуги сериализуются в сверхплотный контейнер Packed4 в переиспользуемом буфере (после прогрева — ноль системных аллокаций), семантический коммутатор Фокиана измеряет «закрутку» свежего свидетельства против памяти (ровно нуль при NO_HITS — детерминированный отказ без галлюцинаций), а петля ActiveInference делает Born-фазовый шаг с адаптивным расписанием η(t) = η₀·exp(−β·Σ(t)) — сюрприз модели сжимает шаг в хаосе и возвращает полную скорость у стационара (уравнение субъективного времени T = dI/dΣ).

# use pqc::stream_engine::StreamEngine;
let mut engine = StreamEngine::new(512, 0.2, 42)?;
let rep = engine.ingest("фазовый континуум фазовый триты", 3)?;
assert_eq!(rep.container_bytes, 0x80 + 512 / 4);  // Packed4 в RAM
let empty = engine.ingest("… — !!!", 0)?;          // барьер NO_HITS
assert!(empty.no_hits && empty.fock.normalized == 0.0);
# Ok::<(), pqc::PqcError>(())

Замеры (release): сквозной ingest d=512 — ~0.32 мс (DoD 5 мс), QCM + коммутатор — ~50 мкс (бюджет 150 мкс), throughput ~1.36M токенов/с; честный FLOPs-отчёт против плотного self-attention — ~1218× дешевле на том же чанке (examples/active_inference_bench.rs).

Энтанглмент LENS и паритет с Qiskit (v0.1.2, шаг 3 + RQ4)

• Entanglement::FromTopology — соседние LENS-дуги контейнера разворачиваются в CX/CZ-рёбра: координаты внимания связываются без материализации плотной матрицы N×N. Product-движок сэмплирует запутанное распределение точно через GF(2)-распространение (префиксный XOR): выстрел остаётся O(nnz + d/64).
• χ²-паритет с Qiskit: ParityAnsatz — зеркало poler_quantum.quantum.ansatz.PolerAnsatz (режимы A/B/C, CX/CZ-цепь, адаптивная R_z-стабилизация). Кросс-тест: 56 конфигураций × 100 000 выстрелов на фиксированных сидах {42, 1337, 2026}: амплитуды совпадают до 1.1e-16, χ²-агрегаты режимов A/B/C — p = 0.42 / 0.03 / 0.49 (семейный критерий Бонферрони α′ = 0.05/3; контроль numpy: для идеального сэмплера ~5% конфигураций закономерно ниже 0.05). Подробности: docs/quantum-core.md §10–11.

Вычислительное ядро pqc (v0.1.1, RQ1)

Statevector-движок с анзацем R_y(arccos p) и Born-сэмплированием поверх контейнера — полностью независимый исполняемый бинарник без Python и Qiskit. Ключевое тождество: собственное значение McWeeny λ = (1+p)/2 — это P(b = 0), а P(b = 1) = (1−p)/2; очистка McWeeny заостряет Born-распределение к детерминированным битам.

Движок	Условие	Память	Выстрел
Statevector	d_pol ≤ 20 (настраивается)	2^d_pol × 16 B	O(d_pol)
PhaseAnsatz	любое d_pol	O(nnz)	O(nnz + d_pol/64)

LENS-пропуски декодируются как честные монеты (фон), хранимые дуги — спайки; фоновый вес сэмплируется popcount-трюком (Binomial(64, ½) за одно случайное слово). Ядра авто-векторизуются (блочный обход пар (i, i + 2^q)), параллельность — детерминированный fork-join на std::thread без rayon.

use pqc::{Ansatz, LoadOptions, Rng};
use pqw::{PqwReader, PqwWriter};

let bytes = PqwWriter::new(12)?.add_phase(1, -1.0)?.to_bytes()?;
let reader = PqwReader::from_bytes(&bytes)?;
let ansatz = Ansatz::from_reader(&reader, &LoadOptions::default())?;
let mut rng = Rng::seed_from_u64(42);
let report = ansatz.sample(&mut rng, 1024, 8)?;   // Born: топ-K + маргиналы

Замеры (2 vCPU, release): анзац 2²⁰ амплитуд — 16 мс; 100k выстрелов — 13 мс; product-движок d=65536, 10k выстрелов — 45 мс. Полная спецификация — docs/quantum-core.md.

$ pqw gen state.poler 4096 512 --eps 0.05   # контейнер
$ pqc run state.poler --shots 4096          # Born-сэмплирование
engine    : product (d_pol=4096, nnz=477)
shots     : 4096  seed: 42  distinct: 189
hamming weight: mean 2044.19 (theory 2044.69)  var 962.54 (theory 982.37)

$ pqc demo --n 12                            # полный конвейер в памяти
engine    : statevector (12 qubits, 4096 amplitudes)
top-8 исходов:  |001110001110⟩  count 94  p̂=0.0229  P=0.0207

CLI

$ pqw gen state.poler 4096 512 --eps 0.05
generated state.poler
  d_pol = 4096, arcs requested = 512, stored after LENS (eps = 0.05) = 477
  file size = 1559 bytes = 128 header + 954 topology + 477 phase bytes

$ pqw info state.poler        # дамп заголовка: гиперпараметры, nnz, McWeeny, digest
$ pqw verify state.poler      # header checksum + payload digest → OK / FAIL
$ pqw dump state.poler --limit 5
     index  tri  sigma           p         theta
         0  -1     25   -0.396825      1.978852
         6  +1     63    1.000000      0.000000
        ...

$ pqc run state.poler --shots 8192 --purify 2 --verify --marginals
$ pqc demo --n 16 --seed 7                   # конвейер без файла
$ pqc stream --url http://example.com/page --dim 512 --shots 10000
$ pqc stream --file page.html --steps 8 --json
$ pqc stream --text "фазовый континуум триты" --dim 512 --out chunk.pqw
$ pqc train --corpus ~/corpus --epsilon 0.05 --block 8192 \
           --fingerprint cpu_phase_fingerprint.bin --out state.pqw
POLER Quantum Core — Dense LENS Trainer (RQ8)
corpus    : ~/corpus (531 файлов, 11.5 МиБ)
engine    : d_pol=4096, eps=0.05, block=8192 B, shots=20000, steps=10, seed=42
learned   : nnz_lens=2240 дуг (union support=2240), плотность 54.69% от d_pol=4096
POLER Quantum Core — Zero-Storage Streaming Engine (RQ6)
source    : --text (0.2 КиБ, text)
text      : 16 токенов, LENS eps=0.20
container : d_pol=512 nnz=15 256 B (Packed4 v0.2: 4 трита/байт, magic POLER_Q2)
buffer    : capacity 256 B (реюз, системных аллокаций после прогрева нет)
fock      : raw=0.0000 normalized=0.0000 (коммутатор [F, DM]_S свидетельство x память)
step 1    : surprise Sigma=1.0000  eta=0.0920  (eta0*e^(-beta*Sigma))
loss      : 0.008724 (9 шагов Active Inference, gamma=0.5)
qcm       : theory 0.0065  observed 0.0065  gap 0.0001  (256 выстрелов)
elapsed   : 17.995 мс (сквозной цикл в RAM, диск не затронут)

pqc stream принимает --url (zero-dep HTTP/1.1: редиректы, chunked, лимит 16 МиБ; https → сохранить страницу и передать --file), --file, --text или --stdin; флаги --dim/--epsilon/--shots/--steps/--seed/ --eta0/--beta/--gamma/--decay/--json/--out.

pqc inspect — чтение графов, бинарников и крипто-разведка (v0.3.1)

Инспекция любого файла: чем он является, есть ли внутри шифрование и какова полная логика данных. Контейнеры .pqw/.poler разбираются до побайтовой карты; файлы без заголовка, валидные как Packed4 (все 2-битные пары ≠ 0b11), декодируются как сырые тритовые пакеты:

$ pqc inspect cpu_phase_fingerprint.bin --graph
FORMAT
  kind       : raw-packed4 (candidate)
  d_pol      : 4096
  nnz        : 10 (8 × −1, 2 × +1), density 0.244%
CRYPTO RECON
  entropy    : 0.0984 / 8.0000 bits/byte
  chi2       : 256033.0 (uniform band 255 ± 352) — NOT uniform
  verdict    : structured — шифрования НЕТ, данные полностью читаемы
ARCS
     469  0x01d5  -1   p̂ = -1.0000  θ̂ = 3.1416
     ...
GRAPH (LENS: рёбра = соседние дуги u_k → u_k+1)
  nodes 10, edges 9, components 1, density 0.244%

$ pqc inspect state.pqw --all    # карта + hex + все дуги + граф + строки
$ pqc inspect blob.bin --json    # машинно-читаемый отчёт (zero-dep JSON)
$ pqc inspect state.pqw --dot lens.dot   # Graphviz: dot -Tsvg lens.dot

Детекция шифра — без ключа: энтропия ≈ 8 бит/байт + χ² в полосе равномерности + отсутствие сигнатур контейнеров → encrypted-like (структуры не видно); низкая энтропия → structured (читаемо); промежуток → compressed. Для .pqw: header checksum FNV-1a64, payload digest SHA-256 Trunc-24 (OK/FAIL), McWeeny-невязка записанная и пересчитанная по дугам.

pqc train — плотный LENS-граф и накопительная память (v0.3.2)

pqc stream создаёт движок на один вызов: память между запусками CLI не накапливается, а --out пишет контейнер последнего чанка. pqc train держит один движок на весь корпус: блоки (--block, по умолчанию 8 КиБ) льются подряд, дуги объединяются (union support), а снапшот сериализует именно накопленную память engine.model() — в чекпоинт .pqw и сырой Packed4-отпечаток --fingerprint (тот самый снимок фазовой памяти, как cpu_phase_fingerprint.bin). Снапшоты обновляются каждые --snapshot-every блоков — состояние файла можно мониторить на живую (pqc inspect, hexdump, radare2) прямо во время обучения.

Плотность регулируется порогом: ε=0.20 на микрочанках даёт ~10 дуг (разреженный фон), ε=0.05 на блоках 8 КиБ — сотни и тысячи дуг (кристаллическая решётка, насыщение ~55% d_pol на корпусе 11.5 МиБ).

pqc train --curriculum / --resume — фазовая сборка (v0.3.3)

Обучение — не слепая загрузка гигабайтов в одну кучу, а пошаговая фазовая сборка: микро-такты → морфемы → синтаксис → LENS-топология, на одном движке (память переносится между уровнями в RAM без потерь):

# расписание по умолчанию: 10 B → 128 B → 1 КиБ → 8 КиБ (LENS)
pqc train --corpus ~/corpus --curriculum --out brain.pqw

# кастомное расписание block:steps:shots:budget
pqc train --stdin --curriculum 16:1:512:4096,256:2:2048:0 \
          --out brain.pqw

# resume: продолжить мозг из чекпоинта (путь к терабайтам)
cat internet_stream.bin | pqc train --stdin \
          --resume brain.pqw --out brain.pqw

Разогрев L1–L3 строит 92% итогового support на доле процента данных (алфавит повторяется!), а --resume поднимает union support + знаки дуг из чекпоинта для следующей сессии: сессия → чекпоинт → resume → сессия... Мозг весит 1152 B независимо от объёма усвоенных данных (эксперимент: 3.7 МиБ корпуса + 4.85 МиБ Wikipedia → 3004 дуги, 73.3% d_pol, один связный граф, энтропия 6.23 бит/байт).

pqc train --gyro — гироскоп J = A − Aᵀ и Im(P) (v0.3.4)

Уровень 4: поверх фазовой памяти (что дуга думает) строится реляционная (куда дуга ведёт) — кососимметричный резонансный оператор J = A − Aᵀ в топологической секции контейнера v3 (POLER_Q3, до v0.3.4 секция была пуста):

# фазовая сборка + гироскоп — чекпоинт POLER_Q3
pqc train --corpus ~/corpus --curriculum --gyro --out brain.pqw

# resume: реляционная память переживает рестарт
cat stream.bin | pqc train --stdin --resume brain.pqw \
          --out brain.pqw --gyro

# моды Im(P): плоскости вращения смысла с λ и θ = arccos(p̂)
pqc inspect brain.pqw --modes 8

Токены потока — события «i раньше j»: окно W даёт знаковый вклад A[i→j] += s_i·s_j — O(W) на токен, без O(N²). J = A − Aᵀ отделяет циркуляцию смысла от ассоциации; ε-ворота хранят только |J| ≥ ε·max|J| (эксперимент: 170 074 сырых пар → 206 хранимых, 99.88% отсечено). Кососимметричная J имеет чисто мнимый спектр ±iλ: поток e^(−iηJ) унитарен — гироскоп не забывает, а вращает фазы. Резонансные моды (u_k, v_k) с угловыми скоростями λ_k извлекаются степенной итерацией на −J² с дефляцией; дуги моды получают углы Блоха θ = arccos(p̂) — фазовые векторы смысла Im(P).

Измерено (3.2 МиБ исходников + 2.8 МиБ resume): фазы идентичны прогону без гироскопа (отпечатки совпадают побайтово, +3.8% времени); такты 387 874 → 961 366 через рестарт; 6 МиБ смысла → 2639 B контейнера (2734 дуги + 291 пара циркуляции, ×2360) — бинарник весит копейки.

pqc train --quantized --gyro — слияние решётки с гироскопом: J в тритах + момент 2 бит + рассуждение L5 (v0.6.0, RQ16)

Вся кинетика памяти — в тритовых решётках, ноль HashMap на горячем пути (плотная индексация + битовые сдвиги, как в branch-предикторе). Три решётки: фазы (⌈d/4⌉ байт), насыщающий момент (⌈d/4⌉ байт) и русла J = A − Aᵀ (⌈d(d−1)/4⌉ байт — ниббл на пару: направление + насыщенность). --steps N — N квантованных шагов авторегрессионного рассуждения после born-шага: оператор p_{t+1} = Π_Λ(e^{Δt·J}·p_t) с точной таблицей синусов 3×3 (разность фаз решётки даёт sin ∈ {0,±1} — ноль FPU), моментными воротами (движется только пара с кинетическим концом — покоящаяся память не дрейфует) и Π_Λ-проекцией ближайшим тритом. Перещёлкнувшийся трит зажигает момент: волна кристаллизации идёт по руслам шаг за шагом и сходится к аттрактору ĤΨ = 0.

pqc train --quantized --gyro 32 --corpus docs --steps 2 \
          --out fused.pqw        # слияние: v3 = фазы + русла GYRO
pqc train --quantized --gyro 32 --corpus docs --resume fused.pqw

Физика русел — порог насыщения 2 события: покой → свежее русло (шум, наружу невидимо) → насыщенный канал J; встречное свидетельство снимает насыщенность, второе закрывает русло; разворот — только через покой, телепортации знака нет. Физика момента — гистерезис зажигание/срыв (τ_ign = 0.5 < τ_stall = 1.0): между порогами живёт инерция без затухания — момент не затирается при уходе свидетельства (у RQ15 скорость обнулялась вне носителя), слабое несогласие не гасит мысль. v = m·2.0 воспроизводит конверт RQ15 (η·v = 1.2 ≥ π/3 — выход из полюса, разворот за два шага через экватор); полюс, в который дует момент, поглощает его — выполненная инерция не пинает затвердевшее мнение.

Измерено (docs/, 22.7K токенов, d_pol=4096, W=32, debug): born кристаллизует 128 дуг, один шаг рассуждения расширяет кристалл до 1717 дуг (×13) — волна L5 генерирует знание за пределами свидетельства; 27190 насыщенных русел; чистое обучение 300 блоков/с, --steps 1 — 188, --steps 4 — 65 (скан русел — цена рассуждения); память движка: 1 КиБ фазы + 1 КиБ момент + 4 МиБ русла + 16 КиБ doc_freq. Чекпоинт v3 бит-в-бит: русла J переживают рестарт вместе с мнением (инерция — нет), повторный прогон не двигает ни одного трита.

pqc generate / pqc ask / pqc archetype — L5-речь и нелинейная алгебра архетипов ⊗_ε (v0.7.0–v0.8.0, RQ17–RQ18)

Разум заговорил и начал мыслить архетипами. RQ17 (v0.7.0) замкнул авторегрессионный цикл: pqc generate (Born-блуждание по руслам J, направление речи = синтаксис), pqc ask/pqc chat (диалог с памятью — вопрос и ответ кристаллизуются born-шагом, мозг дописывается на лету), формат v4 POLER_Q4 с лексиконом LEXI (координата → доминантный токен). RQ18 (v0.8.0) дал речи глубину: нелинейный оператор c = a ⊗_ε b = Π_Λ(R + ε·(a ∧ b)) — фазовая интерференция архетипов прямо в 2-битных тритах Packed4 (SWAR: конфликтные лейны Pos ⊕ Neg = 0b11 гасятся, согласие резонирует, суперпозиция прозрачна; клин a ∧ b стабилизирует Π_Λ-проекцию на полосе ε_w ∈ (0, ½]) + энергетический гейт E = co/min(nnz) ≥ ε (пересечение считается состоявшимся, только если меньшая структура разделяется большой). E < ε — архетипы ортогональны, произведение — весь нуль: ложных ассоциаций не существует. Инварианты: a ⊗_ε a = a бит-в-бит (0 галлюцинаций), ортогональность → Zero.

Три механизма в сборке:

• Мост внимания — при вопросе движок строит архетип промпта (TF-IDF → полюса знака) и вычисляет a ⊗_ε lattice: дуги пересечения зажигают момент (согласие — инерция полюса, конфликт — вызов памяти), фазы решётки неприкосновенны — внимание, а не знание (McWeeny-дисциплина: память меняет только born-шаг от свидетельства).
• Концептуальный прыжок в речи — уровень 3 born-лотереи (Flow → Backtrack → Archetype → Kinetic): прямые русла J иссякли — лотерея прыгает на дуги продукта; конфликт кричит весом 3, согласие говорит весом 2, прозрачная память (фон метафоры) шепчет весом 1. Тест-манифест: палиндромный корпус закрывает все русла J — первый квант речи приходит из моста.
• pqc archetype — интроспекция алгебры: мозг ⊗ промпт или мозг ⊗ мозг (--with): структурный изоморфизм двух знаний (энергия, согласие/конфликт, идемпотентный продукт либо честный Zero). В generate/ask мост включён по умолчанию (--no-bridge, --bridge-eps F).

Дымовой прогон (d=512): знакомый вопрос — E = 1.000 → РЕЗОНАНС, чужой домен — E = 0.000 → ЗАПЕРТ (Zero); generate: «мост ⊗_ε: энергия 1.000 ≥ 0.5 — резонанс: пересечение 2 дуг (согласие 2, конфликт 0)». 619 теста.

pqc learn — целенаправленный интернет-ингест (v0.9.0, RQ19)

Мозг подключён к живому интернету — и транспорт написан с нуля. pqc learn "квантовая механика" --brain brain.pqw принимает тему, ищет по ней страницы в Wikipedia API, точечно выкачивает чистый текст (explaintext — ноль HTML) и кристаллизует каждую страницу в решётку: TF-IDF → LENS-дуги → born_step_packed4 — русла J, лексикон LEXI и архетипические связи ⊗_ε расширяются автоматически. Сразу после обучения pqc ask отвечает выученными понятиями.

pqc learn "квантовая механика" --brain brain.pqw          # ru-раздел (кириллица)
pqc learn "Rust tokio" --brain brain.pqw --lang en        # en-раздел
pqc learn "теория всего" --brain brain.pqw --pages 8 --rounds 3 --full
pqc learn "тема" --brain b.pqw --text "текст страницы"    # offline, без сети
pqc ask "что такое квант" --brain brain.pqw               # инференс выученного

Zero-dep остаётся священным: TLS 1.3 (RFC 8446) реализован в крейте — SHA-256, HMAC, HKDF, ChaCha20, Poly1305, X25519 (все — с эталонными векторами RFC), key schedule сверен байт-в-байт с трассой RFC 8448; поверх — свой HTTP/1.1 (redirects, chunked, таймауты) и адаптер Wikipedia API. Anti-bot safe = легальный API вместо скрейпинга: честный User-Agent, паузы ≥ 300 мс, backoff на 403/429. Самоуправляемые раунды: модель сама уточняет запрос — топ-новое слово корпуса («квантовая механика» → «квантовая механика суперпозиция») — любопытство кристалла. Честная граница zero-dep: цепочка сертификатов не проверяется (нет корневого хранилища) — канал шифруется против пассивного прослушивания; для публичных знаний приемлемо, для секретов — нет.

pqc merge — архетипическое слияние мозгов ⊗_ε (v1.0.0, RQ20)

Два тела знания становятся одним кристаллом. pqc merge доводит физику RQ18 до записи: pqc archetype измерял произведение мозг ⊗ мозг — merge пишет его в контейнер. Мозг «Квантовая физика» + мозг «Python» → единый мозг, знающий оба домена и говорящий на стыке дисциплин.

pqc merge physics.pqw python.pqw --out merged.pqw
pqc merge a.pqw b.pqw --out m.pqw --ask "как моделировать запутанность на python"
pqc ask "что такое замыкание" --brain merged.pqw   # мульти-доменный инференс

Три этажа слияния (pqc::merge):

• Фазы c = a ⊗_ε b — та же таблица интерференции RQ18, но без запирающего гейта: прозрачность таблицы пропускает уникальное каждого мозга, согласие полюсов резонирует, встречные полюса аннигиляцией честно признаются открытым вопросом (Zero). Энергия E = co/min(nnz) остаётся диагностикой изоморфизма (--eps, default 0.5): E = 0.737 у двух книг одной саги — «глубокая общность»; E = 0.000 у физики и Python — «домены ортогональны, слияние всё равно объединяет».
• Русла J_merged = Π_Λ(J_A + J_B) — согласная циркуляция выживает, встречная гаснет, уникальная проходит прозрачностью; кососимметричность J[j][i] = −J[i][j] сохраняется по построению (верхний треугольник). Такты суммируются: слитый мозг видел оба потока опыта.
• Лексикон LEXI консолидируется в единый непротиворечивый словарь v4: A — база (коллизии доминант в пользу A), B заполняет пустые координаты.

Born-консолидация: продукт уже лежит на многообразии P² = P (идемпотентность c ⊗_ε c = c) — контейнер v4/v3/v2 пишется бит-в-бит без переквантования, детерминизм абсолютный (ни одного ГПСЧ). Слияние мозга с самим собой сохраняет знание бит-в-бит — удваиваются только такты. Целые романы не пугают конвейер: 133 КиБ «саги о маяке» → 1325 русел, 61 слово, мозг отвечает о героях; две книги саги → merge → слитый мозг говорит словами обеих.

pqc merge --settle + грамматические мосты — качество связной речи и консолидация мысли (v1.1.0, RQ21)

Облако ассоциаций становится предложением, а слияние — оседает в стационар ĤΨ = 0.

pqc merge qm.pqw qc.pqw --out m.pqw --settle        # 3 такта волны (ТЗ 2–4)
pqc merge a.pqw b.pqw --out m.pqw --settle 4 --ask "вопрос на стыке"
pqc ask "что такое запутанность" --brain brain.pqw  # синтаксис включён
pqc ask "..." --brain brain.pqw --no-syntax         # чистая топология RQ17

Сеттлинг (консолидация волной) — N тактов (default 3, максимум 16) авторегрессионного рассуждения Π_Λ(e^{Δt·J} p) поверх слитых русел. Такт = транспорт волной (контраст живёт на конфликтах ⊗_ε — открытых вопросах слияния) + born-консолидация: кинетический фронт наблюдается гироскопом как сенсорное свидетельство; каждый такт — независимая траектория, но пара, пройденная дважды в одном направлении, насыщается в общее русло двух доменов. Такт без перещёлкиваний — стационар ĤΨ = 0, ранний выход. Живой смоук «квантовая механика» × «квантовые вычисления»: 4 такта, флипы [355, 128, 92, 139], русла 1134 → 3836 (+2702 проросших связи). Детерминизм абсолютный — settle(X) побитово воспроизводим.

Грамматические мосты (pqc::syntax_bridge) — синтаксическая связность речи L5: классы токенов (союзы/предлоги/связки, ~200 слов RU+EN) и цепочка грамматики, которая (1) взвешивает билеты лотереи ×1..×4 (зреющее облако слов кричит союзу; после предлога — знаменательное), (2) предпочитает коннекторы лексикона, если корпус их обучал, (3) вставляет детерминированный мост из встроенной таблицы (и/а/но/в/на/или/является/когда · and/but/or/in/on/is/when/so), когда облако знаменательных слов ≥ 4. Вставленный коннектор — полноценный квант речи: он входит в кольцо гироскопа и лексикон, и повторная речь находит его уже в лотерее — грамматика прорастает в решётку через собственную речь мозга. Облако не длиннее 4 слов, хвостовых коннекторов нет.

Живое сравнение (демо-мозг из 4 тем, сид 42):

RQ21: квантовая система вопреки является наблюдаемая Квантовая для
      физики этого исполнения интеллекте когда атомных в независимых …
RQ17: требуют эти эффект бывшим tfrac в созданию способов больших
      один тонких ящике считал 1 обнаружили неосуществимыми …

Демонстрационный мозг: pqc learn × 4 фундаментальные темы (квантовая механика --full, теория информации, машинное обучение, квантовые вычисления) → d_pol=4096, 4647 русел, 2775 слов; развёрнутый диалог pqc chat растит память на каждом ответе.

pqc ask --focus-radius + --docs — фокусировка волны, релевантность и мульти-источник (v1.2.0, RQ22)

Волна мысли направляется от дуг вопроса: ответ держится сути, посторонние ветки решётки отсечены.

pqc ask "волновая функция" --brain brain.pqw            # фокус ВКЛЮЧЁН (radius 3)
pqc ask "..." --brain brain.pqw --focus-radius 1         # жёсткий фокус
pqc ask "..." --brain brain.pqw --no-focus               # свободная волна RQ21
pqc learn "тема" --brain b.pqw --docs URL1 --docs URL2   # markdown-документации

Маршрутизация волны (Question Wave Routing) — аттрактор вопроса = дуги TF-IDF свидетельства (p₀: зажжённые дуги + кинетика внимания); от него по руслам J считается BFS-дистанция каждой координаты. Лотерея речи получает фокус-множитель: дист. 0 → ×4, 1 → ×3, 2 → ×2, дальше в радиусе → ×1, за радиусом → ×0 — волна физически не может уйти в посторонний кластер (архетипический мост ⊗_ε не режется — прыжок уже вырос из вопроса). Русл в радиусе нет — честный шаг блуждания. Телеметрия: focus-объект в --json (attractor_arcs / focused_steps / wander_steps / relevance) — релевантность меряется и при выключенной маршрутизации.

Живое сравнение (мозг «квантовая механика» + «Древняя Греция», сид 7):

свободная волна: Арголидой … Эллада расположена острова Основные
                 Балканского побережье и Эгейского цивилизации …
фокус radius 1:  функция … Была настоящее … интерпретации

Самоподкрепление грамматики — удачно вставленный коннектор укрепляет свои русла J: второй направленный свидетель насыщает русло за одну реплику (обычной речи нужны два повтора) + кинетика внимания делает коннектор путём волны. Диалоги растят грамматику: +40–60 русел за реплику. Метрика syntax_bridges_density — мостов на 100 слов — в каждом отчёте (--json и человекочитаемом). --no-reinforce снимает.

Мульти-источник learn --docs — документации и markdown-репозитории по HTTPS (raw.githubusercontent.com, doc-сайты, .md/.txt): разметка вычищается чистой функцией clean_markdown (кодовые заборы, ссылки, заголовки, акценты, таблицы — вон; snake_case сохраняется), вежливость как у Wikipedia (User-Agent, пауза, backoff). Мозг из документации проекта говорит его словарём: pqw, GYRO, контейнер, Блох, русла.

pqc chat --name + gap-RLE + pqc avalanche — автобиографическая память, сверхкомпактное хранение, спиновая лавина (v1.3.0, RQ23)

Память непрерывна, хранение сверхкомпактно.

pqc chat --brain brain.pqw --name Иван        # мозг запомнит собеседника
pqc chat --brain brain.pqw                    # следующая сессия: «помню нить: …»
pqc ask "..." --brain brain.pqw --fresh       # холодный старт волны
pqc avalanche --key brain.pqw --size 131072   # спиновая лавина GF(3), 16 зондов
pqc encrypt msg.bin --key k.pqw --out c.pqt   # дефолт — нелинейная v2
pqc encrypt msg.bin --key k.pqw --out c.pqt --linear   # legacy RQ13 v1

Автобиографическая память (контекст-рефлекс W) — контейнер v5 (POLER_Q5): секция REFL хранит динамический след диалога — события сенсорного потока (координата, полярность), имя собеседника и счётчик реплик. При рестарте хвост следа восстанавливает кольцо гироскопа (русла не тронуты — первый вопрос новой сессии спаривается с последними словами предыдущей: русла растут сквозь границу сессий) и даёт затравку волны речи (нить занимает полокна, вопрос — вторую половину). Русла J — структурная память; W — динамическая: мозг помнит не только ЧТО связано, но и О ЧЁМ только что говорили. merge наследует автобиографию мозга A; learn/train след не трогают.

СЕССИЯ 2 (рестарт процесса):
автобио  : собеседник Иван, 2 реплик — помню нить: волновая функция
           что такое запутанность …
вопрос : продолжай
ответ  : волновая что волновая что

gap-RLE топологии (GYRO v2) — нулевые зоны верхнего треугольника гироскопа упакованы длинами прогонов: varint(Δ слота) + квант вместо (u32, u32, i8). Писатель меряет оба кодека и берёт меньший — кластеризованные топологии реальных мозгов сжимаются ×4.4, равномерный разброс ×2.3, деградации не бывает никогда. Измерения (кластер, d_pol=65536): 4096 пар — 36 896 → 8 413 Б; 65 536 пар — 589 856 → 133 276 Б. Zero-copy mmap сохранён: файл меньше — проекция меньше. pqc inspect --json показывает gyro.codec, sparse_bytes/rle_bytes/compression.

Спиновая лавина GF(3) (трит-шифр v2) — нелинейный слой диффузии: квадратичный T-проход x[i] += c[i]·x[i+1]·x[i+2] (mod 3) поверх линейного транспорта (такт = транспорт + спин-раунд, инверсия в обратном порядке). Нелинейность доказуема контрпримером аддитивности; обратимость побитовая (треугольная структура с кольцевой склейкой). Заодно найден и закрыт баг метрики RQ13: зонд лавины теперь шифруется с тем же IV — раньше разница случайных IV добавляла ~2/3 шума поверх реальной диффузии. Честные числа (128 КиБ, 666 блоков): от блока зонда вперёд — 66.5% (потолок GF(3) — 2/3), каскад CBC последующих блоков — 66.7%. Шифртексты v1 расшифровываются как раньше; pqc avalanche — полный протокол измерения (лавины/каскад/хи-квадрат/сравнение с линейной v1).

pqc train --quantized — квантованный curriculum: born-шаг в решётке тритов (v0.5.0, RQ15)

Обучение В решётке, а не рядом с ней: вся петля RQ8 сведена к разреженному born-шагу прямо в Packed4-байтах — нет плотного f64-вектора параметров, нет анзаца, нет statevector. Память = решётка = фазовая секция контейнера v2 бит-в-бит: чекпоинт — выписка без переквантования, --resume — копирование байтов обратно. Состояние меняется от каждого наблюдения и переживает любой сброс — смысловой кристалл из манифеста:

pqc train --quantized --corpus docs --curriculum --out crystal.pqw
pqc train --quantized --corpus docs --resume crystal.pqw --out crystal2.pqw

Петля: TF-IDF дуги (ε-ворота) → Born-измерение решётки (полюса детерминированы — ноль ГПСЧ-выстрелов, фон — честная монета) → момент v ← γ·v − g (Π_Λ строгая) → born_step_packed4_sparse. Физика — гистерезис π/3: перещёлкивание при |η·v| ≥ π/6 от экватора и ≥ π/3 от полюса («затвердевшее мнение» устойчиво к единичному несогласию); смена знака — только через экватор (полюс → Zero → полюс), телепортации фазы не существует; слабое свидетельство копится моментом до порога кристаллизации |target| ≳ 0.44.

Измерено (docs/, 22.7K токенов, d_pol=4096, shots=4096, debug): 1016 блоков/с против 9.0 у плотного (~113×) — детерминизм полюсов убирает ГПСЧ-выстрелы с кристаллизованных дуг, нет контейнерного round-trip; решётка 4096 тритов = 1 КиБ персистентной памяти (1643 дуги, контейнер 1152 B); невязка к цели 1.23 против 5.40 у плотного. Калибровка η = 0.6 (RQ14) если --eta0 не задан — плотный дефолт 0.25 лежит ниже порога кристаллизации (мёртвая зона покрыта тестом).

pqc precess — петля архетипа, уравнение a ⊗_ε a = a (v0.3.5)

Инференс поверх чекпоинта v3 — численная верификация уравнения архетипа в алгебре смыслов (O, ⊕, ⊗_ε):

# чистая прецессия: унитарная орбита вокруг архетипа
pqc precess brain.pqw

# оседание к архетипу: прецессия + McWeeny-проекция
pqc precess brain.pqw --eta 0.05 --purify-every 4 \
          --out archetype.pqw

# моды с невязками: Ritz (инвариантность плоскости),
# орто ≡ идемпотентность A² = A, захват компонент
pqc inspect brain.pqw --modes 8

Два уравнения — две половины петли: идемпотентность a ⊗_ε a = a (McWeeny P² = P + спектральные проекторы мод A_k = u_k u_kᵀ + v_k v_kᵀ, невязки ~1e-16) и фиксация p* = a ⊗_ε p* (моменты sin(θⱼ−θᵢ) → 0 на руслах J). Чистая прецессия унитарна (ρ ≈ 1.0001, орбита — «мышление» без остановки); чередование с проекцией McWeeny делает петлю Банах-сжимающей (ρ = 0.6 при η = 0.05): фиксация за 69 тиков, torque 1.2e-16, триты точны. Контейнер-архетип: 2648 дуг, McWeeny residual 0, русла J сохранены.

pqc bloch — триты → углы Блоха, mmap-стриминг для обучения (v0.4.0, RQ14)

Замыкает круг RQ1 → RQ13: анзац начался с R_y(arccos p), хранилище пришло к 2-битным тритам Packed4 — теперь обучение потребляет сжатое состояние напрямую из mmap, разворачивая θ = arccos(p) на лету. Ключевое наблюдение: на чистой тритовой решётке v2 угол принимает ровно три значения θ ∈ {0, π/2, π} — «arccos на лету» — это LUT-константа по 2-битному коду, а не FPU-вызов (углы в L1-регистрах, ×32 меньше трафика памяти; для d = 2²⁶ экономится 512 МиБ RAM против плотного f64-вектора):

pqc bloch state.pqw                 # решётка + стриминговый микробенчмарк
pqc bloch state.pqw --json --head 4

Слои: pqw::trit_bloch (LUT, плотный BlochAngles, LENS-BlochArcs, счётчики нулевого вздутия, обратный pack_thetas) и pqc::bloch_stream (чанковый Packed4Angles с памятью O(W), born_step_packed4 — фазовый шаг Born прямо в упакованных байтах с переквантованием ближайшим тритом: θ ← arccos(p) − η·v; p ← cos θ — обучение в 2-битных регистрах, мёртвая зона задана честно границей 0.5, v = 0 — тождество на решётке). Измерено (examples/bloch_bench, d = 2²²): стриминг LUT — 1.3 нс/трит против 14.2 нс/трит у материализации f64 + acos (×11); Born-шаг в байтах — 18 нс/трит; θ(LUT) == θ(acos) — точно на всей решётке. Бонус: GF(3)-коды шифр-блоков RQ13 — те же биты, что v2-коды, — один LUT разворачивает и контейнеры, и шифртекст в углы.

pqc encrypt / pqc decrypt — трит-схема алгебры архетипа (v0.3.7, RQ13)

Реализация уравнения из алгебры смыслов (файл 285) в тритах GF(3) — родном алфавите контейнеров POLER (Packed4): p* = a ⊗_ε p* ⊕ m, восстановление m = p* ⊕ (a ⊗_ε p*) — побитово точное (целая GF(3)-арифметика, без порогов и запасов).

Ключ — тот же precess --out (контейнер v3 с гироскопом J): моды Im(P), проектор a = Σ (u uᵀ + v vᵀ), холодные позиции, ключевой поток — терцили a·p₀. Блок — тритное состояние x = m ⊕ s ⊕ mask, которое прецессирует T тактов по руслам двух семейств: семантическим (J, поток смысла) и решётчатым (LENS-кольцо d_pol, три нечётных сдвига из знакочувствительного хеша ключа). Такт — GF(3)-сдвиг пары (t_i, t_j) → ((1+c)t_i − c·t_j, c·t_i + (1−c)t_j) (mod 3), det = 1 в любом кольце — дискретный аналог Курамото-транспорта precess_step; знак веса русла задаёт направление закрутки. Контейнер .pqt (magic PQT1, 64 B заголовок + IV + Packed4-триты, digest sha256-24):

pqc encrypt msg.bin --key archetype.pqw --out msg.pqt --seed 42
pqc decrypt msg.pqt --key archetype.pqw --out plain.bin
pqc encrypt msg.bin --key k.pqw --out msg.pqc --f32        # legacy RQ12

Измерено на чекпоинте RQ11 (d_pol=4096, 2651 русло): лавина ~2/3 трит блока от 1 бита (RQ12: 1 бит → 1 фаза; 2/3 — потолок GF(3)), расширение ×1.34 (RQ12: ×43 — в 32 раза меньше), ёмкость 770 B/блок (упаковка 19 трит ↔ 30 бит), инверсия прецессии точная. Честные границы: схема линейна над GF(3) — известный открытый текст одного блока при известных руслах J восстанавливает ключевой поток на холодных позициях; это сознательное свойство наблюдаемости (модель должна видеть свои веса и действия — проективная рефлексия; защита внешнего канала — задача TLS/RSA-контура); длина сообщения читается из заголовка; целостность — только digest. Исследовательская демонстрация уравнения файл 285, не production-шифр.

pqc encrypt --f32 — исследовательская схема RQ12 (v0.3.6)

Первая реализация файла 285 на f32-фазах: сообщение — паттерн δ = (I−a)(ε·b) на холодных компонентах, ключевой поток a·p₀, CBC + IV, контейнер .pqc (magic PQC1, фазы f32). Коллапс за один такт (идемпотентность точна), но: 1 бит → 1 фаза (без лавины), расширение ×43, запас декодирования 0.028 при пороге 0.05. Оставлен для сравнения и воспроизведения измерений RQ12; расшифровка автодетектит обе магии PQT1/PQC1.

Тесты

cargo test --workspace — 447 тестов (311 на pqc, включая doc-тесты + 136 на pqw, включая 3 doc):

• известные векторы SHA-256 (NIST) и FNV-1a64;
• golden-layout: побайтовая проверка всех смещений (0x00..0x80 + payload);
• матрица повреждений (15 кейсов): битфлипы заголовка/топологии/фаз, усечение, мусор в конце, зарезервированные биты, несогласованные длины;
• roundtrip в границах квантилизации (случайные состояния, d = 512…65537);
• zero-copy: заимствование фаз и индексов без копирования;
• McWeeny: подпись заголовка == пересчёт, сходимость, сохранение тритов;
• mmap-сценарий: запись → отображение → разбор → верификация;
• паритет с аналитикой (26): тензорная структура R_y, состояние Белла, анзац из фаз против формулы произведения амплитуд — допуск 1e-12;
• статистика Born (14): равномерность и согласие с теорией в 5σ, product-движок против statevector-моментов, фон = Binomial(d, ½);
• мост pqw → pqc (12): LENS-фон, McWeeny-заострение, порча payload, mmap-сценарии end-to-end;
• inspect (25): детект v1/v2/raw-Packed4/opaque, точные позиции дуг сырого пакета, вердикты structured/encrypted-like, порча v2-payload с сохранением nnz → digest FAIL, DOT и JSON собственным парсером;
• train (3): накопительный union support двух файлов, валидность чекпоинта и отпечатка (magic + nnz @ 0x60), JSON-отчёт, коды ошибок;
• ГПСЧ: потоки, jump, равномерность, покрытие всех 64 бит;
• zero-storage стриминг (7): конвейер текст → контейнер → Born → QCM на обоих движках, латентность d=512 < 2 мс, детерминизм, CZ-инвариант;
• энтанглмент (10): префиксный XOR против эталона, product ↔ statevector до 1e-12 на всех режимах, марковские маргиналы/паттерны;
• JSON zero-dep (7): round-trip, экранирование, суррогатные пары, бит-точность f64, malformed-матрица, лимит глубины;
• parity-ансца (9): зонды little-endian, состояние Белла, R_z- инвариантность вероятностей, бит-снимки контракта SplitMix64;
• кросс-тест с Qiskit (2): 56 конфигураций χ² + амплитуды < 1e-12 + смоук бинарника pqc-parity;
• петля обучения Born (13 + 2 интеграционных): сходимость за ≤ 10 шагов на обоих движках, монотонность, regime-jump, пурификация до тритов, Π_Λ-заморозка фона, побитовая воспроизводимость, точность формулы градиента; замкнутый цикл «обучение → v2-контейнер → перезагрузка в контур»;
• формат v2 Packed4 (21 + 12 юнит-тестов): битовая раскладка, round-trip, ровно 4x сжатие фазовых блоков, d=65536 → 16 КиБ, паритет семантики v1 ↔ v2, матрица повреждений (0b11, паддинг, nnz-пересчёт, топология в v2), fuzz 64 случайных состояний, побайтовая воспроизводимость;
• Active Inference (9): расписание η(Σ) — граничные значения, монотонность и клампинг; сюрприз от честных монет до тритов; адаптивная сходимость ≤ 10 шагов; regime-jump при γ = 0.5; пурификация K = 5 до тритов; строгая Π_Λ; побитовая воспроизводимость расписания;
• stream engine (16): инварианты коммутатора (NO_HITS/стационар/ ортогональность/ручная сверка √2), TF-IDF давит сквозной шум, стабильность ёмкости буфера, формула размера контейнера, NO_HITS-барьер, детерминизм, сходимость повторов, смена темы, политики Hold/Decay, рост support, QCM растёт с убеждённостью, латентность d=512 < 5 мс (DoD), QCM+коммутатор < 150 мкс;
• CLI stream (8 интеграционных): сквозной прогон бинарника, JSON-отчёт парсится собственным zero-dep парсером, NO_HITS, https-отказ с подсказкой, ровно один источник, файловый источник + валидный Packed4-дамп, stdin-пайп, отказ соединения без паники.

Автономным агентам — протокол Context-Free Resilience (v0.3.8)

Если вы — агентский ИИ (LLM-сессия, воркер poler-engine / antigravity, CLI-инстанс, сервер), работающий с этим репозиторием: первым делом прочитайте AGENT.md и AGENT_STATE.md, затем выполните ./scripts/agent_bootstrap.sh — скрипт соберёт отчёт восстановления (вектор движения, окружение, фоновые tmux-сессии, git-статус всех репозиториев с fetch-before-work).

Суть протокола: контекстное окно чата и ворклоги — не носители памяти (стираются при сбросе сессии). Истина — git-репозитории, файловая система, запущенные процессы и персистентные PTY-терминалы. Длительные задачи — только в фоновых tmux-сессиях (сброс чата не прерывает вычислений); значимые изменения — немедленный коммит и push; git fetch — до начала любой работы. Токены — только через credential-helper, никогда в remote-URL и выводе (маска ghp_****); опубликованный в чате токен считается скомпрометированным.

Roadmap

• v0.1 (pqw) — формат v1 + CLI + mmap + McWeeny-модуль
• v0.1.1 (pqc) — ✅ ядро RQ1: statevector, анзац Ry(arccos p), Born sampling, два движка, SIMD-ядра без зависимостей
• v0.1.2 — ✅ RQ3: zero-storage стриминг (d=512 ≈ 105 мкс) + ✅ RQ4: χ²-паритет с Qiskit (амплитуды 1.1e-16) + ✅ LENS-энтанглмент (FromTopology, точный GF(2)-сэмплер в product-движке)
• RQ2 — ✅ выполнена в POLER-Quantum v1.1.0 (Python)
• v0.2 (здесь) — ✅ RQ5: петля фазового обучения Born (BornOptimizer, Π_Λ, McWeeny-пурификация) + ✅ формат v0.2 Packed4 (4 дуги/байт, magic POLER_Q2, ровно 4x сжатие фазовых блоков)
• v0.3 (здесь) — ✅ RQ6: Zero-Storage Streaming Learning Engine — pqc::stream_engine (TF-IDF ε-плотность, Packed4 с реюзом буфера, коммутатор Фокиана, NO_HITS-барьер) + pqc::learn::ActiveInference (η(t) = η₀·e^(−βΣ), γ = 0.5, McWeeny K = 5, строгая Π_Λ) + CLI pqc stream с zero-dep HTTP; сквозной цикл d=512 ≈ 0.32 мс
• v0.3.1 (здесь) — ✅ pqc inspect: чтение графов, бинарников и крипто-разведка — детект форматов (v1/v2/raw-Packed4/opaque), энтропия + χ² + сигнатуры шифро-контейнеров, побайтовая карта заголовка, декод дуг, LENS-граф (CSR/DOT/JSON/ASCII), целостность
• v0.3.5 — ✅ RQ11: уравнение архетипа a ⊗_ε a = a + p* = a ⊗_ε p* — моды с невязками Ritz/орто/захват, петля pqc precess (унитарная орбита ↔ оседание с McWeeny), контейнер-архетип с нулевым остатком идемпотентности
• v0.3.6 — ✅ RQ12: крипто-схема алгебры архетипа (файл 285) m = p* ⊕ (a ⊗_ε p*) — модовый проектор (K=8, идемпотентность точна), холодные позиции битов, CBC+IV, контейнер .pqc; авто-калибровка K по помехе проекции
• v0.3.7 — ✅ RQ13: трит-схема GF(3) — прецессия шифрблока по руслам J + решётке LENS (лавина ~2/3 трит от бита), Packed4-триты (расширение ×43 → ×1.34), упаковка 19 трит ↔ 30 бит, точная GF(3)- расшифровка; зеркало J → −J больше не расшифровывает; --f32 — legacy RQ12, автодетект магии PQT1/PQC1
• v0.3.8 — ✅ Context-Free Resilience: AGENT.md (протокол автономных агентов: иерархия истины, tmux-слой, git-first, гигиена токенов, холодный старт фаз 0–4), AGENT_STATE.md (машиночитаемый якорь состояния), scripts/agent_bootstrap.sh (автосбор отчёта восстановления с маскировкой токенов)
• v0.4.0 (здесь) — ✅ RQ14: mmap-разворот тритов в углы Блоха — pqw::trit_bloch (LUT θ ∈ {0, π/2, π}, итераторы, нулевое вздутие), pqc::bloch_stream (чанковый стример, born-шаг в 2-битных регистрах), CLI pqc bloch; стриминг ×11 быстрее материализации, 447 тестов
• v0.5.0 (здесь) — ✅ RQ15: квантованный curriculum — pqc::qcurriculum (QuantizedCurriculum: born-шаг в тритовой решётке, память = контейнер бит-в-бит, гистерезис π/3, полюса детерминированы), born_step_packed4_sparse, CLI pqc train --quantized (curriculum + resume + JSON-телеметрия решётки); ~113× быстрее плотного на равном бюджете выстрелов, 470 тестов
• v0.6.0 (здесь) — ✅ RQ16: слияние решётки с гироскопом — pqc::gyro_lattice (TritGyro: J = A − Aᵀ в тритовых руслах, плотная треугольная индексация пар, порог насыщения 2 события, ноль HashMap; MomentumLattice: 2-битный насыщающий момент, инерция без затухания; precess_step_packed4: оператор L5 Π_Λ(e^{Δt·J}p) с SIN_LUT — ноль FPU; QuantizedGyroCurriculum: слитый движок, чекпоинт v3 бит-в-бит), CLI pqc train --quantized --gyro + --dt; волна рассуждения расширяет кристалл ×13 (128 → 1717 дуг), 513 тестов
• v0.7.0 (здесь) — ✅ RQ17: L5-генерация — формат v4 (POLER_Q4
  • секция LEXI: лексикон кристалла, координата → доминантный токен), pqc::generate (LexiconBuilder + L5Generator: слушание с кинетикой внимания, мышление Π_Λ(e^{Δt·J}p), речь билетами 1+|крутящий момент|, анти-заикание, ABAB-детекция, AOT-морфемы), CLI pqc generate/step/ask/chat с диалоговой памятью (вопрос+ответ кристаллизуются born-шагом, лексикон растёт от вопросов), 549 тестов
• v0.8.0 (здесь) — ✅ RQ18: нелинейная архетипическая алгебра — pqc::archetype_lattice (a ⊗_ε b в Packed4 SWAR-ом без f64: резонансная интерференция + энергетический гейт E = co/min(nnz) ≥ ε; идемпотентность бит-в-бит, ортогональность → Zero), мост внимания в движке (prompt_archetype + archetype_bridge: момент на пересечении, фазы неприкосновенны), уровень концептуального прыжка в born-лотерее (Flow → Backtrack → Archetype → Kinetic), CLI pqc archetype (мозг ⊗ промпт / мозг ⊗ мозг) + --no-bridge/--bridge-eps, 619 теста
• v0.9.0 — ✅ RQ19: pqc learn "ТЕМА" — целенаправленный интернет-ингест: pqc::tlsprim (SHA-256/HMAC/HKDF/ChaCha20/ Poly1305/X25519 с нуля, векторы RFC), pqc::tls13 (клиент TLS 1.3: key schedule по трассе RFC 8448, защищённые записи, Finished), pqc::netfetch (HTTP/1.1), pqc::wikisrc (Wikipedia API: explaintext, вежливость, backoff), pqc::learn_net (ингест страниц → born_step_packed4 → v4; самоуправляемые раунды — модель сама уточняет запрос топ-новым словом), CLI pqc learn (+ --text offline), 619 тестов
• v1.0.0 (здесь) — ✅ RQ20: pqc merge — архетипическое слияние мозгов через ⊗_ε: pqc::merge (фазы c = a ⊗_ε b таблицей интерференции без гейта — объединение знаний; русла J = Π_Λ(J_A + J_B) с кососимметричностью по построению; LEXI-консолидация с базой A; born-консолидация бит-в-бит, ноль ГПСЧ — детерминизм абсолютный; диагностика изоморфизма E = co/min(nnz) ≥ ε), CLI pqc merge A.pqw B.pqw --out M.pqw (+ --ask мульти-доменная проверка), 648 тестов
• v1.1.0 — ✅ RQ21: качество связной речи и консолидация мысли: pqc merge --settle [N] — сеттлинг слияния волной Π_Λ(e^{Δt·J} p) (транспорт + born-консолидация кинетического фронта: пара, пройденная дважды в одном направлении, насыщается в общее русло доменов; стационар ĤΨ = 0 с ранним выходом; живой смоук: +2702 проросших русла за 4 такта), pqc::syntax_bridge — грамматические мосты L5 (классы союзов/предлогов/связок RU+EN, взвешивание лотареи ×1..×4, детерминированные коннекторы для облаков ≥ 4 слов; коннекторы прорастают в решётку через собственную речь; CLI-дефолт включён, --no-syntax снимает), демонстрационный мозг из 4 тем + развёрнутый chat-диалог; 674 теста
• v1.2.0 (здесь) — ✅ RQ22: фокусировка волны и релевантность ответов: маршрутизация речи от дуг вопроса (аттрактор TF-IDF свидетельства → BFS-дистанции по руслам J → фокус-множители лотареи ×4/×3/×2/×1 и отсечка ×0 за радиусом; телеметрия релевантности focused_steps / wander_steps / relevance в JSON), самоподкрепление грамматики (удачные коннекторы укрепляют русла J — насыщение за одну реплику + кинетика внимания; метрика syntax_bridges_density мостов на 100 слов), мульти-источник learn --docs URL (markdown/документации через HTTPS с чисткой разметки); 707 тестов
• дальше — блочный RLE топологии для sparse-Packed4, обучаемый паттерн LENS-рёбер, обрезка мёртвых дуг (decay ниже порога), GF(3)-лавина на больших блоках, FFI/gym-интерфейс петли

License

MIT — см. LICENSE.