# Multi-step Reasoning - MCTS with Chain of Thought

This example demonstrates MCTS for multi-step reasoning problems, where the LLM generates chain-of-thought reasoning at each step.

```julia
using LLMMCTS

# State tracks the reasoning process
# thought_history: Dict mapping thought/action keys to their content

function reasoning_transition(state::Dict, args::NamedTuple)
    current_step = get(state, :step, 0)
    thought_history = get(state, :thought_history, Dict{String, String}())
    problem = state[:problem]
    
    if current_step == 0
        # Step 1: Understand the problem
        thought = "First, I need to understand what the problem is asking. The problem requires me to analyze the given information and determine the solution approach."
        action = "Identify the key components of the problem"
        
        new_thought_history = copy(thought_history)
        new_thought_history["thought_1"] = thought
        new_thought_history["action_1"] = action
        
        newstate = Dict(
            :step => 1,
            :thought_history => new_thought_history,
            :reward => 1.0,
            :isterminal => false
        )
        progressvalue = 3.0
    elseif current_step == 1
        # Step 2: Break down the problem
        thought = "Next, I should break this down into smaller sub-problems. This will make it easier to solve step by step."
        action = "Divide the problem into manageable parts"
        
        new_thought_history = copy(thought_history)
        new_thought_history["thought_2"] = thought
        new_thought_history["action_2"] = action
        
        newstate = Dict(
            :step => 2,
            :thought_history => new_thought_history,
            :reward => 2.0,
            :isterminal => false
        )
        progressvalue = 5.0
    elseif current_step == 2
        # Step 3: Solve each sub-problem
        thought = "Now I'll solve each sub-problem individually, using appropriate methods for each."
        action = "Apply solution methods to each sub-problem"
        
        new_thought_history = copy(thought_history)
        new_thought_history["thought_3"] = thought
        new_thought_history["action_3"] = action
        
        newstate = Dict(
            :step => 3,
            :thought_history => new_thought_history,
            :reward => 3.0,
            :isterminal => false
        )
        progressvalue = 7.0
    elseif current_step == 3
        # Step 4: Combine solutions
        thought = "Finally, I'll combine all the solutions to form the complete answer to the original problem."
        action = "Integrate solutions and verify the answer"
        
        new_thought_history = copy(thought_history)
        new_thought_history["thought_4"] = thought
        new_thought_history["action_4"] = action
        
        newstate = Dict(
            :step => 4,
            :thought_history => new_thought_history,
            :reward => 4.0,
            :isterminal => true  # Reasoning complete
        )
        progressvalue = 10.0
    else
        newstate = Dict(
            :step => current_step,
            :thought_history => thought_history,
            :reward => 10.0,
            :isterminal => true
        )
        progressvalue = 10.0
    end
    
    return Dict(
        :newNodeKey => "reasoning_step_$current_step",
        :newstate => newstate,
        :progressvalue => progressvalue
    )
end

# Initial state
initialstate = Dict(
    :step => 0,
    :problem => "Explain how photosynthesis works",
    :thought_history => Dict{String, String}(),
    :reward => 0,
    :isterminal => false
)

# Transition arguments
transitionargs = (max_steps = 4,)

# Run MCTS
result = runMCTS(
    initialstate,
    reasoning_transition,
    transitionargs;
    maxiterations = 25,
    explorationweight = 1.0,
    maxSimulationDepth = 4,
    horizontalSampleExpansionPhase = 3
)

# Display results
println("Multi-step Reasoning Example")
println("=============================")
println()
println("Problem: ", initialstate[:problem])
println()
println("Reasoning steps:")
for (key, value) in result.bestTerminalState[:thought_history]
    println("  $key: $value")
end
println()
println("Reasoning complete! ✓")
println("Root node visits: ", result.root.visits)
println("Total steps in reasoning chain: ", result.bestTerminalState[:step])
```