Skip to content

quantum-eri.md

Latest commit

 

History

History
234 lines (192 loc) · 16.5 KB

quantum-eri.md

File metadata and controls

234 lines (192 loc) · 16.5 KB
Raw

Квантовый мост и POLER-ERI v3.2.0: Reverse Meta-Compiler

Статус: документирует src/quantum/ (mod.rs, crystallizer.rs, meta_compiler.rs) и его происхождение из проекта POLER-ERI. Математика носителя — THEORY.md §9; генеалогия — HISTORY.md этапы 5, 8, 10.

1. Что это такое

src/quantum/ — точка, где три линии проекта слились в одном коде:

  1. POLER-Quantum-RS (крейты pqc/pqw, path-зависимости) — квантово-фазовое ядро: решётка учебного плана, русла циркуляции J, L5-генератор;
  2. POLER-ERI v3.2.0 — мета-компилятор электронных интегралов, чей конвейер CircuitBuilder → R1CS → CSE → Crystallizer перенесён сюда;
  3. Весовые матрицы LLM — новый фронт: .safetensors → тернаризованные R1CS-схемы → векторизованное исполнение.

Идея моста: весовая матрица и рекуррентное уравнение — одно и то же. Оба суть полиномиальные системы ограничений ранга 1; обе можно свернуть в граф линейных вентилей, оптимизировать и «кристаллизовать» в плоский код, исполняющийся без интерпретатора. Отсюда и «reverse»: обычный компилятор понижает абстракцию от кода к железу; мета-компилятор POLER идёт в обратную сторону — от физических коэффициентов к оптимальной программе.

2. Модули

2.1. mod.rs — QuantumMind

L5-движок авторегрессии поверх pqc_core::QuantizedGyroCurriculum. Открывает три семейства контейнеров:

Магия Контейнер Что извлекается
POLER_QW/Q2…Q5 фазовые контейнеры POLER[Ψ] curriculum resume (решётка, русла J)
.safetensors сырые тензоры лексикон + хэш-проекция в русла J (LENS)
.pqw v2 нейровеса __tokenizer__ + авто-насыщение ротора J из W_q/W_k/dense

Ключевые методы: ingest(text, pass) — кормление текста в решётку; generate_stream — потоковая генерация (на корпусных весах — 224.5 ток/с); generate_with_reader — Active Inference U3: при падении relevance ниже 0.25 генератор не галлюцинирует, а читает — берёт следующую страницу из reader::Workspace (действие Action::Read), а пороги τ(t) адаптируются по кинетике Ленгмюра—Михаэлиса—Ментен (термодинамика чтения); project_coord — LENS-хэш-проекция словаря в фазовое пространство; reasoning_step — один шаг цикла ℘-O-L-ε-R[n]-Ψ.

2.2. crystallizer.rs — R1CS-кристаллизатор (собственность владельца)

Фундамент, на котором стоит meta_compiler:

  • SafetensorsHeader::parse — ручной разбор JSON-заголовка (без serde_json: контроль порядка и zero-copy смещений);
  • GateCoeff {Zero, One, NegOne, Scalar} — коэффициенты вентилей;
  • R1CSGate — вентиль operands[result] = cL·operands[l] + cR·operands[r] (линейная форма ранга 1);
  • WeightCircuitBuilder — строитель схем (add_gate, compile_linear_layer: W·x как Σ строк-вентилей);
  • execute_circuit_direct — наивный эталон-интерпретатор (главный дифференциальный оракул всех тестов);
  • WeightCrystallizer::crystallize_to_rust — скалярный кодоген (первое поколение).

2.3. meta_compiler.rs — Reverse Meta-Compiler (1 717 строк)

Полный конвейер POLER-ERI v3.2.0, переработанный по критике владельца (запрещены: псевдо-SIMD _mm256_set1_ps+_mm_cvtss_f32, цикл-интерпретатор с match-диспетчем, CSE без DCE). Публичный API:

pub struct VectorGate8;                    // §1: 8 вентилей в одном AVX2-регистре
pub struct CSEOptimizer;                   // §3: фасад optimize(&builder) -> builder
pub struct MetaPipeline;                   // §4: исполняемый конвейер
impl MetaPipeline {
    pub fn run(builder) -> Result<Self, String>;
    pub fn run_with_outputs(builder, &[usize]) -> Result<Self, String>; // DCE от выходов
    pub fn execute(&self, operands: &mut [f32]);        // скалярно или AVX2
    pub fn slot_of(&self, operand: usize) -> Option<usize>;
    pub fn outputs(&self) -> &[usize];
    pub fn stats(&self) -> (usize, usize, f64);          // (вентили, волны, мкс/проход)
    pub fn n_operands / in_dim / waves / tensor_name …
}
pub fn crystallize_to_flat_simd_rust(fn_name: &str, builder) -> String; // §5
pub fn ternarize_mean_abs(w: &[f32]) -> Vec<i8>;         // §6: порог 1.2125·mean|w|
pub fn meta_compile_safetensors_tensor(bytes, in_dim, out_dim) -> Result<MetaPipeline, String>;

3. Как работает векторизация (§1)

R1CS-вентили независимы — значит, их можно исполнять по 8 штук за раз в одном __m256. VectorGate8 хранит 8 пар индексов операндов (l₀…l₇, r₀…r₇) и кодирует коэффициенты {-1, 0, +1} каждой стороны битовыми масками, а не enum'ами:

MASK_KEEP = 0x00000000  — коэффициент +1 (пропустить как есть)
MASK_KILL = 0x80000000  — коэффициент  0  (зануление знакового бита → ±0)
MASK_FLIP = 0x80000000  — коэффициент −1 (инверсия знака)

вычисление r = cL·l + cR·r  (8 ланн одновременно):
  L = load(lanes l₀…l₇);  R = load(lanes r₀…r₇)
  L = and(L, keepL_mask)            — зануление левых, где cL = 0
  L = xor(L, flipL_mask)            — смена знака, где cL = −1
  R = and(R, keepR_mask); R = xor(R, flipR_mask)
  R = xor(R, sub_mask)              — вычитание = инверсия знака + сложение
  r = add(L, R)                     // ЕДИНСТВЕННАЯ арифметическая инструкция

Итог: одна vaddps на 8 вентилей, ноль умножений, ноль ветвлений — все 9 комбинаций (cL, cR) ∈ {−1,0,+1}² покрываются одной безветвлевой последовательностью маскирующих операций. Скалярные коэффициенты (GateCoeff:: Scalar) материализуются в «холодном прологе» волны — умножение там, где оно редко и не в горячем цикле.

4. Компилятор волн (§2): пять проходов

compile_to_waves превращает плоский список вентилей в вектор волн Vec<VectorGate8>:

  1. Нормализация копий: вентили-копии (One, Zero) схлопываются в alias-карту value_of (chase-map) — копия не занимает слот и не рвёт лан-аффинность.
  2. Коммутативный CSE: общий подвыражение устраняется ключом (min(idx_a, tag_a), op, max(idx_b, tag_b)) — коммутативность учитывается канонизацией порядка; скалярные константы сравниваются битами f32 (−0.0 ≠ +0.0). На реальных схемах — минус 30–50% вентилей.
  3. DCE: обратный обход достижимости от заявленных выходов (run_with_outputs) либо от корней; мёртвые поддеревья не просто не считаются — их нет в волновом плане, слоты SSA-перенумеруются.
  4. Материализация скаляров: редкие скалярные гейты выносятся в пролог, чтобы горячие волны были чисто маскируемыми.
  5. Lane-аффинное планирование: вентили группируются так, чтобы цепочки-аккумуляторы одной полосы j шли в lockstep — тогда операнды левого входа лежат в памяти смежно → _mm256_loadu_ps вместо восьми _mm256_set_ps гатеров, результат пишется блоком → _mm256_storeu_ps. SSA-перенумерация операндов выполняется именно ради этой смежности: reverse = анализ данных + синтез layout'а под ISA.

Готовые волны исполняются MetaPipeline::execute: детект AVX2 — один раз при построении; fallback — скалярный интерпретатор (тот же результат, медленнее; нужен для платформ без AVX2).

5. Плоский кодоген (§5)

crystallize_to_flat_simd_rust(fn_name, builder) испускает готовый к компиляции Rust-файл:

pub fn kernel(operands: &mut [f32]) {
    let w0 = _mm256_loadu_ps(operands.as_ptr().add(0));       // волна 0
    let w0r = _mm256_loadu_ps(operands.as_ptr().add(8));
    let m0 = _mm256_and_ps(w0, unsafe { … MASK_KEEP … });
    …
    _mm256_storeu_ps(operands.as_ptr().add(16), r0);           // без ветвлений
    … // 5 450 волн — линейный текст, ни одного for / match / if
}

Правила кодогена: ноль циклов, ноль match, ноль ветвлений; маски — литералами f32::from_bits(0x…); per-wave специализация add/sub/masked (если у всей волны одинаковые коэффициенты, текст короче — прямые add/sub без масок). Критическая находка: rustc ≥ 1.87 запрещает #[inline(always)] вместе с #[target_feature] — испускается #[inline] с поясняющим комментарием (поймано интеграционным тестом, который реально компилирует сгенерированное ядро rustc -O и сверяет результат с runtime-конвейером побитово — tests/meta_compiler_flat_codegen.rs).

6. Safetensors-фронт (§6)

meta_compile_safetensors_tensor(tensor_bytes, in_dim, out_dim):

  1. pick_weight_tensor — выбор тензора по приоритету имён q_proj → k_proj → dense (это тензоры, из которых QuantumMind строит русла J — фронт согласован с мостом);
  2. декодинг F32 / F16 (субнормали через явную нормализацию мантиссы; ранний дефект — u32-подтерминация экспоненты — исправлен) / BF16 (u32 << 16 — ранняя версия ошибочно сдвигала на 8, паттерн падал в мантиссу, денормали ~1e-35; поймано пробником probe_bf16.rs);
  3. ternarize_mean_abs — тернаризация {−1, 0, +1} с порогом 1.2125·mean|w| (плотность нулей ⅓ — теоретический оптимум для гауссовых весов);
  4. тернарная матрица → WeightCircuitBuilder → весь конвейер §4 → MetaPipeline.

Смысл тернаризации: тернарная матрица — это R1CS-схема с коэффициентами {−1,0,+1}, то есть максимально векторизуемая (§3) аппроксимация линейного слоя. Плотность ⅓ нулей дополнительно сокращает схему.

7. Верификация и производительность

Тест Что гарантирует
test_packed_simd8_accuracy 8-полосное исполнение = скалярный эталон (в пределах f32-ассоциативности — точно: маски не меняют порядок операций)
test_cse_gate_reduction CSE/DCE реально сокращают схему
test_crystallized_flat_speed скорость конвейера
test_flat_codegen_structure в сгенерированном коде нет for/match/ветвлений
test_random_circuits_match_reference бит-в-бит фаззинг: 64 + 24 случайных схемы против execute_circuit_direct
test_safetensors_meta_compile полный фронт: заголовок → тернаризация → конвейер
test_meta_pipeline_stats корректность статистики
tests/meta_compiler_flat_codegen.rs сгенерированное ядро компилируется настоящим rustc и совпадает с runtime побитово

Эталонная производительность (release, Xeon AVX2): тернарный слой 256×256 = 43 764 вентиля → 5 450 волн → 31.76 мкс/проход = 31 490 проходов/сек (гарантия плана >1000 перевыполнена ×31; debug-сборка — 1 347 проходов/с, тоже выше гарантии).

8. Наследие POLER-ERI v3.2.0 (квантовая химия)

Архитектурный шаблон пришёл из вычислительной химии, и это не метафора: рекурренции ВРР/HRR для двухэлектронных интегралов (ab|cd) — тоже линейные формы, и POLER-ERI кристаллизовал их в 1 296 компонент (ss|ss)…(dd|dd) с machine epsilon против мемоизированного референса (417 тестов, архив файл 66). Конвейер ERI: CircuitBuilder → VrrCrystallizer → BatchCompiler (все shell-квартеты) → ArchetypeRegistry (каждый квартет ↔ архетип a⊗_ε a = a, идемпотентность проверяется) → CryptoVerifier (Merkle-подпись кодебейза).

В poler-engine перенесена суть (R1CS → CSE → кристаллизация), но фронт другой: вместо гауссовых оболочек — весовые матрицы LLM. Обратный ход (докрутка ERI-фронта для настоящей квантовой химии внутри движка) — пункт дальнего плана, см. MERGE_PLAN.md §5.

9. Открытые хвосты

  1. L1-замер чистого ядра без метаданных конвейера (сейчас 31.76 мкс включает диспетчеризацию волн).
  2. Multi-accumulator split: разбиение длинных цепочек на независимые аккумуляторы укорачивает критический путь — ожидание ~2× на latency-bound схемах.
  3. CLI-обвязка --meta-compile model.safetensors (сейчас API библиотечный).
  4. Диагностика glm_int4 (0 токенов) — вне модуля, но блокирует e2e-прогон декодера на тернарной аппроксимации.