TL;DR
Zero-Error Horizon (ZEH) — метрика, которая показывает максимальный размер задачи, до которого модель решает все примеры без единой ошибки. Если ZEH = 126 для умножения, модель справляется со всеми умножениями до 126×126, но ошибается хотя бы на одном примере размера 127. Это граница надёжности: внутри можно условно доверять, за пределами — осторожность.
Даже GPT-5.2 — топовая модель, которая пишет симуляторы динамики жидкостей — ошибается на удивительно простых задачах: не может вычислить чётность строки 11000 (5 символов), считает что скобки ((((()))))) сбалансированы (они нет), ошибается в умножении 127×82 (даёт 10314 вместо 10414). При этом та же модель решает сложнейшие задачи. Эта непоследовательность — главная проблема при использовании LLM в критичных сферах: финансы, медицина, право. Модель может применить изощрённую теорию, но ошибиться в простом умножении внутри рассуждения.
ZEH выявляет эти дыры в возможностях. Высокая средняя точность (98%) не гарантирует отсутствие ошибок на конкретных простых примерах. Модель с точностью 98% на умножениях до 99×99 может иметь ZEH = 5 — то есть ошибаться даже на однозначных числах. Исследование показало: маленькие модели механически запоминают примеры из обучающих данных и ошибаются случайно. Большие модели учат алгоритм вычисления, и их ошибки концентрируются на алгоритмически сложных задачах (много переносов разрядов в умножении). ZEH растёт именно когда модель переходит от запоминания к пониманию правил.
Главный инсайт для пользователя
ZEH — это не техника промптинга, а концепция понимания границ LLM. Из неё можно извлечь практические принципы:
1. Проверяй модель на простых задачах перед сложными
Прежде чем доверить модели сложный расчёт, проверь её на серии простых примеров того же типа. Если модель ошибается на 20×20, ей нельзя доверить финансовые расчёты с трёхзначными числами.
2. Высокая точность в среднем ≠ надёжность на каждом примере
Модель может быть на 98% точна, но эти 2% ошибок могут концентрироваться на неожиданно простых задачах. Не полагайся на средние метрики в критичных задачах.
3. Перепроверяй шаги с базовыми вычислениями
Сложная задача часто содержит простые подшаги: умножение, подсчёт, проверка баланса. Модель может ошибиться именно на этом простом шаге, и ошибка распространится дальше. LLM склонны к self-delusion: одна ошибка тянет за собой цепочку неверных выводов.
Пример применения
Задача: Ты готовишь инвестиционную модель для стартапа. Модель должна считать метрики роста: конверсии, LTV, unit-экономику. В расчётах участвуют десятки умножений и делений двух-трёхзначных чисел. Перед тем как доверить модели финальные расчёты, проверь её границы.
Промпт:
Перед основной задачей проверь свои вычислительные возможности.
Реши эти умножения и покажи только ответы через запятую:
5×5, 12×12, 23×23, 34×29, 47×51, 68×73, 89×92, 127×82
Если где-то ошибёшься или сомневаешься, честно скажи.
После проверки — основная задача:
[здесь твоя инвестиционная модель с расчётами]
Результат:
Модель решит тестовые умножения. Если ошибётся на 127×82 (что делает GPT-5.2), ты увидишь границу надёжности. Это сигнал: для трёхзначных умножений в основной задаче добавь инструкцию "разложи умножение пошагово" или "используй калькулятор" (если доступен), или перепроверь сам критичные цифры.
Если модель справилась со всеми примерами, это хороший знак (но не гарантия) — можно доверить основную задачу, но всё равно проверить итоговые цифры.
Почему это важно
Слабость LLM: Модели генерируют текст по паттернам из обучающих данных. Даже если модель "понимает" алгоритм умножения, она может ошибиться в выполнении: пропустить перенос разряда, перепутать цифры. Это похоже на человеческие ошибки в устном счёте, но у LLM нет "внутреннего калькулятора" — они симулируют вычисления через текст.
Непредсказуемость ошибок: Маленькие модели ошибаются случайно — они запоминают примеры, а не правила. Если пример не встречался в обучении, модель гадает. Большие модели учат алгоритм, но всё равно ошибаются на алгоритмически сложных случаях. Проблема: ты не знаешь заранее, где именно модель споткнётся.
Распространение ошибок: LLM генерирует текст последовательно. Если модель ошибётся на шаге 3 из 10, она продолжит рассуждать, опираясь на неверный результат. Эффект self-delusion: модель убеждает сама себя в правильности неверного вывода, потому что он уже появился в контексте. Одна ошибка в простом умножении может обрушить всю цепочку рассуждений.
Рычаги управления:
- Размер проверочных примеров — начни с совсем простых (однозначные числа) и постепенно усложняй, чтобы найти границу, где модель начинает ошибаться
- Тип проверочных задач — подбирай задачи, аналогичные тем, что будут в основной задаче (если в задаче деления — проверяй деления, а не умножения)
- Инструкция при ошибке — попроси модель честно признаться, если не уверена, вместо выдачи неверного ответа
- Пошаговость — если модель ошиблась на проверочных примерах, добавь "реши пошагово" в основную задачу
Шаблон промпта
Задача: {описание_задачи}
Перед решением проверь себя на простых подзадачах того же типа:
{пример_1_простой}
{пример_2_чуть_сложнее}
{пример_3_ещё_сложнее}
...
{пример_N_близко_к_реальной_сложности}
Покажи ответы на проверочные задачи. Если где-то сомневаешься или замечаешь ошибку, честно скажи.
После проверки приступай к основной задаче. Если обнаружил слабые места на проверке, в основной задаче будь особо внимателен на похожих шагах или используй пошаговое решение.
Что подставлять:
- {описание_задачи} — твоя реальная задача, где есть риск ошибки на простых шагах
- {пример_1_простой} и далее — серия задач того же типа, что встретятся в основной задаче, от очень простых к близким по сложности к реальным. Например, для умножения: 5×5, 12×12, 23×23, 47×51, 127×82
Логика: Ты вручную находишь ZEH модели для конкретного типа задач. Это не замена основному решению, а калибровка доверия перед критичной задачей.
Ограничения
⚠️ Проверка не даёт 100% гарантии: Даже если модель справилась с тестовыми примерами, она может ошибиться на конкретном примере в основной задаче. ZEH показывает, что до определённого размера модель решает все задачи правильно, но в реальности промпт и контекст могут меняться, и границы сдвигаются.
⚠️ Зависит от промпта: ZEH измеряется при фиксированном промпте. Смени формулировку — и граница может сдвинуться на 10-20%. Для критичных задач лучше проверить с несколькими формулировками и взять самый осторожный результат.
⚠️ Не для всех задач применимо: ZEH имеет смысл для задач с чёткой градацией сложности (длина строки, размер чисел, количество узлов в графе). Для субъективных задач (креатив, стиль текста) понятие "размера задачи" размыто.
⚠️ Затратно по времени: Чтобы найти ZEH точно, нужно протестировать все задачи до определённого размера. Для быстрой проверки в чате достаточно 5-10 примеров возрастающей сложности, но это даёт только примерное представление, не точную границу.
Как исследовали
Исследователи взяли несколько моделей (Qwen2.5 от 0.5B до 72B параметров, GPT-5.2) и прогнали их через все задачи возрастающей сложности: 1×1, 1×2, 1×3, ..., пока не нашли первую ошибку. Это и есть граница ZEH. Проверяли на четырёх типах задач: умножение целых чисел, вычисление чётности бинарных строк, проверка баланса скобок, хроматическое число графов.
Обнаружили парадокс: GPT-5.2 с ZEH = 126 для умножения (справляется с двузначными числами) делает ошибку на 127×82 — отвечает 10314 вместо 10414. Разница — 100, это ошибка переноса разряда. То есть модель знает алгоритм, но сбоит в выполнении. Для скобок ZEH = 10 — не может обработать 11 символов ((((()))))). Для чётности ZEH = 4 — ошибается на строке из 5 символов 11000.
Детальный анализ на Qwen2.5 показал переход от запоминания к пониманию. Маленькие модели (0.5B, 1.5B) имеют высокую корреляцию между точностью и частотой примера в обучающих данных (C4 корпус) — они запоминают. Корреляция у 0.5B — 0.27, у 1.5B — 0.20. Большие модели (32B, 72B) имеют корреляцию около 0.04 — они не зависят от запоминания, значит, используют алгоритм.
Ещё один паттерн: структурированность ошибок. Если модель ошибается на величину, кратную 10 (например, 986 → 1006, разница 20), это ошибка переноса разряда, признак алгоритмического мышления. У маленьких моделей только 58% ошибок структурированы, у больших — 90%. Это значит, большие модели реально считают по алгоритму, а не угадывают, но всё равно делают "человеческие" ошибки в исполнении.
Регрессионный анализ показал: чем больше модель, тем сильнее она страдает от задач с переносами разрядов. Казалось бы, парадокс — модель умнее, но больше ошибается на сложных случаях? Нет, это логично: маленькие модели безразличны к переносам (они угадывают), а большие модели алгоритмически решают, и алгоритмически сложные задачи (много переносов) для них действительно сложнее. Это доказывает, что они не запоминают, а считают.
Почему это важно: Если модель запоминает, у неё случайные дыры в возможностях — не знаешь, где ошибётся. ZEH таких моделей не растёт даже при росте точности. Если модель понимает алгоритм, ошибки концентрируются на сложных случаях, и ZEH может расти.
Ресурсы
Even GPT-5.2 Can't Count to Five: The Case for Zero-Error Horizons in Trustworthy LLMs
Ryoma Sato, National Institute of Informatics
Код: https://github.com/joisino/zeh