3,583 papers
arXiv:2606.02054 74 1 июня 2026 г. FREE

eMoT: двойная проверка ответа через сравнение рассуждений и расчётов

КЛЮЧЕВАЯ СУТЬ
LLM уверенно пишет «17 × 23 = 381» и строит на этом дальнейшие выводы. Ошибка тихо тянется по всей цепочке — финальный ответ звучит связно, но внутри сломан. Метод двойного пути позволяет ловить такие ошибки в любом чате без внешних инструментов и дополнительных инструментов проверки. Решаешь задачу двумя параллельными способами: один раз через логику словами, второй раз через явную арифметику по шагам. Фишка: если пути дают разные ответы — это уже сигнал ошибки. Не нужно знать заранее где она — сам факт расхождения указывает, что что-то сломалось.
Адаптировать под запрос

TL;DR

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

Главная боль: модель уверенно считает, что 17 × 23 = 381, и строит на этом дальнейшие выводы. Ошибка в одном шаге тихо тянется дальше — и финальный ответ выглядит связным, даже если внутри него сломано всё. Модель не "знает", что посчиталось неверно — она просто генерирует текст, который звучит правдоподобно.

eMoT разрывает эту цепочку. Путь 1 — рассуждения словами. Путь 2 — явные вычисления по шагам (или код). Когда оба пути дают разные ответы, это красный флаг. Модель Stop: "стоп, здесь конфликт" — и разбирает, кто прав и почему.


🔬

Схема метода

Всё выполняется в одном промпте или в двух последовательных запросах.

ШАГ 1: Дистилляция → выделяем ключевые числа, ограничения, цель задачи

ШАГ 2 (параллельно):
  Путь A — Рассуждение → ответ словами и логикой
  Путь B — Вычисление  → явная арифметика/формулы по шагам, финальная цифра

ШАГ 3: Сверка → сравниваем ответы A и B
  ├─ Совпали → финальный ответ принят
  └─ Расходятся → ШАГ 4

ШАГ 4: Примирение → модель находит расхождение, 
        определяет какой путь верен, даёт исправленный ответ

🚀

Пример применения

Задача: Ты сооснователь стартапа. Вы с партнёром делали питч в ФРИИ и теперь обсуждаете условия: за 2,5 млн рублей инвестор хочет 15%. Сейчас у вас два сооснователя по 50%. После сделки — как распределятся доли? И если потом нужно будет зарезервировать 10% на опционный пул — как это изменит расчёт? Хочешь убедиться, что всё правильно.

Промпт:

Реши задачу о распределении долей двумя способами параллельно.

Задача: у двух сооснователей по 50%. Инвестор входит за 2,5 млн рублей 
с долей 15%. Потом создаётся опционный пул 10%.

**Путь A — Логический:**
Рассуждай шаг за шагом: что происходит с долями на каждом этапе, 
почему, что означает каждое изменение. Дай итоговые доли всех сторон.

**Путь B — Вычислительный:**
Запиши явные формулы и арифметику для каждого шага.
Считай по шагам, цифра за цифрой. Дай итоговые доли всех сторон.

**Сверка:**
Сравни финальные цифры из Пути A и Пути B.
— Если совпадают: подтверди ответ.
— Если расходятся: найди конкретный шаг где они разошлись, 
  объясни какой путь содержит ошибку и почему, 
  дай исправленный финальный расчёт.

Результат:

Модель выдаст два параллельных блока с промежуточными шагами — один в логике, второй в цифрах. Затем явно сравнит финальные цифры. Если где-то ошиблась (например, в порядке разводнения — сначала инвестор, потом пул, или наоборот), сверка это поймает. В блоке примирения модель укажет конкретный шаг расхождения и выдаст исправленный расчёт с объяснением.


🧠

Почему это работает

Модель генерирует текст по вероятности — следующий токен, который "звучит правдоподобно". При свободном рассуждении она может пропустить промежуточное вычисление, округлить в голове или потерять число из вида. Ошибка становится частью контекста — и следующие шаги строятся уже на ней.

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

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

Ключевые рычаги: - Детализация Пути B — чем подробнее требуешь расчёт (каждое умножение отдельной строкой), тем выше шанс поймать ошибку - Тип Пути B — можно попросить Python-код вместо арифметики; в ChatGPT с Code Interpreter он выполнится реально - Глубина примирения — можно добавить "покажи конкретную строку расчёта где расхождение" для сложных задач


📋

Шаблон промпта

Реши задачу двумя способами параллельно.

Задача: {задача с конкретными числами и условиями}

**Путь A — Рассуждение:**
Реши шаг за шагом через логику и объяснения. 
Дай итоговый ответ: {что именно нужно найти}.

**Путь B — Вычисление:**
Запиши явные формулы и арифметику для каждого шага.
Считай пошагово, не пропуская промежуточных результатов.
Дай итоговый ответ: {что именно нужно найти}.

**Сверка:**
Сравни ответы Пути A и Пути B.
— Если совпадают: подтверди итоговый ответ.
— Если расходятся: найди конкретный шаг расхождения,
  объясни какой путь содержит ошибку,
  дай исправленный финальный ответ.

Плейсхолдеры: - {задача} — полностью, с конкретными числами. Чем точнее, тем лучше работает Путь B - {что именно нужно найти} — конкретная метрика: "итоговая сумма", "доля каждого", "количество дней"


🚀 Быстрый старт — вставь в чат:

Вот шаблон метода двойной проверки. Адаптируй под мою задачу: [твоя задача].
Задавай вопросы, чтобы уточнить числа и условия.

[вставить шаблон выше]

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


⚠️

Ограничения

⚠️ Качественные задачи: Метод работает там, где есть правильный ответ. Для субъективного текста, оценки стратегии, творческих задач — двойная проверка не даёт преимущества. Нет "верного расчёта" — нечего сравнивать.

⚠️ Системная память не доступна: Оригинальный eMoT накапливает успешные шаблоны рассуждений между сессиями и учится на них. В обычном чате каждый разговор начинается с нуля — этой части нет.

⚠️ Длинные цепочки рассуждений: При очень длинных задачах модель может "согласиться сама с собой" даже при ошибке — если ошибка системная и одинаково присутствует в обоих путях. Тогда сверка ничего не поймает.

⚠️ Токены: Два параллельных пути — вдвое больше текста. Для простых задач дороже, чем нужно. Используй для задач где цена ошибки высока.


🔗

Ресурсы

Работа: eMoT: evolving Memory-of-Thought via Symbolic Anchoring and Memory Corrosion

Авторы: Xiang Li, Jiwei Wei, Ke Liu, Yitong Qin, Jinyu Guo, Malu Zhang, Peng Wang, Yang Yang

Организация: Center for Future Media, University of Electronic Science and Technology of China, Chengdu

Связанные методы: Chain-of-Thought (CoT), Tree-of-Thought (ToT), Buffer-of-Thoughts (BoT), Program-Aided Language models (PAL)


📋 Дайджест исследования

Ключевая суть

LLM уверенно пишет «17 × 23 = 381» и строит на этом дальнейшие выводы. Ошибка тихо тянется по всей цепочке — финальный ответ звучит связно, но внутри сломан. Метод двойного пути позволяет ловить такие ошибки в любом чате без внешних инструментов и дополнительных инструментов проверки. Решаешь задачу двумя параллельными способами: один раз через логику словами, второй раз через явную арифметику по шагам. Фишка: если пути дают разные ответы — это уже сигнал ошибки. Не нужно знать заранее где она — сам факт расхождения указывает, что что-то сломалось.

Принцип работы

Не «запусти код и проверь» — для этого нужна инфраструктура. Просто попроси модель решить задачу дважды в одном промпте. Путь А — свободные рассуждения: логика, объяснения, итог. Путь Б — явный расчёт: каждая формула, каждое умножение, каждый промежуточный результат — отдельной строкой. Модель не может «пропустить» шаг, если её заставили его написать явно. Структура промпта делает невидимое — видимым. Если оба пути дают одинаковый ответ — принимаешь результат. Если расходятся — запускаешь шаг примирения: модель находит конкретный шаг расхождения, объясняет кто ошибся и почему, даёт исправленный ответ.

Почему работает

LLM генерирует следующий токен по вероятности — тот, что «звучит правдоподобно». При свободном рассуждении она может округлить в голове, пропустить промежуточный результат или потерять число из контекста. Ошибка становится частью контекста — и следующие шаги строятся уже на ней. Явный расчёт по шагам не даёт этого сделать: каждая цифра должна быть написана — значит, её нельзя «угадать». Два пути создают встроенный детектор без внешнего инструмента. Не нужно знать заранее где ошибка — сам факт расхождения между путями это сигнал. Дальше шаг примирения заставляет модель локализовать ошибку, а не выдать очередной «правдоподобный» ответ поверх старой.

Когда применять

Финансы и юридические условия → для проверки долей, налогов, условий сделок, когда ошибка в цифре дорого стоит. Логистика и планирование → для задач с конкретными числами: сроки, объёмы, бюджеты. Математические задачи в учёбе и работе → где нужен воспроизводимый правильный ответ, а не «похожий». НЕ подходит для субъективных задач: оценки стратегии, написания текстов, творческих запросов. Там нет «правильного расчёта» — нечего сравнивать и сверка ничего не поймает.

Мини-рецепт

1. Дай конкретную задачу с числами: Чем точнее условия — тем лучше работает явный расчёт в Пути Б. Размытое «примерно 30%» сломает шаг сверки.
2. Запроси два пути параллельно: Путь А — логика и рассуждения, итоговый ответ. Путь Б — явная арифметика по шагам, каждое промежуточное значение отдельной строкой, итоговый ответ.
3. Добавь блок сверки: «Сравни итоги обоих путей. Если совпали — подтверди. Если расходятся — найди конкретный шаг расхождения, объясни какой путь содержит ошибку, дай исправленный расчёт».
4. Для сложных задач: Добавь «покажи конкретную строку расчёта, где пути разошлись» — это не даёт модели отделаться общим объяснением.

Примеры

[ПЛОХО] : Посчитай сколько будет наша доля после того как инвестор войдёт с 15% за 2,5 млн и мы создадим опционный пул
[ХОРОШО] : Реши задачу о распределении долей двумя способами параллельно. Задача: два сооснователя по 50%, инвестор входит с долей 15%, затем создаётся опционный пул 10%. Путь А — Рассуждение: объясни шаг за шагом что происходит с долями, почему, дай итоговые доли всех сторон. Путь Б — Вычисление: запиши явные формулы для каждого шага, считай пошагово не пропуская промежуточных результатов, дай итоговые доли всех сторон. Сверка: сравни финальные цифры из Пути А и Пути Б. Если совпадают — подтверди ответ. Если расходятся — найди конкретный шаг расхождения, объясни какой путь ошибся, дай исправленный расчёт.
Источник: eMoT: evolving Memory-of-Thought via Symbolic Anchoring and Memory Corrosion
ArXiv ID: 2606.02054 | Сгенерировано: 2026-06-02 07:30

Проблемы LLM

ПроблемаСутьКак обойти
Ошибка в середине рассуждений тянется незаметно до концаМодель считает числа "в голове". Пропускает промежуточный шаг. Округляет. Получает неверное число. Но не знает об этом — она просто генерирует правдоподобный текст дальше. Каждый следующий шаг строится на неверном. Финальный ответ выглядит связным. Ошибка внутри невидима. Особенно опасно в задачах с цепочкой зависимых расчётов: финансы, планирование, логистика, правоПопроси модель решить задачу двумя путями параллельно. Путь рассуждений — словами и логикой. Путь вычислений — явная арифметика по шагам. Потом попроси сравнить оба ответа. Расхождение покажет: где-то ошибка. Дальше модель сама локализует её

Методы

МетодСуть
Двойной путь + сверка — встроенный детектор ошибокПопроси решить одну задачу двумя способами в одном запросе. Путь A — рассуждение: логика, объяснения, выводы словами. Путь B — вычисление: каждое действие отдельной строкой, промежуточные результаты видны. Потом явная инструкция: «сравни финальные цифры из Пути A и Пути B. Если совпали — подтверди. Если расходятся — найди конкретный шаг расхождения, объясни какой путь ошибся, дай исправленный ответ». Почему работает: явная запись каждого шага не даёт "пропустить" промежуточное вычисление. Нельзя округлить в голове то, что нужно написать текстом. Когда применять: задачи с конкретными числами и правильным ответом. Финансы, доли, логистика, юридические условия. Когда не работает: субъективные оценки, творческие задачи, вопросы без единственно верного ответа. Два пути там не с чем сравнивать

Тезисы

ТезисКомментарий
Расхождение между двумя путями решения — уже сигнал ошибкиНе нужно знать заранее где ошибка. Достаточно попросить модель решить задачу двумя способами и сравнить результаты. Если они разошлись — ошибка точно есть. Где именно — модель найдёт сама в шаге примирения. Это работает потому что два независимых пути к одному ответу дают одинаковый результат, только если оба верны. Применяй: добавляй блок явной сверки в любой задаче с числами. Не "проверь себя" — а именно "сравни Путь A и Путь B и найди расхождение"
📖 Простыми словами

eMoT: evolving Memory-of-Thought via Symbolic Anchoring and Memory Corrosion

arXiv: 2606.02054

Суть eMoT в том, что нейронки патологически не умеют считать в уме, пока болтают. Когда модель пишет рассуждение, она просто подбирает слова, которые звучат правдоподобно, и легко может ляпнуть «2+2=5», если контекст к этому располагает. Метод заставляет модель работать в режиме шизофреника: она должна решить задачу дважды и параллельно. Сначала выдать поток сознания, а потом — сухие, жесткие вычисления через символьные якоря. Если эти две реальности не склеиваются, модель получает по рукам и идет переделывать, пока версии не совпадут.

Это как если бы ты считал сдачу в магазине, одновременно обсуждая с кассиром погоду. Ты можешь ошибиться просто потому, что язык занят болтовней. Но если ты в одной руке держишь калькулятор, а другой жестикулируешь, и в конце сверяешь цифру на экране со своими ощущениями — шансов на обсчет почти нет. eMoT — это и есть тот самый калькулятор, который не дает модели уйти в творческий полет там, где нужна математическая точность.

В реальности это выглядит так: модель берет твой кейс с долями в стартапе и запускает два процесса. В первом она пишет текст: «Ну, раз инвестор берет 15%, то у основателей остается по 42.5%...». Во втором она обязана прописать формулы и явные вычисления. Если в тексте получилось одно, а в формуле другое — включается механизм «примирения». Модель сама ищет, где она лажанула, и исправляет ошибку до того, как ты ее увидишь. Это убивает главную проблему LLM — когда ошибка в начале текста тянет за собой весь остальной бред.

Метод тестировали на сложных логических задачах, но он идеально ложится на любой бизнес-контекст: расчеты юнит-экономики, распределение опционов или планирование бюджета. Везде, где есть риск, что модель «заговорится» и потеряет логику, символьное якорение спасает ситуацию. Принцип универсален: если задача сложнее, чем написание поста в соцсети, заставляй нейронку проверять себя через параллельные вычисления.

Короче, хватит верить модели на слово, когда она выдает длинные простыни рассуждений. Без жесткой фиксации чисел через eMoT или аналогичные техники, нейронка — это просто очень уверенный в себе гуманитарий, который путает проценты с долями. Внедряй двойную проверку через символьные вычисления, иначе рискуешь получить галлюцинацию вместо бизнес-плана. Кто контролирует логику через формулы, тот получает результат без ошибок.

Работа с исследованием

Адаптируйте исследование под ваши задачи или создайте готовый промпт на основе техник из исследования.

0 / 2000
~0.5-2 N-токенов ~10-30с
~0.3-1 N-токенов ~5-15с