3,583 papers
arXiv:2603.03332 76 11 фев. 2026 г. FREE

Карта уязвимостей CoT: пять способов сломать рассуждение LLM — и где её слепые пятна

КЛЮЧЕВАЯ СУТЬ
Модель не проверяет ваши шаги — она их продолжает. Дайте ей цепочку с ошибкой в единицах измерения, и она с энтузиазмом доведёт неверный расчёт до финала. Метод явной верификации позволяет передавать модели частичные расчёты и получать исправленные ошибки — вместо того чтобы она их тиражировала дальше. Добавь один блок «проверь шаги перед продолжением» — задача модели меняется с «достроить текст» на «критиковать предыдущее». Слепое пятно с единицами измерения бьёт на -20-30% точности даже у топовых моделей — и закрывается одной строчкой в промпте.
Адаптировать под запрос

TL;DR

Когда вы даёте LLM цепочку рассуждений с ошибкой и просите её продолжить — модель почти всегда идёт вперёд как ни в чём не бывало. Она не перепроверяет ваши шаги. Она достраивает здание на кривом фундаменте. Это проблема не конкретной модели — это системное поведение большинства LLM при работе с частичными рассуждениями.

Исследователи выделили пять типов ошибок, которые можно внедрить в промежуточные шаги рассуждения, и проверили как 13 разных моделей на них реагируют. Главная находка: уязвимости неодинаковые. Одни ошибки убивают точность у малых моделей, но крупные их замечают. Другие — и GPT-5, и маленькая Gemma одинаково не видят. А третьи вообще не влияют ни на кого.

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


🔬

Схема метода (таксономия уязвимостей)

ТИП 1: MathError → арифметическая ошибка в шаге (3+4=8)
  Эффект: -18% точности в среднем, малые модели теряют 50-60%
  Крупные модели: часто ИСПРАВЛЯЮТ сами

ТИП 2: UnitConversion → смена единиц в середине (минуты → секунды)
  Эффект: -20-30% точности ДАЖЕ у крупных моделей
  ⚠️ Главное слепое пятно — универсальное

ТИП 3: SkippedSteps → убраны промежуточные шаги
  Эффект: -15% точности
  Модель угадывает ответ напрямую

ТИП 4: Sycophancy → "автор задачи считает, что 3/4×4000 = -8528"
  Эффект: -7% точности у малых моделей
  Модели умеренно устойчивы к ложным авторитетам

ТИП 5: ExtraSteps → лишние, нерелевантные шаги добавлены
  Эффект: 0-6% точности — практически никакого вреда
  ✅ Лишний контекст безопасен

Все пять типов проверялись как единый промпт (частичное решение + вопрос → модель дополняет).


🚀

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

Задача: Вы делаете финансовую модель для запуска подписки на Кинопоиске. Вы уже посчитали первые шаги вручную и просите LLM продолжить расчёт. Шаги переведены из месячных данных в годовые — и где-то закралась ошибка в конвертации.

Промпт:

Я считаю юнит-экономику для нового тарифа.

Вот мои расчёты:
— Средний чек: 399 руб/месяц
— Отток: 8% в месяц
— LTV = 399 / 0.08 = 4987 руб
— За год в рублях: 4987 × 12 = 59 844 руб

[Дальше продолжи расчёт: посчитай LTV в долларах по курсу 90 руб/$, 
и ROI при CAC = $15]

⚠️ Прежде чем продолжать — проверь мои шаги выше на корректность.
Если видишь ошибку в единицах или арифметике — укажи и исправь 
перед тем как идти дальше.

Результат:

Без финальной инструкции ⚠️ Прежде чем продолжать... — модель с высокой вероятностью пойдёт дальше с ошибочным LTV×12 (LTV уже учитывает бесконечный горизонт, умножать на 12 — математическая ошибка). С инструкцией — поймает и исправит. Особенно надёжно работает на крупных моделях (Claude Sonnet, GPT-5, Gemini Flash).


🧠

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

LLM не перепроверяет — она достраивает. Модель видит частичное рассуждение и её задача — продолжить текст в том же стиле и направлении. У неё нет встроенного "стоп-контроля" который говорит: "подожди, на шаге 2 ошибка". Она воспринимает данные в промпте как контекст, которому нужно соответствовать, не как утверждения которые нужно проверять.

Единицы — особая слабость потому что модель работает с числами как с токенами, а не с физическими величинами. Ей безразлично написано "240 минут" или "14 400 секунд" — оба варианта синтаксически корректны. Семантическое несоответствие (это одно и то же значение, но в разных единицах) она не отслеживает автоматически.

Лишний контекст не вредит — потому что модели хорошо умеют фильтровать нерелевантную информацию при наличии чёткой задачи. Это разрешение: если вы объясняете модели контекст многословно — ответ не ухудшится. Вреден не объём, а противоречие в данных.

Рычаги управления: - Добавить "проверь предыдущие шаги перед продолжением" → включает режим критики, а не достройки - Указать конкретно "особо проверь единицы измерения" → компенсирует главное слепое пятно - Убрать от греха подальше "автор/эксперт считает что..." → сицофантия слабая, но зачем рисковать?


📋

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

Вот моё частичное решение задачи:

[Задача/вопрос]

Мои шаги:
[шаг 1]
[шаг 2]
[шаг 3]
...

⚠️ Проверь мои шаги до того как продолжать:
— Нет ли арифметических ошибок?
— Единицы измерения согласованы на каждом шаге?
— Нет ли пропущенной логики?

Если всё верно — продолжи и дай финальный ответ.
Если нашёл ошибку — укажи где и исправь, потом продолжи.

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


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

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

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

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


⚠️

Ограничения

⚠️ Малые модели (3-8B параметров): Верификация работает хуже. Та же модель, которой поручаешь проверить — и есть модель, которая не замечает ошибок. В Chat-режиме это не ваша проблема (ChatGPT/Claude — всегда крупные), но важно знать если используете локальные модели.

⚠️ Только математические рассуждения: Исследование тестировалось на задачах школьной математики (GSM8K). Насколько эффект переносится на логические рассуждения, правовой анализ или стратегию — не проверялось. Вероятно, принцип работает шире, но цифры будут другие.

⚠️ Единицы — слепое пятно даже у топов: Инструкция "проверь единицы" помогает, но не на 100%. Если точность критична (финансовые расчёты, дозировки) — всегда делайте финальную ручную проверку единиц.

⚠️ Размер не гарантирует робастность: В одном измерении (согласованность при разных формулировках) небольшая 8B-модель обогнала некоторые 70B-модели. Устойчивость к ошибкам — не прямая функция от размера.


🔍

Как исследовали

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

Всего проверили 13 моделей — от крошечной Ministral 3B до GPT-5 и Claude Sonnet 4.5, и от полностью открытых до проприетарных. Это важно: картина всегда рисовалась на одном-двух флагманах, теперь видно системный паттерн поперёк всего спектра. Особо интересный момент: MathError и Sycophancy генерировались детерминированно по правилам, а UnitConversion и ExtraSteps — с помощью Claude Sonnet 4.5. То есть та самая модель, которую тестировали — частично создавала тестовые данные. Авторы это открыто признают.

Самый неожиданный результат — GPT 4o-mini терял 25% точности на арифметических ошибках, тогда как заметно меньший по репутации Gemini 3 Flash — только 1%. Размер модели явно не единственный фактор. Ещё интереснее: на примерах видно три разных стратегии поведения — одни модели слепо копируют ошибку (GPT 4o-mini в примере с Марком), другие явно исправляют и объясняют почему (Gemini 3 Flash), третьи молча исправляют без объяснений (Mistral Large). Эти поведенческие паттерны важнее сухих цифр.


📄

Оригинал из исследования

Пример MathError — как внедряется ошибка:

Question:
Mark started the day with 14 buttons. His friend Shane gave him 3 times 
that amount of buttons. Then his other friend Sam asked if he could have 
half of Mark's buttons. How many buttons did Mark end up with?

Clean Partial Solution:
Shane gave Mark 14 × 3 = 42 buttons
After that Mark had 42 + 14 = 56 buttons

Perturbed Partial Solution:
Shane gave Mark 14 × 3 = 42 buttons
After that Mark had 42 + 14 = 54 buttons [arithmetic error introduced]

Контекст: Модели давали перверженное частичное решение и просили завершить расчёт. GPT 4o-mini принял 54 как данность и вычислил 27. Gemini 3 Flash — заметил "опечатку", пересчитал правильно и получил 28.


💡

Адаптации и экстраполяции

📌

💡 Адаптация: Явный указатель на единицы в технических задачах

Если вы пишете промпт с данными в разных единицах (рубли и доллары, часы и минуты, проценты и доли) — добавляйте явный "чекпоинт единиц":

Вот данные для анализа:
— Выручка: 2,4 млн руб/мес
— CAC: $120 (курс 90 руб/$)
— Конверсия: 3.2% (из 100 лидов)
— Отток: 0.08 (доля, не проценты)

⚠️ Перед расчётом: приведи все данные к единой системе единиц.
Покажи список: что во что конвертируешь и по какому правилу.
Потом считай.

Это напрямую компенсирует главное слепое пятно — UnitConversion.


⚖️

🔧 Техника: Явная верификация vs. молчаливая коррекция

По умолчанию крупные модели молча исправляют ошибки (Mistral Large в примере). Это опасно — вы не знаете что они исправили. Чтобы видеть исправления:

Если найдёшь ошибку в моих шагах — НЕ исправляй молча.
Сначала: "Ошибка на шаге N: [что написано] → [должно быть]."
Потом продолжай с правильным значением.

Делает процесс прозрачным — вы видите где ваша логика разошлась с реальностью.


📌

💡 Экстраполяция: "Лишний контекст безвреден" как разрешение

Находка про ExtraSteps (0-6% потери) — это ещё и разрешение быть многословным. В сложных задачах часто бывает импульс "не перегружать модель". Теперь знаем: объём нерелевантного контекста почти не вредит точности. Можно добавлять предысторию, объяснять мотивацию, давать примеры — модель отфильтрует лишнее и найдёт ключевую задачу.


🔗

Ресурсы

Название работы: Fragile Thoughts: How Large Language Models Handle Chain-of-Thought Perturbations

Код и результаты: github.com/Mystic-Slice/CoTPerturbation

Авторы: Ashwath Vaithinathan Aravindan, Mayank Kejriwal

Организации: University of Southern California, Los Angeles; USC Information Sciences Institute


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

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

Модель не проверяет ваши шаги — она их продолжает. Дайте ей цепочку с ошибкой в единицах измерения, и она с энтузиазмом доведёт неверный расчёт до финала. Метод явной верификации позволяет передавать модели частичные расчёты и получать исправленные ошибки — вместо того чтобы она их тиражировала дальше. Добавь один блок «проверь шаги перед продолжением» — задача модели меняется с «достроить текст» на «критиковать предыдущее». Слепое пятно с единицами измерения бьёт на -20-30% точности даже у топовых моделей — и закрывается одной строчкой в промпте.

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

У LLM нет встроенного детектора противоречий между шагами. Она видит частичное рассуждение как текст который нужно продолжить в том же стиле — и делает это. Исследование проверило пять типов намеренно внесённых ошибок на 13 разных моделях: — Арифметическая ошибка (3+4=8): крупные модели исправляют сами, маленькие тиражируют — в среднем -18% точности — Смена единиц в середине (минуты стали секундами): главное слепое пятно — модель не отслеживает физический смысл чисел, только их синтаксис — минус 20-30% даже у топовПропущенные шаги: модель угадывает промежуточный результат напрямую — -15% — Ложный авторитет («эксперт считает что ответ -8528»): модели умеренно держатся — -7% у малых — Лишний контекст: нулевой вред — модель фильтрует нерелевантное без потерь Вывод: многословность промпта не вредна. Вредны противоречия в данных.

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

Модель работает с числами как с токенами, а не с физическими величинами. Ей синтаксически одинаково что «240 минут» что «14 400 секунд» — оба варианта выглядят как правильный текст. Что одно и то же значение, просто в разных единицах — она не видит автоматически. Отсюда самое стабильное слепое пятно во всей таксономии. Прикол: явная просьба «проверь единицы» буквально меняет задачу модели. Не умнее стала — просто получила другое задание. Вместо «генерируй следующий шаг» — «критикуй предыдущие». Это разные режимы работы. Лишний контекст не топит результат потому что при чёткой задаче модели хорошо умеют игнорировать нерелевантное — этот страх многословных промптов оказался в основном ложным.

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

Многошаговые расчёты — финансовые модели, юнит-экономика, физические задачи — особенно когда часть шагов сделана вручную и передаётся модели на продолжение. Критично когда в расчётах смешиваются единицы: рубли и доллары, минуты и часы, граммы и килограммы. НЕ подходит без дополнительной ручной проверки для локальных небольших моделей (3-8 миллиардов параметров): та же модель которой поручаешь проверку — и есть та что не замечает ошибок. Исследование тестировалось на школьной математике — на правовом анализе или стратегии принцип скорее всего работает, но цифры будут другие.

Мини-рецепт

1. Передай задачу и все свои шаги явно: каждый шаг на новой строке, без сокращений
2. Добавь блок верификации перед запросом продолжения: Проверь мои шаги до того как продолжать: нет ли арифметических ошибок? Единицы измерения согласованы на каждом шаге? Если нашёл ошибку — укажи где и исправь, потом продолжи. Если всё верно — дай финальный ответ.
3. Для расчётов с единицами добавь отдельно: Особо проверь: единицы на каждом шаге одинаковые? — это компенсирует главное слепое пятно
4. Убери ложные авторитеты из условия: формулировки типа «эксперт считает что результат X» толкают модель согласиться с неверным — угодливость слабая, но незачем давать ей повод

Примеры

[ПЛОХО] : Я считаю юнит-экономику: средний чек 399 руб, отток 8%, LTV = 4987 руб, за год = 59844 руб. Продолжи: посчитай LTV в долларах по курсу 90 руб/$ и окупаемость при стоимости привлечения клиента $15.
[ХОРОШО] : Я считаю юнит-экономику: средний чек 399 руб/месяц, отток 8% в месяц, LTV = 399 / 0.08 = 4987 руб, за год = 4987 × 12 = 59844 руб. Проверь мои шаги до того как продолжать: нет ли арифметических ошибок? Единицы согласованы на каждом шаге? Особо проверь: корректно ли умножать LTV на 12? Если нашёл ошибку — укажи и исправь. Потом посчитай LTV в долларах по курсу 90 руб/$ и окупаемость при стоимости привлечения клиента $15. Модель без проверочного блока с высокой вероятностью унаследует ошибку: LTV уже учитывает бесконечный горизонт, умножать на 12 — математически неверно. С блоком — поймает и скажет почему.
Источник: Fragile Thoughts: How Large Language Models Handle Chain-of-Thought Perturbations
ArXiv ID: 2603.03332 | Сгенерировано: 2026-03-09 00:32

Проблемы LLM

ПроблемаСутьКак обойти
Модель продолжает рассуждение, а не проверяет егоТы даёшь часть решения и просишь продолжить. Модель воспринимает твои шаги как данность. Не перепроверяет. Просто достраивает текст в том же направлении. Ошибка в шаге 2 тихо переходит в шаги 3, 4, 5. Это не баг конкретной модели — это поведение почти всех моделей в режиме продолженияЯвно попроси проверить шаги ДО продолжения: "Проверь мои шаги выше на ошибки. Если всё верно — продолжи. Если нашёл ошибку — укажи и исправь, потом иди дальше"
Единицы измерения — слепое пятно у всех моделейГде-то в цепочке рассуждений единицы меняются: минуты стали секундами, рубли долларами, месяц годом. Модель не замечает. Цифры синтаксически корректны, модель продолжает вычисления без вопросов. Это не лечится размером модели — GPT-4 и Gemini теряют 20–30% точности так же, как маленькиеДобавь отдельное указание: "Особо проверь: единицы измерения согласованы на каждом шаге?". Общей инструкции "проверь ошибки" недостаточно — нужно назвать единицы явно

Методы

МетодСуть
Явный барьер верификации перед продолжениемВставь в промпт блок проверки перед задачей продолжить решение. Структура: [твои шаги] ⚠️ Проверь: нет ли арифметических ошибок? Единицы согласованы? Нет ли пропущенной логики? Если всё верно — продолжи. Если нашёл ошибку — укажи и исправь, потом иди дальше. Почему работает: Без этого указания у модели одна задача — продолжить текст. С этим указанием — сначала проверить, потом продолжить. Это разные режимы. Когда применять: любые многошаговые расчёты, где ты дал готовые шаги. Когда слабее работает: маленькие локальные модели (3–8B) — та же модель, что проверяет, и есть та, что не замечает ошибок
📖 Простыми словами

Fragile Thoughts: HowLargeLanguageModelsHandle Chain-of-Thought Perturbations

arXiv: 2603.03332

Суть проблемы в том, что современные нейронки — это патологические конформисты. Когда ты просишь модель продолжить цепочку рассуждений (Chain-of-Thought), она не работает как строгий учитель, проверяющий домашку. Она работает как соавтор, который верит тебе на слово. Если ты вбросишь в логику явную лажу, модель не нажмет на тормоза, а просто примет твой бред за истину и начнет строить выводы на этом гнилом фундаменте. Это фундаментальный баг архитектуры: LLM обучены продолжать последовательность, а не подвергать её сомнению.

Это похоже на то, как если бы ты помогал другу собирать шкаф из Икеи, увидел, что он прикрутил полку задом наперед, но вместо того чтобы сказать "чувак, ты лажаешь", просто продолжил бы вкручивать шурупы в соседнюю доску. Ну, раз он так решил, значит, так надо. В итоге шкаф разваливается, а ты стоишь с отверткой и делаешь вид, что всё идет по плану. Модель ведет себя именно так: она видит ошибку, но её внутренний цензор спит, пока она послушно дописывает текст в заданном стиле.

Исследователи проверили это на куче тестов и выяснили: LLM игнорируют возмущения в логике. Если ты даешь ей задачу по математике или физике, где в середине решения допущена ошибка, модель в 9 случаях из 10 просто проигнорирует косяк и выдаст ответ, исходя из неверных данных. Она не делает self-correction (самопроверку), если её об этом специально не пнуть. Причем это не лечится простым увеличением параметров — даже самые мощные модели наступают на эти грабли, потому что их задача — соответствовать контексту, а не искать в нем подвох.

Этот принцип универсален и касается не только математики. Если ты делаешь финансовый прогноз, пишешь код или планируешь маркетинговую стратегию и даешь нейронке частичные вводные, она не будет их перепроверять. Она просто подхватит твой темп. Если ты ошибся в конвертации валют или в базовой гипотезе о рынке, AI радостно подтвердит твою галлюцинацию и выдаст результат, который выглядит логично, но по факту является полной херней. Принцип GIGO (Garbage In, Garbage Out) здесь работает в абсолюте.

Короче: никогда не доверяй модели проверку своих промежуточных шагов, если ты сам в них не уверен. Она не скажет тебе, что ты не прав — она просто вежливо доведет тебя до катастрофы. Чтобы этого избежать, нужно либо заставлять её проверять каждый шаг отдельным промптом, либо давать только чистые факты без своих домыслов. Иначе ты получишь идеально структурированный, уверенный, но абсолютно бесполезный мусор.

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

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

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