Tree-of-thought for complex decisions in Agentic AI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a tree-of-thought search with an initial state.

Agentic AI

tree = TreeOfThought(initial_state=[1])

Drag options to blanks, or click blank then click option'

Astart_state

Binitial_state

Croot_state

Dstate0

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names that are not recognized by the TreeOfThought constructor.

Confusing the initial state with other variable names.

The TreeOfThought class requires the initial_state parameter to start the search tree.

2fill in blank

medium

Complete the code to expand the current node by generating possible next thoughts.

Agentic AI

next_nodes = current_node.[1]()

Drag options to blanks, or click blank then click option'

Aexpand

Bbranch

Cgrow

Dgenerate

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names that do not exist on the node object.

Confusing expansion with evaluation or selection.

The method expand() is used to generate the next possible thoughts or nodes from the current node.

3fill in blank

hard

Fix the error in the code to correctly evaluate the utility of a node.

Agentic AI

score = node.evaluate_utility([1])

Drag options to blanks, or click blank then click option'

Ascore_function

Butility_score

Cevaluate

Dheuristic_function

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a numeric score instead of a function.

Using incorrect parameter names that cause runtime errors.

The evaluate_utility method requires a heuristic_function to estimate the node's value.

4fill in blank

hard

Fill both blanks to select the best child node based on utility and update the current node.

Agentic AI

best_child = max(current_node.children, key=lambda n: n.[1])
current_node = current_node.[2](best_child)

Drag options to blanks, or click blank then click option'

Autility_score

Bselect_child

Cevaluate_utility

Dmove_to

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method instead of an attribute for the key function.

Trying to assign the current node without using the proper method.

The utility_score attribute is used to find the best child, and move_to() updates the current node to that child.

5fill in blank

hard

Fill all three blanks to implement a recursive tree-of-thought search with depth limit.

Agentic AI

def tree_search(node, depth):
    if depth == 0 or node.is_terminal():
        return node.[1]()
    best_score = float('-inf')
    best_action = None
    for child in node.[2]():
        score = tree_search(child, depth - 1)
        if score > best_score:
            best_score = score
            best_action = child
    return node.[3](best_action)

Drag options to blanks, or click blank then click option'

Aevaluate_utility

Bexpand

Cselect_child

Dgenerate

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up method names for generating children and selecting best child.

Returning the wrong value at the base case.

The function evaluate_utility() returns the node's score, expand() generates children, and select_child() chooses the best child node.

Practice

1.

What is the main purpose of using a tree-of-thought approach in complex decisions?

easy

A. To avoid making any decision

B. To randomly select an action without analysis

C. To break down decisions into smaller, manageable steps

D. To speed up decisions by ignoring options

Solution

1. Step 1: Understand the concept of tree-of-thought

   Tree-of-thought breaks complex decisions into smaller steps to simplify the process.

2. Step 2: Identify the purpose of breaking down decisions

   This helps explore options carefully and find better solutions.

3. Final Answer:

   To break down decisions into smaller, manageable steps -> Option C

4. Quick Check:

   Tree-of-thought = smaller steps [OK]

Hint: Think of breaking big problems into small parts [OK]

Common Mistakes:

• Confusing tree-of-thought with random choice
• Thinking it avoids decisions
• Assuming it speeds up by ignoring options

2.

Which of the following correctly represents a step in building a tree-of-thought?

1. Start with initial state
2. Generate possible actions
3. Evaluate outcomes
4. Choose best path

easy

A. Choose best path, generate actions, start with initial state, evaluate outcomes

B. Start with initial state, generate actions, evaluate outcomes, choose best path

C. Evaluate outcomes, choose best path, start with initial state, generate actions

D. Generate actions, start with initial state, choose best path, evaluate outcomes

Solution

1. Step 1: Identify the logical order of steps

   We start from the initial state, then generate possible actions.

2. Step 2: Follow with evaluation and choice

   After generating actions, we evaluate outcomes and choose the best path.

3. Final Answer:

   Start with initial state, generate actions, evaluate outcomes, choose best path -> Option B

4. Quick Check:

   Logical step order = B [OK]

Hint: Follow the natural decision flow order [OK]

Common Mistakes:

• Mixing up the order of steps
• Starting with choice before generating actions
• Evaluating before generating actions

3.

Given the following simplified tree-of-thought code snippet, what is the printed output?

def tree_of_thought(state, depth):
    if depth == 0:
        return [state]
    results = []
    for action in ['A', 'B']:
        next_state = state + action
        results.extend(tree_of_thought(next_state, depth - 1))
    return results

print(tree_of_thought('', 2))

medium

A. ['AA', 'AB', 'BA', 'BB']

B. ['A', 'B']

C. ['', 'A', 'B']

D. ['AA', 'AB', 'BA']

Solution

1. Step 1: Understand recursion and depth

   At depth 2, the function appends two actions at each step, building strings of length 2.

2. Step 2: Trace the recursive calls

   Starting with '', actions 'A' and 'B' add to form 'A' and 'B', then again add 'A' or 'B' to form 'AA', 'AB', 'BA', 'BB'.

3. Final Answer:

   ['AA', 'AB', 'BA', 'BB'] -> Option A

4. Quick Check:

   All 2-length action combos = C [OK]

Hint: Count depth levels and action combinations [OK]

Common Mistakes:

• Confusing depth with number of actions
• Returning partial strings
• Missing recursive expansion

4.

Identify the error in this tree-of-thought function that prevents it from exploring all branches:

def tree_of_thought(state, depth):
    if depth == 0:
        return [state]
    results = []
    for action in ['A', 'B']:
        next_state = state + action
        results.append(tree_of_thought(next_state, depth - 1))
    return results

print(tree_of_thought('', 2))

medium

A. Using append instead of extend causes nested lists

B. Missing base case for depth == 0

C. Looping over wrong actions

D. Returning results before recursion

Solution

1. Step 1: Analyze list operations in recursion

   Using append adds the entire recursive list as a single element, creating nested lists.

2. Step 2: Correct method to flatten results

   Using extend adds elements individually, flattening the list as intended.

3. Final Answer:

   Using append instead of extend causes nested lists -> Option A

4. Quick Check:

   append vs extend affects list shape [OK]

Hint: Use extend to flatten recursive results [OK]

Common Mistakes:

• Confusing append and extend
• Ignoring base case presence
• Misunderstanding recursion flow

5.

You want to use tree-of-thought to decide the best sequence of moves in a game where each move has a score. Which approach best fits this goal?

def tree_of_thought(state, depth):
    if depth == 0:
        return [(state, score(state))]
    results = []
    for action in possible_actions(state):
        next_state = apply_action(state, action)
        results.extend(tree_of_thought(next_state, depth - 1))
    return results

# How to choose best sequence?

hard

A. Stop recursion early without exploring all sequences

B. Pick the first sequence returned without comparing scores

C. Ignore scores and choose randomly

D. After collecting all sequences and scores, select the sequence with the highest score

Solution

1. Step 1: Understand the goal of maximizing score

   The goal is to find the sequence with the highest score after exploring all options.

2. Step 2: Choose the best sequence after full exploration

   Collecting all sequences and their scores allows selecting the best one reliably.

3. Final Answer:

   After collecting all sequences and scores, select the sequence with the highest score -> Option D

4. Quick Check:

   Best score selection after exploration = A [OK]

Hint: Explore all, then pick highest score [OK]

Common Mistakes:

• Choosing first sequence without comparison
• Ignoring scores
• Stopping early and missing better options