Средний

4 мин

12K

В первой статье я высказал простую идею: если вычисление можно свести к конечной таблице операции, его можно проверять, а не угадывать. То есть его можно свести не к "модель выдала вероятность 0,67", а просто открыть таблицу и сказать: вот ячейка, вот результат, rc=0.

Эта статья — прямое продолжение первой статьи. Сейчас у меня на руках значительно отличающаяся рабочая модель ИИ-движка. Но сразу честно: я не собираюсь раскрывать здесь внутреннюю кухню "GALO AI". Ни устройство нейрона, ни приватные маршруты мышления. Покажу только основополагающую математику: маленькую конечную структуру, которую можно взять руками, прогнать скриптом и попытаться сломать контрпримером.

Ключевая идея проста до невозможности: я взял обычное сложение по модулю и изменил в его таблице ровно одну строку.

Этого хватило, чтобы структура перестала быть полем, кольцом и моноидом.

1. Таблицы Кэли циклической группы

Когда говорят про математику для ИИ, на ум сразу приходят векторы, вероятности, градиенты и огромные обучаемые веса. Я пошел другим путем.

Я взял нетривиальную, но понятную конечную конструкцию — таблицу Кэли циклической группы — и спросил себя: что будет, если в ней испортить ровно одну строку?

Не наколдовать. Не ввести стохастику. Не спрятать поведение в вещественных весах.

Просто переписать одну строку.

Получилась операция, которую я называю якорной таблицей STAR.

2. PLUS и STAR

Носитель простой:

Q_n = {P0, P1, ..., P(n-1)}

Первая операция — PLUS — обычное сложение по модулю n:

PLUS(P_i, P_j) = P((i + j) mod n)

Вторая операция — STAR — почти копия PLUS, но с якорем P0.

Первое правило: если P0 стоит слева, он всё поглощает:

STAR(P0, x) = P0

Второе правило: если P0 стоит справа, он ничего не меняет:

STAR(x, P0) = x

Третье правило: если оба индекса ненулевые, STAR совпадает с PLUS:

STAR(P_i, P_j) = PLUS(P_i, P_j), если i != 0 и j != 0

То есть:

• P0 слева работает как поглотитель;

• P0 справа работает как нейтральный элемент;

• все ненулевые пары работают так же, как PLUS.

Этого достаточно, чтобы обычная симметричная картина сломалась.

3. Пример на L3

Возьмем нетривиальный пример:

n = 3

Q_3 = {P0, P1, P2}

Таблица PLUS:

Теперь таблица STAR:

Строки P1 и P2 остались прежними. Они совпадают с PLUS. Изменилась только строка P0.

Именно эта строка все меняет.

4. Почему STAR — не умножение поля

Типовая ошибка — думать, что STAR это «какое-то хитрое умножение».

Нет.

В поле умножение на ноль всегда дает ноль:

P1 * P0 = P0

У меня:

STAR(P1, P0) = P1

Одна ячейка — и claim "это поле" падает.

Это не мелочь и не технический нюанс. Это разделитель. STAR не пытается быть полевым умножением. У него другая роль: он сохраняет профиль PLUS почти везде, но вводит якорную асимметрию через P0.

5. Почему STAR — не моноид

Моноид требует ассоциативности. Но уже на L3 она ломается без длинного доказательства.

Считаем левую расстановку скобок:

(STAR(P1, P0)) STAR P1

Сначала:

STAR(P1, P0) = P1

Затем:

STAR(P1, P1) = P2

Итого:

(STAR(P1, P0)) STAR P1 = P2

Теперь правая расстановка:

P1 STAR (STAR(P0, P1))

Сначала:

STAR(P0, P1) = P0

Затем:

STAR(P1, P0) = P1

Итого:

P1 STAR (STAR(P0, P1)) = P1

Получили:

P2 != P1

Ассоциативность нарушена.

(STAR(P1, P0)) STAR P1 != P1 STAR (STAR(P0, P1))

Поэтому я сознательно не называю это "STAR-моноидом". Звучит красиво, но математически неверно.

По той же причине эта структура не становится кольцом в обычном смысле: для кольца вторая операция должна вести себя как ассоциативное умножение. Здесь этого нет.

6. Почему одна строка так важна

Изменение минимальное, эффект сильный.

Почти вся таблица наследует PLUS. Новое поведение сосредоточено в одной якорной строке.

Это даёт три инженерных плюса:

• проверка локальна: можно указать конкретную ячейку;

• контрпример точен: можно назвать конкретные элементы;

• поведение полностью воспроизводимо: rc=0 или rc=1, без "в среднем".

Здесь нет "модель решила". Есть только:

expected = … got = … where = … counterexample = … rc = …

Для меня это важная часть всей идеи: вычисление должно быть не впечатлением, а проверяемым объектом.

7. Связь с GALO AI

В моем закрытом проекте GALO AI такие таблицы — один из нижних математических слоев. Проще говоря, на них основаны все последующие вычисления. Но в этой статье я показываю только азы: носитель, две операции, таблицы, контрпримеры и самопроверку.

Я не утверждаю, что эта структура сама по себе — готовый ИИ. И это еще не замена LLM, что я также подчеркнул в первой статье.

Это математический фундамент. Его можно проверить независимо от моих слов, моей мотивации и моих дальнейших планов.

8. Что лежит в архиве

К статье прилагаю архив GALO_HABR_1.zip.

В нём:

• таблицы PLUS/STAR для L1...L7;

• ручные примеры и контрпримеры;

• скрипт самопроверки;

• короткие задания для тех, кто хочет проверить конструкцию.

Запуск:

python3 -B galo_habr.py selfcheck
python3 -B galo_habr.py route article
python3 -B galo_habr.py route math`

Ожидаемый результат:

status = PASS

rc = 0

Если что-то не проходит, нужен конкретный контрпример.

9. Минимальный набор формул

Весь математический фундамент помещается в несколько строк:

Q_n = {P0, P1, ..., P(n-1)}
PLUS_n(P_i, P_j) = P((i+j) mod n)
STAR_n(P0, x) = P0
STAR_n(x, P0) = x
STAR_n(P_i, P_j) = PLUS_n(P_i, P_j), если i != 0 и j != 0

В табличном виде:

Дальше эти строки разворачиваются в полные таблицы. А таблицы уже можно проверить исчерпывающе.

10. Кого я ищу

Я ищу того, кто хочет взяться за развитие этих идей всерьез и вместе двигаться к системе, где каждое решение можно проверить.

Если вы:

• искренне любите алгебру и формальную верификацию;

• цените предельно строгую логику;

• по-настоящему интересуетесь не очередной статистической моделью, а системой, где все проверяемо.

Тогда этот архив для вас.

Первая задача простая:

1. Возьмите L3 и вручную проверьте нарушение ассоциативности.

2. Возьмите L5 и найдите разделитель, показывающий, что STAR не является полевым умножением.

3. Запустите selfcheck.

4. Сравните ручной результат со скриптом.

Если найдёте ошибку — пишите не "мне кажется", а в таком формате:

check_id =

expected =

got =

where =

counterexample =

minimal_fix =

Вот такой разговор мне действительно интересен.

11. Заключение

Это не заявление о готовом ИИ.

Это второй шаг после первой статьи: сначала я привел идею табличного детерминированного движка, теперь показываю конкретный математический фундамент, который можно легко проверить.

Архитектура архива простая:

• таблицы;

• формулы;

• контрпримеры;

• selfcheck;

• rc = 0.

Хотите проверить — архив открыт.

Хотите спорить — буду рад любой критике!

P.S.

Если среди читателей вдруг завалялся крутой разработчик LLM, который устал от вероятностного шаманства и хочет попробовать разработать систему, где каждый шаг действительно можно проверить, — пишите в личку.

Мне нужен именно тот, кто готов вместе думать, как сделать ИИ по-настоящему разумным, а не просто очень убедительным.