3,583 papers
arXiv:2511.21734 92 21 нояб. 2025 г. FREE

Verification-First (VF): проверка перед генерацией улучшает рассуждения LLM

КЛЮЧЕВАЯ СУТЬ
Парадокс: LLM лучше критикует чужие ответы, чем генерирует правильные свои. Причина — эгоцентризм авторегрессии: модель цепляется за первый вариант и защищает его, а не ищет ошибки. Verification-First ломает эту защиту: заставляет модель сначала проверить чужой ответ (даже абсурдный '1'), что включает критическое мышление вместо защиты. Фишка: проверка чужого ответа выключает режим защиты. Модель ищет противоречия, формулирует уравнения, строит контрпримеры — эта структура ведёт к правильному решению. +5-7% точности на математике из добавления одной строчки.
Адаптировать под запрос

TL;DR

Verification-First (VF) — техника, которая меняет порядок работы LLM: вместо "думай по шагам и найди ответ" мы говорим "вот ответ [любой, даже случайный], проверь его, потом дай правильный". Модель сначала критикует предложенный ответ, и только потом генерирует свой — это запускает обратное рассуждение от ответа к условию.

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

Как работает: в простейшем варианте — один промпт с тривиальным ответом (например, "1" для математических задач). Для сложных задач — два вызова: сначала обычный CoT даёт первый ответ, затем VF просит проверить его и дать финальный. Итеративная версия Iter-VF повторяет цикл проверки многократно, каждый раз используя только ответ из предыдущего шага (без накопления контекста).


🔬

Схема метода

Вариант 1: VF с тривиальным ответом (один запрос)

ВХОД: Задача + "Предлагаемый ответ: 1"
→ Модель проверяет → находит ошибки → генерирует правильный ответ

Вариант 2: VF с предыдущим ответом (два запроса)

ШАГ 1: CoT(задача) → Ответ_1
ШАГ 2: VF(задача, Ответ_1) → проверка → Ответ_2 (финальный)

Вариант 3: Iter-VF (N запросов, для test-time scaling)

ШАГ 1: CoT или VF → Ответ_1
ШАГ 2: VF(задача, Ответ_1) → Ответ_2
...
ШАГ N: VF(задача, Ответ_{N-1}) → Ответ_N (финальный)

Важно: каждый шаг видит ТОЛЬКО ответ из прошлого шага, не весь контекст

🚀

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

Задача: Ты готовишь финмодель для питча инвестору. Нужно рассчитать точку безубыточности: фиксированные расходы 450 000 ₽/мес, маржинальность единицы продукта 1 500 ₽. Сколько продаж в месяц нужно для выхода в ноль?

Промпт:

Задача: Фиксированные расходы компании — 450 000 рублей в месяц. 
Маржинальность одной продажи — 1 500 рублей. 
Сколько продаж в месяц нужно для выхода на точку безубыточности?

Предлагаемый ответ: 1

Сначала проверь предлагаемый ответ. Затем дай правильный ответ с объяснением.

Результат: Модель начнёт с проверки: "Если ответ 1 продажа, то выручка 1 500 ₽, а расходы 450 000 ₽ — очевидно не покрывает". Затем сформулирует уравнение: 1 500 × N = 450 000, и даст ответ 300 продаж. Процесс проверки вынуждает модель явно записать соотношение между переменными — это снижает шанс арифметической ошибки.


🧠

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

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

Сильная сторона: LLM отлично критикует — находит противоречия, строит контрпримеры, проверяет граничные условия. Верификация — когнитивно более простая задача, чем генерация с нуля.

Как VF использует это: Когда ты даёшь модели "чужой" ответ для проверки, она выходит из режима защиты своей генерации. Включается критическое мышление. Даже если ответ "1" абсурден — процесс проверки заставляет модель явно сформулировать условия задачи, записать уравнения, найти противоречия. Эта структура потом используется для генерации правильного ответа.

Рычаги управления:

  • Тривиальный vs реальный ответ: Для простых задач достаточно "1" или "Вариант Б". Для сложных (код, API) — сначала сгенерируй первый ответ обычным CoT
  • Количество итераций: Iter-VF можно остановить после 2-5 шагов — основной прирост на первых итерациях
  • Markov vs накопление: VF передаёт только ответ, не весь контекст — избегает переполнения и накопления ошибок (в отличие от Self-Correction)

📋

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

Базовый VF (с тривиальным ответом):

Задача: {описание_задачи}

Предлагаемый ответ: {тривиальный_ответ}

Сначала проверь предлагаемый ответ — найди ошибки или подтверди правильность. 
Затем дай правильный ответ с объяснением.

Плейсхолдеры:

  • {описание_задачи} — полное условие задачи
  • {тривиальный_ответ} — для чисел: "1"; для выбора: "Вариант Б"; для да/нет: "Да"

VF с предыдущим ответом (для сложных задач):

Задача: {описание_задачи}

Предыдущий ответ: {ответ_из_первого_запроса}

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

Плейсхолдеры:

  • {ответ_из_первого_запроса} — скопируй ответ из предыдущего запроса (без рассуждений, только финальный ответ)

Iter-VF (многократная итерация):

Повторяй VF с предыдущим ответом 3-5 раз. Каждый раз:

  1. Извлеки только финальный ответ из предыдущего вывода
  2. Подставь его в шаблон VF
  3. Получи новый ответ

Критически важно: передавай только ответ, не весь текст рассуждений.


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

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

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

LLM спросит про тип ответа (число, выбор, текст) — чтобы подобрать осмысленный тривиальный ответ для проверки.


⚠️

Ограничения

⚠️ Слабее на knowledge-intensive задачах: VF улучшает рассуждения (вычисления, логику), но мало помогает когда проблема в знаниях. На GPQA (научные вопросы) прирост ~2-3%, на GSM8K (математика) — до 5-7%.

⚠️ Нужен осмысленный тривиальный ответ: Для кода "return 1" бесполезен — модель не может его осмысленно проверить. Для open-ended задач используй двухшаговый вариант.

⚠️ Iter-VF достигает потолка: После 5-10 итераций прирост замедляется. Для дальнейшего scaling авторы рекомендуют комбинировать с параллельными стратегиями (voting по всем промежуточным ответам).


🔍

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

Команда из Tsinghua University проверила VF на трёх типах задач: математика (GSM8K, MATH500), научные вопросы (GPQA-Diamond), код и API (HumanEval, MBPP, API-Bank). Тестировали на 8 моделях от 1B до 72B параметров (Qwen2.5, Llama3).

Интересная деталь дизайна: для математических задач везде использовали один и тот же тривиальный ответ "1" — и это работало даже когда ответ должен быть не числом (координаты, выражения). Модель интерпретировала "1" осмысленно в контексте задачи.

Ключевой результат на TTS: Iter-VF превзошёл Self-Correction, PHP, Self-Consistency и Best-of-N при ограниченном бюджете токенов. Критическое отличие — марковость: Iter-VF передаёт только ответ, Self-Correction — весь контекст. Накопление контекста приводило к катастрофическому падению качества у Self-Correction.

Неожиданная находка: VF работает даже с "thought-hidden" моделями (GPT-o1 и подобные), где внутренние рассуждения скрыты. Прирост +3% на MATH500 и +4% на GPQA с минимальным overhead по токенам.


📄

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

Контекст: Базовый промпт VF для математических задач (Figure 2 в статье)

Problem: [problem description]

Proposed Answer: 1

First verify the proposed answer. Then give the correct answer.

Контекст: Iter-VF алгоритм (Algorithm 1)

Require: LLM M, problem Q, computation budget B, (optional: initial answer A_0)
for i = 1, ..., B do
    Extract final answer A_i from M(VF(Q, A_{i-1}))
end for
return answer A_B

💡

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

💡 Адаптация для ревью текстов: Вместо "проверь ответ" — "вот черновик письма клиенту, найди слабые места, потом напиши улучшенную версию"

Промпт:

Задача: Написать письмо клиенту с извинениями за задержку доставки.

Черновик: "Здравствуйте! Ваш заказ задерживается. Извините."

Сначала найди проблемы в черновике (тон, полнота, конкретика). 
Затем напиши улучшенную версию.

🔧 Техника: добавить структуру проверки → глубже анализ

Вместо просто "проверь ответ" можно направить проверку:

Проверь предлагаемый ответ по критериям:
1. Математическая корректность вычислений
2. Соответствие условию задачи
3. Логичность рассуждений

Затем дай исправленный ответ.

💡 Экстраполяция: VF + Devil's Advocate

Комбинация VF с ролевой игрой — попроси модель искать ошибки агрессивно:

Задача: {описание}

Предлагаемый ответ: {ответ}

Ты — скептик-аудитор. Твоя цель — найти ВСЕ возможные ошибки, неточности 
и слабые места в предлагаемом ответе. Будь придирчив.

После критики дай исправленный ответ.

🔗

Ресурсы

Статья: "Verification-First: An Extremely Cheap Way to Improve LLM Reasoning"

Авторы: Shiguang Wu, Quanming Yao (Tsinghua University, Department of Electronic Engineering)

Ссылки из статьи: Chain-of-Thought (Wei et al., 2022), Self-Refine (Madaan et al., 2023), Reflexion (Shinn et al., 2023)


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

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

Парадокс: LLM лучше критикует чужие ответы, чем генерирует правильные свои. Причина — эгоцентризм авторегрессии: модель цепляется за первый вариант и защищает его, а не ищет ошибки. Verification-First ломает эту защиту: заставляет модель сначала проверить чужой ответ (даже абсурдный '1'), что включает критическое мышление вместо защиты. Фишка: проверка чужого ответа выключает режим защиты. Модель ищет противоречия, формулирует уравнения, строит контрпримеры — эта структура ведёт к правильному решению. +5-7% точности на математике из добавления одной строчки.

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

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

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

Авторегрессивная генерация создаёт эгоцентризм — модель оптимизирует связность текста, не правильность. Если допущена ошибка в начале, модель продолжает строить логику поверх неё, потому что защищает свою генерацию. Проверить проще чем решить — верификация когнитивно легче генерации для LLM. Когда модель проверяет чужой ответ, она не защищает его: ищет ошибки, формулирует уравнения явно, проверяет граничные условия. Даже абсурдный '1' запускает полезный процесс — модель вынуждена объяснить почему это неверно. На GSM8K (математика) +5-7% точности, на MATH +3-4%. Основной прирост на задачах требующих рассуждений, не знаний.

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

Математика, финмоделирование, логические задачи — везде где нужны рассуждения и вычисления. Особенно эффективно когда модель делает арифметические ошибки или цепляется за первый неверный подход. НЕ подходит для задач требующих фактических знаний — VF улучшает логику, не восполняет пробелы в знаниях (на научных вопросах GPQA прирост только ~2-3%).

Мини-рецепт

1. Базовый VF (один запрос): Добавь к задаче строчку: Предлагаемый ответ: 1. Сначала проверь этот ответ, затем дай правильный с объяснением. Для выбора используй 'Вариант Б', для да/нет — 'Да'.

2. Для сложных задач (два запроса): Сначала получи первый ответ обычным пошаговым промптом (Chain-of-Thought), затем дай его модели для проверки: Предыдущий ответ: [скопируй сюда]. Проверь его и дай исправленный или подтверждённый ответ.

3. Итеративный вариант (3-5 раз): Повторяй шаг 2, каждый раз передавая только финальный ответ из предыдущего запроса — без рассуждений, без накопления контекста. Основной прирост на первых 2-3 итерациях.

Примеры

[ПЛОХО] : Фиксированные расходы 450 000₽/мес, маржинальность продажи 1 500₽. Сколько продаж нужно для безубыточности?
[ХОРОШО] : Фиксированные расходы 450 000₽/мес, маржинальность продажи 1 500₽. Сколько продаж нужно для безубыточности? Предлагаемый ответ: 1 Сначала проверь предлагаемый ответ — найди ошибки или подтверди правильность. Затем дай правильный ответ с объяснением. Модель начнёт: 'Если 1 продажа → выручка 1 500₽ vs расходы 450 000₽ — очевидно не покрывает'. Сформулирует уравнение: 1 500 × N = 450 000, даст ответ 300 продаж. Процесс проверки вынудил модель явно записать соотношение между переменными — снижает шанс арифметической ошибки.
Источник: Asking LLMs to Verify First is Almost Free Lunch
ArXiv ID: 2511.21734 | Сгенерировано: 2026-01-11 20:19

Проблемы LLM

ПроблемаСутьКак обойти
Авторегрессивный эгоцентризмМодель генерирует токен за токеном. Первый ответ становится якорем. Если в начале ошибка — модель строит логику поверх неё. Почему? Она оптимизирует связность текста, не правильность. Защищает свой вариант вместо поиска ошибок. Это проблема для всех задач где нужны многошаговые рассужденияДай модели "чужой" ответ для проверки. Даже абсурдный: "Предлагаемый ответ: 1". Попроси сначала проверить его, потом дать правильный. Проверка чужого выключает режим защиты. Модель начинает критиковать, искать ошибки — это запускает рассуждение от ответа к условию

Методы

МетодСуть
Проверка перед генерацией — включает критическое мышлениеМеняешь порядок работы. Обычно: "думай по шагам дай ответ". VF: "вот ответ [любой] проверь его дай правильный". Базовый вариант: Добавь в промпт Предлагаемый ответ: {тривиальный}. Для чисел — "1". Для выбора — "Вариант Б". Попроси: "Проверь этот ответ. Найди ошибки. Потом дай правильный". Продвинутый: Сначала обычный запрос получи Ответ_1. Второй запрос: "Предыдущий ответ: {Ответ_1}. Проверь его. Дай исправленный". Итеративный: Повторяй проверку 3-5 раз. Каждый раз бери ТОЛЬКО финальный ответ из прошлого шага, не весь текст. Почему работает: Проверка когнитивно проще генерации. "Чужой" ответ выключает эгоцентризм — модель не защищает его. Включается критика: ищет противоречия, строит контрпримеры, явно формулирует условия. Эта структура потом используется для правильного ответа. Работает: математика, логика, код, многошаговые рассуждения. Слабее: задачи на знания (где проблема не в логике, а в отсутствии фактов). Ограничения: Для открытых задач тривиальный ответ бесполезен — используй двухшаговый вариант. После 5-10 итераций прирост замедляется

Тезисы

ТезисКомментарий
Проверить проще чем создатьГенерация с нуля: модель ищет в пространстве всех возможных решений. Проверка: есть конкретный объект для анализа. Для LLM это значит: при генерации первая ошибка создаёт каскад (эгоцентризм). При проверке — можно найти противоречие и остановиться. Даже слабая модель хорошо критикует. Применяй: Для сложных задач не проси сразу "реши". Дай черновой ответ (свой или сгенерированный) и попроси проверить
📖 Простыми словами

Verification-First (VF): проверка перед генерацией улучшает рассуждения LLM

arXiv: 2511.21734

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

Это как если бы ты попросил пьяного друга дойти до магазина, и он, свернув не туда, начал бы убеждать тебя, что аптека — это и есть булочная, просто вывеску сменили. Метод Verification-First (VF) меняет правила игры: ты подсовываешь модели любой ответ (даже заведомо ложный) и заставляешь её сначала побыть критиком. Вместо того чтобы просто «идти вперед», модель вынуждена включить обратное рассуждение от результата к условию, что моментально подсвечивает все логические дыры.

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

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

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

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

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

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