Cumulative Reasoning

from dataclasses import dataclass, field
from openai import OpenAI

client = OpenAI()

@dataclass
class VerifiedFact:
    """Верифицированное утверждение в DAG."""
    id: int
    content: str
    depends_on: list[int] = field(default_factory=list)  # ID зависимостей
    confidence: float = 1.0


PROPOSER_PROMPT = """Ты — Proposer в системе Cumulative Reasoning.

Задача: {task}

Уже подтверждённые факты:
{facts}

Предложи ОДНО новое утверждение — следующий шаг к решению.
Утверждение должно опираться на подтверждённые факты.
Формат: одно предложение, конкретное и проверяемое."""

VERIFIER_PROMPT = """Ты — Verifier в системе Cumulative Reasoning.

Задача: {task}

Подтверждённые факты:
{facts}

Новое утверждение для проверки:
{proposition}

Проверь:
1. Логически корректно?
2. Следует из подтверждённых фактов или условия задачи?
3. Нет арифметических или логических ошибок?

Ответь ОДНИМ словом: ВЕРНО или НЕВЕРНО. Затем кратко обоснуй."""

REPORTER_PROMPT = """Ты — Reporter в системе Cumulative Reasoning.

Задача: {task}

Подтверждённые факты:
{facts}

Достаточно ли фактов для финального ответа?
Если ДА — сформулируй ответ.
Если НЕТ — ответь «ПРОДОЛЖИТЬ»."""


class CumulativeReasoner:
    """Реализация Cumulative Reasoning с тремя LLM-ролями."""

    def __init__(self, model: str = "gpt-4o", max_rounds: int = 15):
        self.model = model
        self.max_rounds = max_rounds
        self.facts: list[VerifiedFact] = []
        self.fact_counter = 0

    def _format_facts(self) -> str:
        if not self.facts:
            return "(пока нет подтверждённых фактов)"
        return "\n".join(
            f"[F{f.id}] {f.content}"
            for f in self.facts
        )

    def _propose(self, task: str) -> str:
        """Proposer генерирует новое утверждение."""
        resp = client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": PROPOSER_PROMPT.format(
                task=task, facts=self._format_facts()
            )}],
            temperature=0.7
        )
        return resp.choices[0].message.content.strip()

    def _verify(self, task: str, proposition: str) -> bool:
        """Verifier проверяет утверждение."""
        resp = client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": VERIFIER_PROMPT.format(
                task=task, facts=self._format_facts(), proposition=proposition
            )}],
            temperature=0
        )
        answer = resp.choices[0].message.content.strip()
        return answer.upper().startswith("ВЕРНО")

    def _report(self, task: str) -> str | None:
        """Reporter проверяет, достаточно ли фактов."""
        resp = client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": REPORTER_PROMPT.format(
                task=task, facts=self._format_facts()
            )}],
            temperature=0
        )
        answer = resp.choices[0].message.content.strip()
        if "ПРОДОЛЖИТЬ" in answer.upper():
            return None
        return answer

    def solve(self, task: str) -> dict:
        """Полный цикл Cumulative Reasoning."""
        self.facts = []
        self.fact_counter = 0

        for round_num in range(self.max_rounds):
            # Proposer
            proposition = self._propose(task)

            # Verifier
            is_valid = self._verify(task, proposition)

            if is_valid:
                self.fact_counter += 1
                self.facts.append(VerifiedFact(
                    id=self.fact_counter,
                    content=proposition
                ))

                # Reporter
                final_answer = self._report(task)
                if final_answer:
                    return {
                        "answer": final_answer,
                        "facts": [f.content for f in self.facts],
                        "rounds": round_num + 1,
                        "rejected": round_num + 1 - len(self.facts)
                    }

        return {
            "answer": "Не удалось найти ответ за отведённые раунды",
            "facts": [f.content for f in self.facts],
            "rounds": self.max_rounds,
            "rejected": self.max_rounds - len(self.facts)
        }


# Пример использования
reasoner = CumulativeReasoner(model="gpt-4o", max_rounds=15)

result = reasoner.solve(
    "Числа: 1, 3, 4, 6. Получи 24, используя каждое число один раз "
    "и операции +, -, ×, ÷."
)

print(f"Ответ: {result['answer']}")
print(f"Раундов: {result['rounds']}")
print(f"Отклонено: {result['rejected']}")
print(f"Верифицированные факты:")
for f in result["facts"]:
    print(f"  - {f}")

class CrossModelReasoner(CumulativeReasoner):
    """Разные модели для разных ролей — повышает надёжность."""

    def __init__(
        self,
        proposer_model: str = "claude-sonnet-4-20250514",
        verifier_model: str = "gpt-4o",
        reporter_model: str = "gpt-4o-mini",
        max_rounds: int = 15
    ):
        super().__init__(max_rounds=max_rounds)
        self.proposer_model = proposer_model
        self.verifier_model = verifier_model
        self.reporter_model = reporter_model

    def _propose(self, task: str) -> str:
        self.model = self.proposer_model
        return super()._propose(task)

    def _verify(self, task: str, proposition: str) -> bool:
        self.model = self.verifier_model
        return super()._verify(task, proposition)

    def _report(self, task: str) -> str | None:
        self.model = self.reporter_model
        return super()._report(task)