Algorithm of Thoughts (AoT)

from openai import OpenAI

client = OpenAI()

def algorithm_of_thoughts(task: str, max_tokens: int = 4096) -> str:
    """
    Algorithm of Thoughts: модель выполняет
    алгоритмический поиск в одном промпте.
    """
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "Решай задачу методом алгоритмического поиска. "
                    "Следуй DFS-подобному алгоритму:\n"
                    "1. Выбери первый возможный путь и иди вглубь\n"
                    "2. На каждом шаге оценивай: приближается ли "
                    "путь к решению?\n"
                    "3. Если тупик — напиши 'ВОЗВРАТ' и вернись "
                    "к последней развилке\n"
                    "4. Попробуй следующий путь\n"
                    "5. Когда решение найдено — напиши "
                    "'РЕШЕНИЕ НАЙДЕНО:' и итог\n"
                    "6. Если все пути исчерпаны — напиши "
                    "'РЕШЕНИЕ НЕ СУЩЕСТВУЕТ'\n"
                    "Помни о ранее найденных тупиках — "
                    "не повторяй их."
                ),
            },
            {"role": "user", "content": task},
        ],
        max_tokens=max_tokens,
        temperature=0.2,  # низкая для систематичности
    )
    return response.choices[0].message.content


result = algorithm_of_thoughts(
    "Расставь числа от 1 до 8 по вершинам куба так, "
    "чтобы сумма на каждом ребре была чётной."
)
print(result)

import anthropic
import re

client = anthropic.Anthropic()

def aot_with_parsing(task: str) -> dict:
    """
    AoT с парсингом: извлекаем путь поиска,
    количество возвратов и финальное решение.
    """
    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": (
                    f"Задача: {task}\n\n"
                    "Реши методом алгоритмического поиска "
                    "(DFS с возвратами). На каждом шаге:\n"
                    "- Пронумеруй путь: 'ПУТЬ N:'\n"
                    "- При тупике напиши: 'ТУПИК. ВОЗВРАТ.'\n"
                    "- При нахождении решения: 'РЕШЕНИЕ: ...'\n"
                    "Начинай."
                ),
            }
        ],
    )

    text = message.content[0].text

    # Парсим результаты
    paths = re.findall(r"ПУТЬ\s+\d+", text)
    backtracks = text.count("ВОЗВРАТ")
    solution_match = re.search(
        r"РЕШЕНИЕ:\s*(.+?)(?:\n\n|\Z)", text, re.DOTALL
    )
    solution = (
        solution_match.group(1).strip()
        if solution_match
        else "Не найдено"
    )

    return {
        "full_trace": text,
        "paths_explored": len(paths),
        "backtracks": backtracks,
        "solution": solution,
        "efficiency": (
            f"{len(paths)} путей, "
            f"{backtracks} возвратов"
        ),
    }


result = aot_with_parsing(
    "Размести 4 ферзей на доске 4×4 так, "
    "чтобы ни один не бил другого."
)
print(f"Решение: {result['solution']}")
print(f"Эффективность: {result['efficiency']}")

def compare_cost():
    """
    Сравнение стоимости AoT и ToT на одной задаче.
    """
    # ToT: генерация + оценка на каждом уровне
    tot_calls = 0
    depth = 3
    branches = 3
    for level in range(depth):
        tot_calls += branches  # генерация
        tot_calls += branches  # оценка
    # Итого: 3 уровня × (3 генерации + 3 оценки) = 18 вызовов

    # AoT: один вызов
    aot_calls = 1

    # Стоимость (приблизительно, GPT-4o)
    cost_per_call = 0.02  # ~$0.02 за средний вызов
    tot_cost = tot_calls * cost_per_call
    aot_cost = aot_calls * cost_per_call * 3  # длинный промпт

    print(f"ToT: {tot_calls} вызовов ≈ ${tot_cost:.2f}")
    print(f"AoT: {aot_calls} вызов ≈ ${aot_cost:.2f}")
    print(f"Экономия: {(1 - aot_cost/tot_cost)*100:.0f}%")


compare_cost()