Question: A jug holds 3 liters. It is filled with a 30% salt solution.
4 liters of pure water are added. What is the new salt concentration?

Let's think step by step.

{problem}

Think step by step inside <reasoning> tags.
After </reasoning>, give ONLY the final answer with no explanation.

import re
import anthropic

client = anthropic.Anthropic()

def solve_with_cot(problem: str) -> tuple[str, str]:
    """Returns (reasoning, answer)."""
    resp = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": (
                f"{problem}\n\n"
                "Think step by step inside <reasoning> tags. "
                "After </reasoning>, give ONLY the final answer."
            ),
        }],
    )
    text = resp.content[0].text
    reasoning = re.search(r"<reasoning>(.*?)</reasoning>", text, re.DOTALL)
    answer = re.sub(r"<reasoning>.*?</reasoning>", "", text, flags=re.DOTALL).strip()
    return (reasoning.group(1).strip() if reasoning else "", answer)

reasoning, answer = solve_with_cot(
    "A jug holds 3L of 30% salt solution. Add 4L pure water. New concentration?"
)
print("Answer:", answer)

Answer: ~12.86% (0.9L salt in 7L total)

Solve each problem. Show step-by-step reasoning before the final answer.

Q: A train leaves Station A at 9am going 60 mph. Another leaves Station B at 10am
   going 80 mph toward A. Stations are 280 miles apart. When do they meet?
A: Let t = hours after 9am.
   Train 1 position from A: 60 * t
   Train 2 starts at 10am (so t=1 onwards): 80 * (t - 1) from B
   They meet when 60t + 80(t-1) = 280
   60t + 80t - 80 = 280
   140t = 360
   t = 2.57 hours after 9am
   Final answer: ~11:34 am

Q: If 5 workers can build a wall in 8 days, how long for 8 workers (same rate)?
A: Total worker-days = 5 * 8 = 40
   New time = 40 / 8 = 5 days
   Final answer: 5 days

Q: {new_problem}
A:

import anthropic
from collections import Counter

client = anthropic.Anthropic()

def self_consistency(problem: str, n: int = 5, temperature: float = 0.7) -> dict:
    """Sample n reasoning paths and majority-vote the final answer."""
    answers = []
    for _ in range(n):
        resp = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=1500,
            temperature=temperature,
            messages=[{
                "role": "user",
                "content": (
                    f"{problem}\n\n"
                    "Think step by step. End with: Final answer: <answer>"
                ),
            }],
        )
        text = resp.content[0].text
        if "Final answer:" in text:
            answer = text.split("Final answer:")[-1].strip().split("\n")[0]
            answers.append(answer)

    counts = Counter(answers)
    winner, votes = counts.most_common(1)[0]
    return {
        "answer": winner,
        "confidence": votes / n,
        "all_answers": dict(counts),
        "samples": n,
    }

result = self_consistency("What is 47 * 83?", n=5)
print(result)

{'answer': '3901', 'confidence': 1.0, 'all_answers': {'3901': 5}, 'samples': 5}

def adaptive_consistency(problem: str, easy_threshold: float = 0.9) -> dict:
    # First pass: ask for answer + self-rated confidence
    first = call_claude(
        f"{problem}\n\nThink step by step. End with:\n"
        f"Final answer: <answer>\nConfidence (0-1): <num>"
    )
    if extract_confidence(first) >= easy_threshold:
        return {"answer": extract_answer(first), "samples": 1}
    # Escalate
    return self_consistency(problem, n=5)

import anthropic

client = anthropic.Anthropic()

def expand_thoughts(state: str, k: int = 3) -> list[str]:
    """Generate k candidate next steps from the current state."""
    resp = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=600,
        temperature=0.8,
        messages=[{
            "role": "user",
            "content": (
                f"Current state:\n{state}\n\n"
                f"Propose {k} distinct next steps. Number them 1-{k}. "
                f"Each step should be one short paragraph."
            ),
        }],
    )
    return parse_numbered_list(resp.content[0].text, k)

def score_thought(thought: str, goal: str) -> float:
    """Heuristic score from 0-1 for how promising the thought is."""
    resp = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=20,
        messages=[{
            "role": "user",
            "content": (
                f"Goal: {goal}\nProposed step: {thought}\n\n"
                "Rate 0-1 how likely this step is to reach the goal. "
                "Reply with the number only."
            ),
        }],
    )
    try:
        return float(resp.content[0].text.strip())
    except ValueError:
        return 0.0

def tot_search(problem: str, max_depth: int = 4, beam: int = 3) -> str:
    """Beam-search over thought tree."""
    frontier = [problem]
    for depth in range(max_depth):
        candidates = []
        for state in frontier:
            for thought in expand_thoughts(state, k=3):
                score = score_thought(thought, problem)
                candidates.append((score, state + "\n" + thought))
        candidates.sort(reverse=True)
        frontier = [s for _, s in candidates[:beam]]
        if any("FINAL ANSWER" in s for s in frontier):
            return next(s for s in frontier if "FINAL ANSWER" in s)
    return frontier[0]

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",          # Opus required for extended thinking
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000,        # cap on private reasoning tokens
    },
    messages=[{
        "role": "user",
        "content": (
            "A 3-digit number is divisible by 7 and 11. Its digits sum to 13. "
            "What's the largest such number?"
        ),
    }],
)

for block in response.content:
    if block.type == "thinking":
        print(f"[Thinking: {len(block.thinking)} chars (hidden)]")
    elif block.type == "text":
        print("Answer:", block.text)

[Thinking: 2104 chars (hidden)]
Answer: 847 (847 = 7 * 11 * 11, digits 8+4+7=19... no, recompute) 

Actually the largest 3-digit multiple of 77 with digit sum 13 is 616 (6+1+6=13).

PROMPT 1 (extract principle):
Question: A 2 kg ball is dropped from 10 m. What is its KE just before hitting the ground?
What general principle is needed to solve this? Reply in one sentence.

PROMPT 2 (apply principle):
Question: A 2 kg ball is dropped from 10 m. What is its KE just before hitting the ground?
Principle: Conservation of energy — PE at the top equals KE at the bottom.
Apply this principle step by step.

Problem: {problem}

Step 1 — DEVISE A PLAN.
List the sub-steps needed to solve this problem. Number them 1, 2, 3, ...
Do NOT solve yet.

Step 2 — EXECUTE THE PLAN.
Now work through each numbered step. Show calculations.

Step 3 — FINAL ANSWER.
State the final answer on its own line: "Final answer: <answer>"

def cot_with_critique(problem: str) -> str:
    draft = call_claude(
        f"{problem}\n\nThink step by step and give your answer.",
        max_tokens=1500,
    )

    revised = call_claude(
        f"Problem: {problem}\n\n"
        f"My draft solution:\n{draft}\n\n"
        "Review this for arithmetic errors, logical gaps, and misread conditions. "
        "List any issues, then provide a corrected final answer if needed. "
        "If the draft is correct, say 'no changes' and repeat the final answer.",
        max_tokens=1500,
    )
    return revised

☐ The answer is a single token (classification, yes/no, label)
☐ Latency budget is tight (chat UX, autocomplete)
☐ Reasoning chain might expose sensitive sources (RAG over private docs)
☐ The model gets it right zero-shot — measure before adding CoT
☐ Output is for a downstream model that doesn't need the reasoning
☐ The task is style/tone rewriting where reasoning doesn't help

def user_facing_answer(problem: str) -> str:
    """Run CoT, return only the clean final answer for the user."""
    resp = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1500,
        messages=[{
            "role": "user",
            "content": (
                f"{problem}\n\n"
                "Reason in <thinking> tags, then output the user-facing answer in <answer> tags. "
                "The answer must be self-contained and friendly — do not refer to your reasoning."
            ),
        }],
    )
    text = resp.content[0].text
    match = re.search(r"<answer>(.*?)</answer>", text, re.DOTALL)
    return match.group(1).strip() if match else text

def solve_word_problem(problem: str) -> dict:
    resp = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2000,
        messages=[{
            "role": "user",
            "content": (
                f"Solve this word problem step by step.\n\n"
                f"Problem: {problem}\n\n"
                f"Format:\n"
                f"Step 1: <identify variables and what's being asked>\n"
                f"Step 2: <set up equations or relationships>\n"
                f"Step 3: <solve algebraically>\n"
                f"Step 4: <check the answer is reasonable>\n"
                f"Final answer: <number with units>"
            ),
        }],
    )
    text = resp.content[0].text
    answer = text.split("Final answer:")[-1].strip()
    return {"reasoning": text, "answer": answer}

def debug_with_cot(code: str, error: str) -> str:
    return call_claude(f"""You are an expert debugger. Diagnose the failure step by step.

<code>
{code}
</code>

<error>
{error}
</error>

Reason through the failure:
1. What does the error message tell us about the failing line and condition?
2. Trace execution up to that point — what variables hold what values?
3. Identify the root cause (one sentence).
4. Propose a minimal fix as a diff.

End with:
<fix>
<diff>...</diff>
</fix>""", max_tokens=2000)

def route_ticket(ticket: str) -> dict:
    resp = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=600,
        messages=[{
            "role": "user",
            "content": f"""Route this ticket to a queue. Show your reasoning.

Available queues:
- urgent_billing (P1 billing issues, payment failures)
- general_billing (refunds, invoice questions)
- access (password, login, permissions)
- bug (broken behavior)
- product (feature requests, how-to)

Ticket: {ticket}

Reason in <thinking> tags. Then output:
<queue>queue_name</queue>
<priority>P1|P2|P3|P4</priority>
<reason>one sentence for the routing decision</reason>"""
        }],
    )
    text = resp.content[0].text
    return {
        "queue": re.search(r"<queue>(.*?)</queue>", text).group(1),
        "priority": re.search(r"<priority>(.*?)</priority>", text).group(1),
        "reason": re.search(r"<reason>(.*?)</reason>", text).group(1),
        "raw": text,
    }

def generate_then_verify(problem: str) -> str:
    candidates = [
        call_claude(f"{problem}\n\nThink step by step.", temperature=0.7)
        for _ in range(3)
    ]

    verifier_prompt = (
        f"Problem: {problem}\n\n"
        + "\n\n---\n\n".join(f"Candidate {i+1}:\n{c}" for i, c in enumerate(candidates))
        + "\n\nWhich candidate has the most correct reasoning? Reply with the number and a one-sentence justification, then restate the final answer."
    )
    return call_claude(verifier_prompt, temperature=0.0)