В первой статье я высказал простую идею: если вычисление можно свести к конечной таблице операции, его можно проверять, а не угадывать. То есть его можно свести не к "модель выдала вероятность 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:
PLUS_L3 |
P0 |
P1 |
P2 |
P0 |
P0 |
P1 |
P2 |
P1 |
P1 |
P2 |
P0 |
P2 |
P2 |
P0 |
P1 |
Теперь таблица STAR:
STAR_L3 |
P0 |
P1 |
P2 |
P0 |
P0 |
P0 |
P0 |
P1 |
P1 |
P2 |
P0 |
P2 |
P2 |
P0 |
P1 |
Строки 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
В табличном виде:
Объект |
Правило |
Носитель |
Q_n = {P0, P1, ..., P(n-1)} |
PLUS |
PLUS_n(P_i, P_j) = P((i+j) mod n) |
STAR, якорь слева |
STAR_n(P0, x) = P0 |
STAR, якорь справа |
STAR_n(x, P0) = x |
STAR вне якоря |
STAR_n(P_i, P_j) = PLUS_n(P_i, P_j), если i != 0 и j != 0 |
Дальше эти строки разворачиваются в полные таблицы. А таблицы уже можно проверить исчерпывающе.
10. Кого я ищу
Я ищу того, кто хочет взяться за развитие этих идей всерьез и вместе двигаться к системе, где каждое решение можно проверить.
Если вы:
искренне любите алгебру и формальную верификацию;
цените предельно строгую логику;
по-настоящему интересуетесь не очередной статистической моделью, а системой, где все проверяемо.
Тогда этот архив для вас.
Первая задача простая:
Возьмите L3 и вручную проверьте нарушение ассоциативности.
Возьмите L5 и найдите разделитель, показывающий, что STAR не является полевым умножением.
Запустите selfcheck.
Сравните ручной результат со скриптом.
Если найдёте ошибку — пишите не "мне кажется", а в таком формате:
check_id =
expected =
got =
where =
counterexample =
minimal_fix =
Вот такой разговор мне действительно интересен.
11. Заключение
Это не заявление о готовом ИИ.
Это второй шаг после первой статьи: сначала я привел идею табличного детерминированного движка, теперь показываю конкретный математический фундамент, который можно легко проверить.
Архитектура архива простая:
таблицы;
формулы;
контрпримеры;
selfcheck;
rc = 0.
Хотите проверить — архив открыт.
Хотите спорить — буду рад любой критике!
P.S.
Если среди читателей вдруг завалялся крутой разработчик LLM, который устал от вероятностного шаманства и хочет попробовать разработать систему, где каждый шаг действительно можно проверить, — пишите в личку.
Мне нужен именно тот, кто готов вместе думать, как сделать ИИ по-настоящему разумным, а не просто очень убедительным.
Комментарии (34)
not-allowed-here
26.05.2026 04:28читаю вторую статью - и видимо не способен понять базу - попробуйте сделать статью с Индексом Ноль - где дадите базовые понятия которыми вы оперируете (вполне возможно что имеет смысл сделать кроcc ссылки на ту статью #0 у понятий для удобоваримости при чтениии) в идеале опираясь на принцип - что каждая упоминаемая в статье формула сокращает число понимающих статью ровно в два раза....
на текущий момент число понимающих стремится к нулю к сожалению...
чисто психологический вам тяжело переключится, т.к. у вас в голове всё уже уложилось, но если вы пытаетесь найти единомышленников то вам придется много работать на удобствоа укалдывания материала и в их головах тоже.
rusfbm Автор
26.05.2026 04:28Давайте напишу сразу вам азы, чтобы не затягивать.
Базовый словарь GALO можно зафиксировать так:
Уровень L_n — это конечный слой модели. На уровне L_n есть не бесконечное пространство признаков, а конечный набор состояний, которые я называю полюсами: P0, P1, ..., P(n-1). В текущей версии рассматривается башня уровней L1–L7.
Полюс — это атомарная позиция внутри конечного уровня. Его не надо понимать как “нейрон”, “признак” или “токен” в обычном ML-смысле. Это элемент конечной алгебраической структуры, над которой можно строго проверить переходы.
Таблица Кэли — это таблица операции над полюсами. Если взять два полюса на одном уровне, таблица говорит, в какой полюс они переходят. В GALO такие таблицы не являются таблицами всех знаний о мире. Это нижний проверяемый слой, который задаёт допустимую операционную геометрию.
Операция — это правило перехода внутри уровня. В текущем ядре есть две базовые операции: PLUS и STAR. PLUS ведёт себя как циклическая операция сложения по конечному кругу. STAR устроена иначе: у неё есть специальное поведение около P0, поэтому её нельзя отождествлять с обычным умножением или с полевой алгеброй.
P0 — это особый граничный элемент. В STAR-логике он может работать как поглощающий якорь в одной позиции, но не является обычным нулём поля. Это важно: GALO не пытается бесконечно разворачивать экстремумы, неопределённости или недопустимые случаи. Такие случаи должны попадать в конечную границу: P0, fold, BOUNDARY или FAIL.
Маршрут — это не просто “клетка таблицы”. Маршрут — это типизированный способ применить операцию: слева, справа, через PLUS или через STAR. Поэтому есть базовые route-signatures, то есть строгие типы маршрутов, и есть конкретные переходы по ячейкам таблиц. В текущем атомарном контуре по башне L1–L7 получается 112 строгих route-signatures и 560 строгих типизированных переходов по ячейкам.
Формула в этой системе не является первичной истиной. Формула — это только сжатая реконструкция таблицы. Если формула и таблица расходятся, первичной остаётся таблица плюс воспроизводимая проверка. Поэтому здесь важен не красивый вид формулы, а возможность проверить каждую заявленную строку.
Witness — это машинный след проверки. Он должен показать: какой объект проверяли, где он лежит, какой вход был подан, какой результат ожидался, какой получился, какой статус и можно ли это воспроизвести. Без witness утверждение остаётся текстом, а не проверенным результатом.
PASS означает, что проверяемый слой прошёл свои условия воспроизводимости. FAIL означает, что найдено конкретное расхождение. BOUNDARY означает, что область применения закона закончилась или утверждение пока не доказано. Это не косметические статусы, а часть логики модели.
Контрпример — это минимальный воспроизводимый случай, где заявленный закон, переход, таблица или формульная реконструкция расходятся. Хороший контрпример должен отвечать на вопросы: какой был вход, что ожидалось, что получилось, где именно сломалось и какой минимальный фикс нужен.
Нейрон GALO не равен проходу по таблице. Таблицы — это нижний проверяемый слой. Поверх него работает более сложный контур: отбор устойчивых состояний, проверка инвариантов, редукция, память, откат и replay. Сеть из таких элементов добавляет обмен пакетами, локальные ограничения и контроль воспроизводимости. Поэтому это не “таблица + брутфорс всех клеток”.
Данные или LLM могут быть источником гипотез, признаков или входных наблюдений, но не источником истины для ядра. Истина появляется только после материализации в конечной структуре, проверки переходов, контрпримеров и replay.
Если коротко: GALO начинается не с бесконечной модели мира, а с конечного проверяемого ядра. Дальше любой закон, маршрут или нейронный шаг должен быть сводим к проверяемому переходу, witness и воспроизведению. Если это невозможно, система не должна выдавать уверенный ответ, а должна фиксировать FAIL или BOUNDARY.
rusfbm Автор
26.05.2026 04:28Дело в том, что здесь другой уровень сложности — мировоззренческий. На L3 есть три полюса: P0, P1, P2. И переходы между ними задаются не обычной логикой “истина/ложь/не знаю”, а таблицами операций. Особенно важно, что STAR на L3 не ведёт себя как привычное умножение или как обычная булева операция. У P0 там разное поведение слева и справа: в одной позиции он работает как поглощающий якорь, в другой — как правая граница, которая не уничтожает состояние. Уже это разрушает бытовую аналогию с нулём.
not-allowed-here
26.05.2026 04:28еще один такой корневой вопрос LUT вполне может противоречить Логике причем любой и при этом оставаться корректной для какой-то системы/формуле/правилу, т.е тут есть непрозрачное и жесткое непонимание того как оно будет работать...
чисто на LUT? в том плане что без формулы просто подстановка по таблице?
rusfbm Автор
26.05.2026 04:28Отвечу сразу на два вопроса:
Таблицы GALO могут противоречить классической логике поля или моноида. Именно поэтому я и не называю STAR ни полем, ни моноидом. Она не обязана быть ими. Она обязана честно пройти тот профиль, которы й для неё заявлен.
Поэтому это не любая LUT пригодна. Нет. Произвольная LUT — это просто сырой объект. В GALO важна не таблица сама по себе, а связка:
таблица;
заявленный закон;
формульная реконструкция;
проверка всех ячеек;
контрпример при нарушении;
статус: PASS или FAIL. И она работает. Это самое важное.То есть таблица не заменяет логику. Таблица делает логику конечной и проверяемой.
Причем:
P0,P1,P2в статье — это не биты и не физические частицы. Это метки конечных состояний внутри конкретного уровня.На самом простом уровне такая метка может быть почти элементарной. На более высоком уровне такая же метка уже может означать не один сырой объект, а свернутый класс состояния.
Например, если говорить совсем приближённо : на одном уровне я могу различать "плоская фигура / не плоская фигура", на другом — "круг / треугольник / квадрат", на третьем — уже свойства вроде симметрии, углов, границ, допустимых преобразований. То есть уровни нужны не для красоты, а чтобы не смешивать разные типы сложности в одну кашу.
В GALO эта идея доведена до башни конечных алгебр. У каждого уровня свой конечный язык, свои таблицы и свои правила проверки. Нижний уровень может быть грубым, верхний — богаче. Но при этом нельзя просто сказать: "пусть всё будет одним большим состоянием". Если при сворачивании потерялось важное различие, такой шаг должен быть запрещён или помечен как граница. Для этого и нужно обучать мой ИИ, чем я сейчас и занимаюсь.
Поэтому да, в некотором смысле состояние может быть упакованным и согласованным с симметриями башни (это отдельная статья большая). Но не как скрытый вектор и не как произвольная метафора. Оно должно иметь проверяемый паспорт: что именно сохранено, что отброшено, какая таблица это допускает, где свидетельство, где возможный контрпример.
В закрытой части проекта я как раз исследую более богатые уровни такой башни. Там уже речь не только о простых переходах вроде L3, но и о более сложных типизированных поверхностях. Например, у меня есть расчёты по выбранной поверхности Q108 для верхних уровней (L7). Я отдельно исследую, можно ли через такие поверхности описывать более сложные смысловые и эмоциональные состояния.
Но тут важна честная граница: в этой статье я не доказываю, что L7 уже полностью описывает человеческие эмоции, физику или "метафизику". Это было бы слишком сильным заявлением для текущего публичного текста. В статье я показываю только базовые аспекты: как конечная таблица задаёт проверяемый переход. В реальности все устроено намного сложнее.
Если сказать проще: L3 в статье — это игрушечный пример, чтобы руками увидеть принцип. А вся башня L1-L7 нужна затем, чтобы описывать состояния разной сложности, не теряя проверяемость. Чем выше уровень, тем богаче язык состояний. Но каждый уровень всё равно должен проходить через таблицы, свидетельства и контрпримеры.
Поэтому я бы сформулировал так: GALO не пытается "почувствовать" в человеческом смысле. Он пытается построить такую систему состояний, где даже сложные вещи — смысл, оценка, эмоциональный класс, переход между состояниями — можно будет не угадывать, а проверять. Интуиция при таком подходе становится вычислимой дисциплиной мышления. В этом смысле я действительно иду к более "живой" архитектуре, но через конечную математику, а не через туманную имитацию эмоций.
not-allowed-here
26.05.2026 04:28Например, если говорить совсем приближённо : на одном уровне я могу различать "плоская фигура / не плоская фигура", на другом — "круг / треугольник / квадрат", на третьем — уже свойства вроде симметрии, углов, границ, допустимых преобразований. То есть уровни нужны не для красоты, а чтобы не смешивать разные типы сложности в одну кашу.
во тут сразу возникает вопрос - а как реализуется связанность свойств между уровнями? как понять что у свойства уровня 1 есть связь с уровнем 2? например параллельность сторон имеет смысл для квадрата и большего числа граней а для треугольника бессмысленна даже в неевклидовых геометриях?
ну т.е. возьмем Аксиомы и Постулаты Евклида как их описать и связать в вашей системе ? Такое "описание" в конечном итоге позволит описать всю математику Евклида и будет отличным примером работоспособности методики. Я понимаю что с ТЗ практичности Лучше бы взяться за Гильберта - но там все сложнее а у нас счас задача понимание...
rusfbm Автор
26.05.2026 04:28Это сильный вопрос, потому что в GALO связанность свойств между уровнями не должна пониматься как автоматическое наследование: мол, если свойство есть на L1, значит оно само собой есть на L2, L3 и дальше.
Связь между уровнями должна задаваться явно: через допустимый мост между уровнями. Условно, если есть свойство на одном уровне, то для связи с другим уровнем нужно показать, что существует корректный перенос: что сохраняется носитель, что сохраняется операция, что не ломается смысл свойства, что нет потери различений, и что при переносе можно получить воспроизводимый witness. Если такого моста нет, свойство не переносится, а фиксируется как BOUNDARY.
Поэтому пример с параллельностью хороший. Сразу отмечу, что параллельность сторон не является универсальным свойством для любого уровня и любого объекта. Для треугольника в обычной евклидовой постановке оно либо неприменимо, либо требует другого контекста. В GALO это означало бы: у свойства “параллельность” есть область применимости. Если уровень или объект не содержит нужного числа направлений, сторон или отношений, то свойство не считается ложным или истинным.
С Евклидом я бы действовал так: для каждого сделал бы контракт, то есть где свойство определено, как оно проверяется, какие переходы допустимы, какой контрпример считается минимальным.
Например: если две прямые имеют такое-то отношение, то при допустимом переносе между уровнями должно сохраняться такое-то свойство; если не сохраняется, система должна показать конкретный witness: где сломалось, на каком объекте, что ожидалось и что получилось.
При этом надо понимать, что геометрия пространства в GALO в принципе не обязана быть евклидовой по умолчанию. Она строится от конечных уровней, полюсов, операций и допустимых мостов между уровнями. Например, механическая интуиция часто приводит к мысли (оно не трехмерное, как я писал ранее), что пространство двухполярно: есть контакт / нет контакта, есть сигнал / нет сигнала, есть притяжение / нет притяжения. Это ближе к бинарной логике L2.
Но уже на L3 появляется другая операционная геометрия: не просто “есть/нет”, а несколько различимых активных состояний. Поэтому некоторые вещи, которые в L2 выглядят как невозможные (телепортация, например) или неописуемые, на L3 могут иметь другой смысл. Например, не как физическое утверждение, что предмет/частица телепортнулся, а как модельная возможность представить объект или свойство не одной бинарной отметкой, а распределённой конфигурацией внутри конечной структуры (причём еще и циклической, спойлер: время, начиная с L3, также циклическое). В STAR-логике L3 это уже не сводится к обычному нулю и единице.
Поэтому да, если брать Евклида как демонстрационный пример, начинать лучше не с Гильберта, а с малого типа “Евклид #0”. Тогда будет видно, какие части евклидовой геометрии воспроизводятся в выбранной конечной структуре, какие требуют более богатого уровня, а какие сразу уходят в BOUNDARY.
Ключевой момент: GALO не говорит, что любое свойство обязано жить на любом уровне. Наоборот, свойство должно предъявить свой законный носитель, допустимые мосты и проверку. Если для параллельности нет нужной структуры, она не переносится. Если для постулата Евклида не хватает отношений, он не считается доказанным. Если перенос ломает различения, появляется контрпример. Именно так и должна строиться связность между уровнями.
not-allowed-here
26.05.2026 04:28То есть уровни нужны не для красоты, а чтобы не смешивать разные типы сложности в одну кашу.
и вот тут мы приходим к очень важному вопросу - как будут заполнятся таблицы - глубина модели может быть так-то бесконечной, вплоть до уровня достаточного для исключения объективной случайности процессов(квантовую физику пока исключим) и вот как понять достаточность глубины описания свойств модели? не получится ли что это решение через Брутфорс всех возможных состояний?
я уже примерно понимаю что верхние "деревья" ограничиваются влиянием нижних, для сужения "числа состояний модели" и что нижние также ограничены верхними для того чтобы сократить "число факторов влияющих" на "число состояний" - но тут же голимая экспонента по сложности и связанности - так что вопрос как именно предполагается формировать вот Эти самые таблицы и потом верифицировать их соответствие?
таблица - туту прост можно сгенерить через LLM или взять экспериментальные данные с достаточной дискретностью - по сути наборы признаков и их взаимодействие;
заявленный закон - туту сложнее по стуи надо описать понятным псевдо языком логику по которому взаимодействуют признаки из п.1;
формульная реконструкция - компиляция в математический корректный код описания из п.2;
проверка всех ячеек - валидация таблицы через прогон через код из п.3;
контрпример при нарушении - поиск коллизий / ошибок по факту работы кода из п.3 - должна сформировать что? что подразумевается под контрпримером? по сути Даже если мы сделали корректный закон и правильно реконструировали у нас ведь всё равно могут быть экстремумы, особенно на данных из реального мира;
статус: PASS или FAIL - вот тут не понятно по факту п.4. с формируется таблица проблем из п.1. - нужны корректирующие действия для п.2 и п.1(?) и потом по кругу.
примерно так?
not-allowed-here
26.05.2026 04:28дополню с учетом комментария выше:
декомпозиция:
сначала задаём область задачи;
потом выделяем классы состояний - вот тут как я понимаю появляется "дерево состояний"?;
потом выбираем признаки, которые нельзя потерять - а вот тут появляются критические ветви деревьев на разных уровнях;
потом строим конечные носители уровней;
Определение закона:
потом задаём операции - туту сложнее по стуи надо описать понятным псевдо языком логику по которому взаимодействуют признаки из декомпозиции;
Создание таблиц:
потом получаем таблицы переходов - а вот ту снова стало не понятно к чему именно из Декомпозиции привязаны Таблицы- потому что если определять данные не из задачи или внешних данных а из "закона" валидация потеряет смысл + я так понимаю LUT таблицы обогащают дерево вариантов состояний? ;
Валидация - потом проверяем, что переходы не ломают нужные инварианты:
формульная реконструкция - компиляция в математический корректный код описания из п.2;
проверка всех ячеек - валидация таблицы через прогон через код из п.3;
контрпример при нарушении - поиск коллизий / ошибок по факту работы кода из п.3 - должна сформировать что? что подразумевается под контрпримером? по сути Даже если мы сделали корректный закон и правильно реконструировали у нас ведь всё равно могут быть экстремумы, особенно на данных из реального мира;
статус: PASS или FAIL - вот тут не понятно по факту п.4. с формируется таблица проблем из п.1. - нужны корректирующие действия для п.2 и п.1(?) и потом по кругу.
rusfbm Автор
26.05.2026 04:28туту прост можно сгенерить через LLM
Нельзя, моя личная практика показывает, что чатгпт 5.5 можно с горе пополам обучить различать L3 , L4, далее очень и очень приближенная аналогия. Для получения человекочитаемых мыслей можно использовать логику IER: интенция - доказательство - риск, — и прогонять утверждения по таблицам. Если уж речь зашла о маршрутах мышления, то надо писать отдельную статью и разбирать ваши примеры. Позже займусь этим.
rusfbm Автор
26.05.2026 04:28Да, направление мысли близкое, но я бы уточнил несколько важных моментов.
Во-первых, таблицы в этой архитектуре — это не священные таблицы Моисея, на которые нужно молиться, и не эмпирическая матрица, которую можно просто сгенерировать в LLM. Это конечное проверяемое ядро: базовая операционная геометрия, которая задаёт, какие переходы допустимы, как они воспроизводятся и где можно получить локальный контрпример (хотя корректнее говоритб witness).
Во-вторых, модель не сводится к проходу по клеткам таблиц Кэли. В текущем атомарном контуре у меня зафиксировано 112 строгих рут-переходов по башне L1–L7: это 4 типа действий на каждый полюс башни (кстати, получается подобие математического вихря, право- и левоврашающего, но об этом потом). Если развернуть их уже в конкретные переходы по ячейкам таблиц, получается 560 типовых транзиций. То есть это не одна священная таблица , а проверяемая система маршрутов и переходов.
Но и это ещё не вся логика нейрона. Эти 112 маршрутов и 560 табличных переходов — нижний строгий слой. Поверх него работает более сложный нейронный контур: отбор устойчивых состояний, проверка инвариантов, редукция, память, откат и реплэй. А сеть из таких элементов добавляет обмен пакетами, локальные ограничения и контроль воспроизводимости. Детали внутреннего механизма я пока публично не раскрываю, но принципиально это точно не “перебор всех клеток”.
Поэтому это не брутфорс всех возможных состояний мира. Таблицы ограничивают базовую алгебру, а верхние контуры допускают к дальнейшей обработке только те переходы, которые проходят проверяемые условия. Если переход, закон или реконструкция не совпадают, это не маскируется вероятностной уверенностью, а фиксируется как FAIL или BOUNDARY.
Контрпример, хотя вернее говорить witness, здесь — это не просто экстремум в данных реального мира. Это минимальный воспроизводимый случай, где заявленный закон, таблица, переход или реконструкция расходятся: какой был вход, что ожидалось, что получилось, на каком слое и в какой проверке возникло расхождение. После этого корректируется либо закон, либо дискретизация, либо допуск к применению этого закона.
LLM или экспериментальные данные могут быть источником гипотез или входных признаков, но не источником истины для ядра. Истина появляется только после табличной материализации, контракта, проверки переходов, контрпримеров и replay. Поэтому PASS/FAIL — это не просто результат “прогона модели”, а статус воспроизводимости конкретного слоя.
Итого: таблицы Кэли — это не вся модель, а нижний проверяемый слой. Сам ИИ работает не только через переходы по ячейкам, а через многоступенчатый конечный контур: допустимый переход → проверка устойчивости/инвариантов → редукция → witness → replay → PASS/FAIL/BOUNDARY.
Ещё важный момент: в этой логике я не пытаюсь работать с бесконечностями или экстремумами как с настоящими, истинными бесконечными областями поиска. Математика здесь конечная и детерминированная: если внешний случай уходит в экстремум, неопределённость или недопустимое состояние, он не разворачивается в бесконечный перебор, а должен попасть в конечную границу: якорь, fold, BOUNDARY или FAIL.
Внутри табличного ядра роль такой видимой границы во многих случаях играет P0. Но это не обычный ноль из поля и не магическая черная дыра, куда всё схлопывается. В STAR-логике P0 является поглощающим якорем в одной позиции: STAR(P0, x) = P0. При этом в другой позиции он ведёт себя иначе: STAR(x, P0) = x. Поэтому P0 — это не грубое зануление смысла, а контролируемая граничная точка с разными законами слева и справа.
Именно поэтому подход не терпит бесконечных хвостов, скрытых вероятностных уверенностей и неограниченных экстремумов. Если состояние нельзя законно провести через конечные таблицы, инварианты, witness и replay, оно не принимается как истина. Оно фиксируется как граница или ошибка, с указанием места расхождения.
rusfbm Автор
26.05.2026 04:28Ниже ответил, но в общем все намного сложнее, так как это не брутфорс всех возможных состояний. В текущем атомарном контуре есть 112 строгих путей по башне L1–L7 и 560 строгих типизированных переходов по ячейкам таблиц. Но нейрон не просто перебирает эти переходы. Таблицы — это нижний слой верификации. Поверх него работает более сложный контур: отбор устойчивых состояний, проверка инвариантов, редукция, память, откат и replay. А сеть из таких элементов добавляет обмен пакетами, локальные ограничения и контроль воспроизводимости.
Real_Egor
Проблема в том, что чтобы выдать тебе "Критику по существу", нужно сначала до того самого "существа" добраться...
Ты сначала в шапке статьи сказал, что детально ключевого не расскажешь...
А потом с места в карьер, сразу к формулам. Даже не потрудившись написать, для каких задач это применимо, в чем смысл и логика этих формул...
Больше того скажу, даже скормив твой текст статьи в ЛЛМ, я лишь с третьего промпта добился от нее интерпретации на человеческом языке в виде примера, и все еще не понял, как эти самые решения в таблицу попадают. То есть поле применимости этой идеи так же непонятно, как и сама идея, если не сильнее.
Попробуй мысли описать обычными словами, с метафорами и аналогиями. Только после этого можно рассчитывать на конструктивную критику...
rusfbm Автор
Спасибо за вопрос! Все верно сказано! Я действительно слишком необычно перешел к основе основ разумного интеллекта и не объяснил, как это связано с вычислениями.
Попробую нормальным языком.
Таблица STAR в статье — это не весь GALO AI и не одна таблица, которая за все отвечает. Это первооснова, фундаментальная единица. Я специально начал с нее, потому что к ней не придраться: есть конечная таблица, есть ячейка, есть результат, есть контрпример. Но в то же время это очень сложно для понимания, потому что Вы привыкли мыслить бинарно. Далее можно написать целый философский трактат и перейти к квантовым вычислениям...
А сам движок устроен намного сложнее.
Сама идея (и она рабочая , я сейчас приступаю к обучению моего ИИ) такая: GALO работает не с одной алгеброй, а с целой башней конечных алгебр (всего их 7 как я писал в комментариях к первой статье). У каждого уровня свой набор состояний, свои таблицы PLUS и STAR, свои переходы и свои проверки. Уровень сложности такой, что даже на третьем уровне, который я привёл для примера, уже сыпется привычная логика и математика. Поэтому входная ситуация не прогоняется через один плоский автомат (отсылка к мультфильму "Плоский мир"). Она рассматривается сразу на нескольких уровнях.
Если совсем грубо, составной нейрон делает несколько шагов.
Сначала он пытается разобрать вход не как "строку текста", а как набор проверяемых элементов. Что здесь объект? Что операция? Что условие? Что ожидаемый результат? Где можно построить свидетельство? Где возможен контрпример?
Потом эти элементы поднимаются по башне уровней L1-L7. Это важно: один уровень может быть слишком грубым. Если всё схлопнуть в один бинарный слой, часть различий потеряется. Поэтому GALO смотрит на состояние многополярно: один и тот же объект проверяется через несколько конечных табличных проекций.
Дальше начинается сворачивание. Обычная модель часто таскает за собой большое скрытое состояние. Я пытаюсь делать иначе: не переносить всё сырьё дальше, а выделять минимальный инвариантный паспорт. То есть такую часть состояния, которая действительно нужна для следующего шага и при этом не стирает важные различия.
Если при таком сворачивании потерялось то, что нельзя было терять, шаг не должен пройти. Система должна сказать: здесь граница, здесь потеря различия, здесь нужен контрпример или откат.
Затем составной нейрон проверяет переходы по таблицам, в том числе смотрит, сохранились ли нужные инварианты, не разрушилась ли связь между уровнями, можно ли предъявить свидетельство.
Если всё прошло — шаг принимается.
Если не прошло — система не должна уверенно писать красивый текст. Она должна выдать: ожидалось вот это, получилось вот это, ошибка здесь, минимальный контрпример такой.
Вот в этом и разница с обычной языковой моделью. Там ответ рождается из статистического продолжения. В GALO я пытаюсь строить ответ как цепочку проверяемых переходов.
В чем тогда кльчева роль таблицы STAR из статьи?
Она показывает наименьший пример такого проверяемого перехода. Мы берем обычную таблицу сложения по модулю, меняем одну строку и сразу видим: структура перестала быть полем, кольцом и моноидом. Но при этом она осталась полностью конечной и проверяемой. Любой спор решается не словами, а ячейкой таблицы.
Например, если кто-то заявит, что это просто умножение поля, я покажу одну ячейку:
STAR(P1, P0) = P1
А в поле умножение на ноль дало бы P0.
Значит, claim падает.
Где это применимо? На первом этапе не для всеот на свете, но только на первом. Естественная область, которая сразу приходит на ум, — задачи, где есть конечные состояния, правила, переходы, свидетельства и критически важна проверяемость:
формальные процедуры;
конечные автоматы(я разработал целую теорию применительно к своему движку);
протоколы;
юридически проверяемые цепочки;
символьные рассуждения;
Другие задачи (их миллион), где ошибка должна давать точный контрпример.
Поэтому да, Вы правы: по одной таблице STAR нельзя понять весь GALO AI. Но эта статья и заявлена как фундамент и как фильтр, направленный на поиск партнёра по разуму. За ней стоит более сложный составной нейрон: он выделяет проверяемые элементы, поднимает их по нескольким алгебраическим уровням, сворачивает состояние до инвариантного паспорта, проверяет переходы по таблицам и фиксирует результат через свидетельство.
Внутреннюю схему я пока не раскрываю. Но общий смысл такой: я хочу строить не систему, которая "угадывает", а систему, которая каждый шаг обязана провести через проверяемую конечную математику. Продолжение следует.
Real_Egor
Что-то я пропустил момент, когда и главное "для чего" они появились. Как ниже писал другой комментатор, сначала нужно сделать статью с индексом ноль. Объяснить, что за задачу ты решаешь, какие подходы отвергаешь, какие используешь. Как задачу декомпазируешь и как проверяешь результат. И оттуда уже вести к таблицам и ячейкам.
Для того, кто просто общается с ЛЛМ, наличие таблицы, ячейки и результата в обыченом диалоге - это что-то из ряда вон выходящее, а не вводная и самодостаточная мысль
А ниже по тексту твоего комментария ты плывешь между умозаключениями:
- как все сложно
- ссылаешься на другие мысли и статьи, сразу поясняя что все сложнее и не так тривально
- какие наблюдения ты уже делаешь
резюмирую и предлагаю тебе перейти к комментарию ниже, про фазу "ноль"
Абстрагируйся от идей и опиши фундамент, Задачу / проблемы / базовые гипотезы и аксиомы / подходы и отвергнутые идеи / оставь читателя с вопросами, которые вытекают из предыдущего, но которые еще далеки от самих идей. Только тогда ты получишь того, кто готов к таблицам и уже сможет придумать им применение в голове
rusfbm Автор
Да, согласен. Вы правы: я снова перескочил через "нулевую фазу".
Я начал объяснять с таблиц, потому что для меня это фундамент. Но для читателя это действительно выглядит странно...
Попробую сформулировать проще.
Задача, которую я решаю, не в том, чтобы просто сделать ещё один генератор текста. Меня интересует система, где вычислительный шаг можно проверить. Не задним числом объяснить красивыми словами, а именно проверить: было состояние, было правило, был переход, есть результат, есть свидетельство. Если шаг неверный — должен быть конкретный контрпример.
Проблема обычных языковых моделей для такой задачи в том, что внутри у них нет простой проверяемой единицы рассуждения. Есть огромный скрытый числовой слой, вероятности, веса, но трудно указать: вот конкретная ячейка, где решение было принято, вот точное место ошибки, вот минимальный контрпример.
Поэтому я начал свой путь не от текста, а от конечных состояний и таблиц. Таблица здесь — не украшение и не самоцель. Это способ задать закон перехода так, чтобы его можно было полностью проверить.
Поиведу аналогию: , LLM похожа на человека, который говорит: "мне кажется, правильный ответ такой". А я хочу построить механизм, который говорит: "я сделал такой переход, потому что в этой таблице в этой строке и этом столбце стоит такой результат".
Дальше уже появляется вопрос: какую минимальную таблицу взять, чтобы продемонстрирвать подобный принцип мышления? В статье я привел простейший пример: обычное сложение по модулю и одну изменённую строку. Так появляется STAR. Она не объясняет весь GALO AI, но показывает первый важный ход: маленькая конечная таблица может задавать нетривиальный, проверяемый и не классический переход.
То есть Вы правы: перед этой статьёй нужна нулевая статья. В ней нудно было не показывать формулы, а объяснить границы:
какую задачу я решаю;
почему мне не хватает вероятностного ответа;
почему я хочу проверяемый переход;
почему конечная таблица удобна как источник истины;
почему ошибка должна давать контрпример;
и только потом переходить к PLUS, STAR и таблицам Кэли.
Сейчас я понимаю, что без этой вводной части статья выглядит так, будто я достал формулы из воздуха. Хотя для меня они появились как ответ на более базовую задачу: как построить вычисление, которое не угадывает, а проверяется.
Спасибо, это полезное замечание. Видимо, следующую публикацию действительно надо делать как "нулевую": не про STAR, а про саму постановку задачи и почему я вообще пришёл к табличной математике.
Real_Egor
уже ближе к пониманию. Хотя все еще остается разрпыв между "ЛЛМ - которая выдает по одному токену за раз, при этом каждый раз перед выдачей всего одного токена, она прогоняет полный цикл предсказания" и "таблица, которая поможет все проследить"...
как это у тебя стыкуется? У тебя ЛЛМ должна будет заполнять таблицу по ячейкам, это рамки ее размышления?
- Вероятно это в чем-то поможет
- Это никак не уберет тот самый черный ящик предсказания, ты лишь поставишь границы, куда вписать следующий токен
- Эта механика будет сильно сбоить с дрессировкой RLHF. Если там не было такой механики, то модель постоянно будет скатываться в привычки
а если у тебя наоборот, эти таблицы будут внутри размышления о каждом следующем токене... То мы говорим о чем-то сильно глубже, фундаментально ином алгоритме и архитектуре трансформе ЛЛМ, уже даже не трансформере...
not-allowed-here
о чем и речь тут такой концептуальный проект который очень интересен - сама идея довольно таки интересна хоть и не могу пока сказать что понимаю как работает оно изнутри и работает ли вобще.
Real_Egor
так, ты опять запутал только ))
попробуй спозиционировать
1) где эти таблица в отношении выводимиого ЛЛМ токена? или внутри архитектуры трансформеров или снаружи?
2) Как они вообще будут заполняться? как будет определяться состав колонок/строк в этих шахматках? (мне для себя проще их так называть)
З.Ы. Я тоже занимаются разработкой алгоритмов мышления, хотя я пошел совсем иным способом и путем (см статью, в ней есть ссылка на репозиторий, как раз последние несколько дней выкладываю новые версии протоколов туда)
not-allowed-here
вот бы еще реально понимать... +))
но вот из того что понял тут нет токена как идеи по сути она оперирует состояниямии систем - т.е. она не сгенерирует текст напрямую, но проверит и создаст стейт который опишет всю логику которую будет содержать этот текст или она не напишет код, но сгенерирует алгоритм который доказуемо будет покрывать нужный стейт. это имено МОЗГ, а не язык.
как заполннение будет тут вопрос к Автору - но думаю вполне можно генерить на LLM такие таблицы с последующей верификацией и авто корекцией.
я Уже сейчас могу придумать пару прикладных задачек которые настолько не определяемы что там будет очень сложно определить параметры и их влияние и то как их учитывать.
Real_Egor
1) сорри, я хотел ответить Автору статьи, а тегнул твой комментарий
2) Я не представляю себе, чтобы ЛЛМ выдавала такую таблицу ВМЕСТО токенов, так как тут прийдется не только архитектуру платформеров изменить, но и механику обучения и, что самое трудоемкое, разработать дата-сеты под такое обучение
3) предлагаю пытаться добыть информацию из головы Автора, а не гадать между собой. Мы так очень далеко от темы уйдем -)
rusfbm Автор
Приведите любое утверждение, я сходу найду в нём ядро рассуждения по башне L1 - L7. В природе нет стохастики — есть неверное различение полярностей
not-allowed-here
она чуток игровая - "задача продажи ноутбука" - надо определить критический путь и те параметры которые будут критичны для ускорения продаж конкретным категориям людей Мужчине, Женщине, ИТ-специалисту(обоих полов), Нёрду(обоих полов), Закупщику Техники(обоих полов).
по сути задача сводится к построениею модели приоритезации вывода параметров критичных для каждой категории покупателей. И она не детерминируется к сожалению - слишком большая ширина и глубина модели, а еще огромное объем перекрестного влияния.
rusfbm Автор
Ответ по поводу задачи продажи ноутбука, максимально короткий ответ, по делу, без всей трассировки в реальной нейронке, получился все равно очень длинным, сократить его нельзя. Ниже пример первичной тррассировки подобных задач. В реальной нейронке все сложнее будет.
Итак, рассмотрим задачу поиска маршрута в многополярном пространстве:
В линейной логике L2 всё сразу схлопывается в пары: купит/не купит, дорого/дёшево, хороший/плохой, подходит/не подходит. Но такая логика слишком грубая. Она не различает, почему именно человек сомневается: из-за цены, из-за доверия, из-за состояния, из-за нехватки тестов или из-за того, что ему вообще не показали его сценарий.
Если провести задачу через GALO-логику, то на L3 уже видно первое расхождение с обычным мышлением.
На L3 я бы разметил так:
P0— граница решения: стоп, отказ, зависание, не понял / не верю.P1— рационально-технический интерес.P2— сценарный интерес: для чего мне это.И здесь уже появляются реальные переходы по таблице, а не просто слова. Например, если человек находится в
P2, то есть ему нужен сценарий — работа, учёба, поездки, ребёнку, домой, — а ему сразу дают жёсткий технический критерийP1, маршрут может уйти вP0. То есть он не стал тупым покупателем; просто к нему применили не ту операцию.Обратный случай такой же: человек в
P1, его интересуют характеристики железа , а ему говорят “стильный, удобный" и прочую чушь. Для него это тоже может датьP0, потому что сценарная подача не закрывает технический полюс.Вот это уже похоже на то, что в философских примерах происходит при переходе от двухполярности к L4/L5. В L2 кажется, что есть только плюс и минус. Но когда появляется L4, возникают дополнительные полюса. А в L5 уже появляются состояния вроде возмущение, мера, посветление которые в L2 будут выглядеть парадоксом. Не потому что там мистика, а потому что L2-проекция теряет часть полюсов.
То же самое с ноутбуком. В линейной логике дёшево должно помогать продаже. Но в многополярной логике дёшево может и ускорить, и убить продажу — зависит от того, в каком полюсе сейчас покупатель.
На L5 я бы разметил задачу так:
P0— граница/стоп-фактор.P1— цена/выгода.P2— физическое состояние.P3— сценарий использования.P4— доказательства: фото, тесты, батарея, диагностика.И тут нейронка уже нашла бы несколько характерных соотношений.
Например,
P1 + P2 -> P3: цена плюс состояние дают сценарий. То есть “недорого и в хорошем состоянии” само по себе ещё не продажа; это должно превратиться в понятный сценарий: для учёбы и пр.Другое соотношение:
P2 + P4 -> P1. Состояние плюс доказательства возвращают покупателя к цене. То есть если состояние подтверждено тестами, фото, батареей и диагностикой, тогда цена начинает восприниматься как ценность, а не как случайная цифра.Но самое интересное появляется не на обычном
PLUS, а наSTAR_RIGHT, потому что это уже не мягкий сдвиг, а жёсткий критерий. В GALOSTAR_RIGHTможет схлопнуть разные источники вP0. И вот здесь видно, почему продажа не равна “покажи больше параметров”.Если применить цену как жёсткий критерий слишком рано, она может схлопнуть покупателя, который сейчас находится в полюсе доверия или доказательств. Для закупщика дёшево без документов — не плюс, а риск. То есть цена работает только после правильного маршрута, а не сама по себе.
На L7 картина становится ещё точнее. Я бы задал такую разметку:
P0— критическая граница: либо закрытие сделки, либо отказ; тут нужен witness, чтобы не спутать одно с другим.P1— доверие: продавец, документы, гарантия, легальность.P2— состояние: корпус, экран, батарея, износ, дефекты.P3— сценарий: работа, учёба, поездки, игры, дизайн, офис.P4— производительность: CPU, RAM, SSD, GPU, охлаждение.P5— доказательства: тесты, диагностика, температуры, отчёты.P6— цена/ценность.И вот какие характерные пары здесь находятся:
P1 <-> P6— доверие и цена.P2 <-> P5— состояние и доказательства.P3 <-> P4— сценарий и производительность.Это очень важные пары.
Первая пара: доверие и цена.
Если человек сейчас проверяет доверие (
P1), а ему дают только цену (P6), он может уйти вP0. Для закупщика это прямо типовой случай: “дёшево” без документов, гарантии, серийников и условий возврата — это не ускорение продажи, а красный флаг. Но если человек уже спрашивает про цену, а ему вместо экономической логики отвечают только “я честный продавец”, это тоже не закрывает маршрут.Вторая пара: состояние и доказательства.
Фраза состояние отличное без фото, диагностики и батареи плохо работает для ИТ-специалиста. Но и обратное тоже верно: тесты без нормального описания состояния могут выглядеть как попытка спрятать внешний дефект за цифрами. Поэтому правильный маршрут здесь не
P2отдельно и неP5отдельно, а связка: состояние → доказательства → цена.Третья пара: сценарий и производительность.
Обычному покупателю сначала нужен
P3: “для чего мне этот ноутбук”. И только потомP4: какие характеристики это обеспечивают. А для ИТ-специалиста и нёрда наоборот: сначалаP4иP5, то есть железо и подтверждения, а уже потом сценарий. Если перепутать порядок, аргумент может не усилить продажу, а схлопнуть маршрут вP0.Теперь по категориям.
Для обычного покупателя маршрут был бы примерно такой:
P3 -> P2 -> P6 -> P1 -> P5То есть сначала сценарий: работа, учёба, дом, поездки. Потом состояние. Потом цена. Потом доверие. Потом базовые доказательства. Если начать с железа, можно просто перегрузить человека.
Для ИТ-специалиста маршрут другой:
P4 -> P5 -> P2 -> P6 -> P1Сначала железо, потом тесты. Потом состояние. Потом цена. Потом документы. Здесь сценарная реклама типа “стильный и для всего” может работать против продажи.
Для профи ещё жёстче:
P5 -> P4 -> P2 -> P6Сначала доказательства: температуры, стресс-тесты, матрица, батарея, BIOS, ограничения. Потом производительность. Потом состояние. Потом цена.
Для закупщика:
P1 -> P2 -> P5 -> P6Сначала документы, гарантия, легальность, серийники, условия возврата. Потом состояние. Потом доказательства. Потом цена. У закупщика цена без
P1часто не аргумент, а риск.А вот пол — мужчина/женщина — я бы не ставил главным полюсом. Нейронка, скорее всего, вернула бы по этому признаку BOUNDARY: слишком слабый параметр. Намного важнее не пол, а активная полярность покупателя: он сейчас в сценарии, в цене, в доверии, в состоянии, в производительности или в доказательствах.
Ключевая закономерность такая: параметр сам по себе ничего не значит. Он получает силу только в правильной операции.
PLUS— это мягко добавить новый смысл.Например: к сценарию добавить состояние, к состоянию добавить цену.
STAR_LEFT— это сильно предъявить аргумент от продавца.Например: сразу показать тесты нёрду или документы закупщику.
STAR_RIGHT— это жёсткий критерий покупателя.И вот он опасен: если применить не тот критерий не к тому состоянию, маршрут может уйти в
P0.Поэтому это не брутфорс всех состояний. Нейронка не должна перебирать все параметры ноутбука. Она должна понять, в каком полюсе находится покупатель, какая операция сейчас допустима, какую пару нельзя схлопнуть и какой следующий шаг нужен.
Если коротко: в линейной логике мы спрашиваем “какие характеристики важны покупателю?”. В многополярной логике вопрос другой: “какой параметр сейчас является законным следующим ходом, а какой преждевременно схлопнет маршрут в
P0?” Вот в этом и отличие.rusfbm Автор
Да, вы почти правильно уловили главное. Попробую ответить по пунктам.
Где таблицы ?
Они не находятся внутри трансформера. Это не слой трансформера и не часть обычной генерации следующего токена. Это вообще не LLM, вот вообще, никак!
В языковой модели токен — это кусок текста. Модель берёт предыдущий текст и предсказывает следующий кусок текста. В GALO я думаю иначе: первичен не текстовый токен, а проверяемое состояние системы.
То есть таблица не отвечает на вопрос "какое слово написать дальше?". Она отвечает на другой вопрос: "если система находится в таком состоянии и к ней применено такое действие, какой проверяемый переход разрешён?"
Поэтому да, в вашем описании есть важная точность: это скорее не язык, а мыслительный контур. Но я бы сказал аккуратнее: это не готовый мозг или супер мозг Грок, а попытка построить проверяемое ядро рассуждения.
Текст в такой схеме — внешний слой. Его можно получить потом, а можно закодировать так, что он будет органично выводиться в этой системе. Поверьте, так можно сделать. Например:
сначала система строит внутреннее состояние;
потом проверяет переходы по таблицам;
потом получает подтверждённый каркас рассуждения;
и уже после этого этот каркас можно выразить человеческим текстом или кодом.
С кодом то же самое. Цель не в том, чтобы сразу написать код наподобие языковой модели. Цель в том, чтобы сначала построить проверяемую схему решения: какие состояния есть, какие переходы допустимы, какие ограничения должны сохраниться, где свидетельство правильности. А уже потом это можно переводить в код. И уже потом можно навернуть GALO -лингвистику.
То есть если очень кратко:
языковая модель работает с текстом;
GALO работает с проверяемыми состояниями;
текст или код — это уже способ вывода результата наружу.
Если когда-нибудь языковая модель будет использоваться вместе с GALO, то она не должна быть источником истины. Она может быть переводчиком между человеческим текстом и внутренним состоянием. Источник истины — таблица, правило, проверка и свидетельство.
Как заполняются строки ?
Тут важно: таблицы не заполняются произвольно.
Сначала нужно определить конечный язык уровня. То есть какие состояния этот уровень вообще умеет различать. После этого задаются допустимые операции и только потом строится таблица переходов.
В статье пример очень маленький: на уровне L3 есть три состояния:
P0, P1, P2.
Строка — текущее состояние.
Столбец — действие или второй аргумент операции.
Ячейка — результат перехода.
Для PLUS таблица заполняется по правилу сложения по модулю. Для STAR — по правилу якоря P0. То есть таблица не угадывается, а строится по закону и затем проверяется по всем ячейкам.
В прикладной задаче всё сложнее. Там нельзя просто взять любые параметры и разложить их в таблицу. Сначала надо понять, что именно мы считаем состояниями.
Например, объект можно описывать не как картинку, а как проверяемый набор свойств: какие повороты его сохраняют, какие отражения его сохраняют, какие переходы допустимы, что меняется, что не меняется. Но в случае геометрии по башне L1-L7 у меня уже наработана определённая база, там все сложнее.
В итоге строки и столбцы таблицы возникают напрямую из выбранного конечного различения:
какие типы состояний различаем;
какие симметрии учитываем;
какие действия разрешены;
какие переходы считаем допустимыми;
какие различия нельзя потерять.
Если задача слишком размыта и непонятно, какие состояния выделять, GALO не должен делать вид, что всё понял. Правильный ответ в таком случае: текущий уровень описания недостаточен. Нужно уточнить язык состояний, добавить другой уровень или признать границу применимости.
Это важнее, чем кажется. Обычная модель может уверенно написать ответ даже там, где постановка плавает. В GALO такой шаг должен останавливаться: нет конечного языка — нет честной таблицы; нет таблицы — нет проверяемого перехода; нет проверяемого перехода — нет доказанного результата.
Поэтому прикладной процесс выглядит примерно так:
сначала задаём область задачи;
потом выделяем классы состояний;
потом выбираем признаки, которые нельзя потерять;
потом строим конечные носители уровней;
потом задаём операции;
потом получаем таблицы переходов;
потом проверяем, что переходы не ломают нужные инварианты.
Если объект не помещается в текущую шахматную доску, его нельзя насильно туда запихнуть. Например, уровень, описывающий симметрии плоских фигур, не обязан корректно описывать тетраэдр или шар. Для них нужен другой язык состояний и, возможно, другой уровень. И сразу замечу, наблюдаемый мир с этих позиций вовсе не трехмерный, это иллюзия ,
В этом и смысл башни уровней: разные уровни видят объект с разной глубиной. Нижний может видеть грубую классификацию, верхний — более тонкие симметрии и связи. Но каждый уровень всё равно должен быть конечным и проверяемым.
Так что да, в реальных задачах это сложно и вызовет кучу споров, например, насчет ложности трёхмерного пространства. Некоторые задачи сначала вообще нельзя сразу уложить в таблицу. Их нужно разобрать, выделить состояния, понять симметрии, границы, допустимые переходы. Но это не недостаток подхода, а его фильтр честности: если не смогли формализовать состояние, система не должна притворяться, что всё посчитала.
L3 в статье — это микроскопический пример. Он показывает не всю архитектуру, а принцип: состояние, действие, таблица, ячейка, проверка. В настоящем применении таких уровней больше, состояния богаче, а таблицы работают не как игрушка, а как проверяемый каркас рассуждения.
Real_Egor
я все таки все сильнее плыву в попытке понять... а где же облако задач, к которыи применим твой подход? только то, что расписано так детально, что ты сможешь разложить на все потенциальные состояния? так таким задачам не решатель нужен, а надзиратель (чтобы просто не ленились)
в общем приведи хоть пару примеров задачи и декомпазиции на таблицу и состояния
rusfbm Автор
Вот привел https://habr.com/ru/articles/1039330/#comment_30023014
rusfbm Автор
Насчет фундаментальных алгоритмов мышления могу накатать статью по их классификации. Я посмотрю твой репозиторий позже, напишу ответ
rusfbm Автор
Вы рассуждаете о токене в смысле LLM. В GALO токен устроен иначе.
Токен там не равен слову, букве, BPE-фрагменту или “следующему токену”. Это минимальный инвариантный носитель: фрагмент входа сначала поднимается в башню L1–L7, проверяется через табличные переходы, W-профиль и пр. спецвещи, условия фолдинга/фибры и реплэй. Если этот фрагмент нельзя воспроизвести как устойчивый инвариант, он не становится токеном в строгом смысле.
По поводу чёрного ящика: если просто взять обычную RLHF-модель и сверху навесить правила, то да, чёрный ящик никуда не исчезнет. Модель будет продолжать предсказывать привычные токены, а правила будут только фильтром. Это слабая архитектура.
С RLHF вы тоже правы: если такую механику держать внутри уже надрессированной LLM, она будет постоянно скатываться в привычные паттерны. Поэтому RLHF не должен управлять ядром, и в идеале вообще LLM не должна соприкасаться с подобной архитектурой. Максимум на первых порах — интерфейс, черновик, переводчик на человеческий язык. А ядро отдельно говорит: этот фрагмент стал минимальным инвариантным токеном или нет; это отношение допустимо или нет; этот пакет получил receipt или нет; этот вывод проходит replay или уходит в FAIL/BOUNDARY.
То есть GALO совсем не про это. Там токен — не предсказанный кусок текста, а проверенный инвариантный объект. И дальше ИИ работает не через “угадай следующий токен”, а через связку: token admission → lawful relation → packet → receipt → reduction/fold → witness/replay.
rusfbm Автор
Добавлю ещё проще, без пафоса, на примере уровня L3.
Возьмём всего три состояния:
P0, P1, P2.
Это можно представить как маленький конечный автомат. Только вместо того чтобы рисовать кружки и стрелки, я задаю все таблицей. Таблица в таком подходе и есть полное описание автомата: в какой строке стоим, какой столбец выбираем, в какую ячейку попадаем.
Например, для PLUS по L3 таблице можно рассуждать так:
Имеем текущее состояние P1 и действие P1, то смотрим строку P1 и столбец P1. Получаем P2.
То есть переход такой:
P1 + P1 -> P2
Если состояние P2 и действие P1, то строка P2, столбец P1. Получаем P0.
P2 + P1 -> P0
Это обычный цикл по модулю 3.
Теперь рассмотрим STAR на том же L3:
Здесь почти всё как в PLUS, кроме строки P0. Если автомат попал в строку P0, то любое действие оставляет его в P0:
STAR(P0, P0) = P0
STAR(P0, P1) = P0
STAR(P0, P2) = P0
То есть P0 слева работает как якорь-поглотитель.
А если P0 стоит справа, то он не меняет состояние:
STAR(P1, P0) = P1
STAR(P2, P0) = P2
Вот здесь и появляется отличие от обычного умножения поля. В поле умножение на ноль дало бы ноль, а здесь справа P0 сохраняет состояние.
Поэтому ответ на типичный вопрос "как решения попадают в таблицу?" такой: они туда не попадают во время работы. Таблица заранее задает закон перехода. Движок берёт текущее состояние, берёт действие, открывает нужную ячейку и получает следующий результат. Потом он может отдельно сверить это с формулой. Если таблица и формула совпали — шаг прошёл. Если нет — появляется точный контрпример.
В более сложном GALO таких таблиц не одна, а целая башня уровней. Но L3 хорошо показывает принцип на пальцах: мысль можно рассматривать не как вероятностное продолжение текста, а как цепочку проверяемых переходов между конечными состояниями.
То есть вместо чёрного ящика я хочу прийти к формату:
было состояние P1,
было действие P1,
по таблице получено P2,
формула дала P2,
значит шаг подтверждён.
А если где-то не совпало, система должна показать не объяснение задним числом, а конкретную ячейку, где всё сломалось.
not-allowed-here
вот правильно ли я понимаю по сути размерность P0, P1, P2 - не определена они могут быть как "одним битом" так и неким "Стейтом" описывающим суперпозицию состояний системы?
UPD: причем сам этот "Стейт" может быть описан боле низким или более высоким уровнем Логики? т.е. постиу мы "упаковываем" в "Стейт" разные по комплексности стейты как бы один в другой для большей детерминированности системы?
т.е. как пример есть круги, треугольники и квадраты - это плоские геометрические фигуры, тетраедр и шар тут будет нарушением логики, т.к. он не плоский и потребует уже дополнения более высокой логики... и примерно так оно и работает в реальности, а уровни логики позволяют описать больше комплексность стейтов системы?
Вобще реально не хватает простых предметных примеров которые бы позволили увидеть применимость - на тех же фигурах и их свойствах и классификации.
как пример пять аксиом Евклида или 20 утверждений — аксиом Гильберта.
rusfbm Автор
Давайте я Вам отвечу отдельной статьей, слишком сложный и фундаментальный вопрос. Но ответ будет с оговоркой: "как мыслит GALO", чтобы меня физики не заклевали
not-allowed-here
лучше сначала нулевую статью - определим язык, чтобы формализовать единое поле логики и терминов.
очень многое не понятно именно из-за наличия у вас не прозрачного фундамента подкрепленого не тривиальной алгеброй который копился несколько лет и вылился в понятный пока только для вас комплекс...
rusfbm Автор
Принято, но она будет слишком сильным фильтром, хорошо, если пару человек ее поймет. Чтобы увидеть причину всего, нужно будет попотеть.