diff --git a/tutorials/tree-of-thought-prompting/API.py b/tutorials/tree-of-thought-prompting/API.py new file mode 100644 index 0000000..10f9573 --- /dev/null +++ b/tutorials/tree-of-thought-prompting/API.py @@ -0,0 +1,78 @@ +# @Author: Bertan Berker +# @Language: Python 3.11.9 +# @Description: This is a Flask API implementation for using the tree of thought reasoning + +from flask import Flask, request, jsonify +from flask_cors import CORS +import os +from dotenv import load_dotenv +from DFS_tree_of_thought import dfs_reasoning_solver_full_tree, get_all_paths_from_root, score_reasoning_path, summarize_best_path + +# Initialize Flask app +app = Flask(__name__) + +# Enable CORS with more permissive settings for development +CORS(app, + resources={r"/api/*": { + "origins": ["http://localhost:3000"], + "methods": ["POST", "OPTIONS"], + "allow_headers": ["Content-Type"], + "supports_credentials": True + }}) + +# Load environment variables +load_dotenv() + +@app.route('/api/chat', methods=['POST', 'OPTIONS']) +def chat(): + # Handle preflight requests + if request.method == 'OPTIONS': + response = jsonify({'status': 'ok'}) + response.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000') + response.headers.add('Access-Control-Allow-Headers', 'Content-Type') + response.headers.add('Access-Control-Allow-Methods', 'POST') + response.headers.add('Access-Control-Allow-Credentials', 'true') + return response + + try: + data = request.json + reasoning_prompt = data.get('message') + + if not reasoning_prompt: + return jsonify({'error': 'No message provided'}), 400 + + root = dfs_reasoning_solver_full_tree(reasoning_prompt) + all_paths = get_all_paths_from_root(root) + + best_score = -1 + best_path = None + + for i, path in enumerate(all_paths, start=1): + score = score_reasoning_path(path, reasoning_prompt) + + if score > best_score: + best_score = score + best_path = path + + answer = summarize_best_path(reasoning_prompt, best_path) + + response = jsonify({ + 'message': answer + }) + + # Add CORS headers to the response + response.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000') + response.headers.add('Access-Control-Allow-Credentials', 'true') + return response, 200 + + except Exception as e: + print(f"Error in /api/chat: {str(e)}") + error_response = jsonify({'error': str(e)}) + error_response.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000') + error_response.headers.add('Access-Control-Allow-Credentials', 'true') + return error_response, 500 + + +if __name__ == '__main__': + print("Server starting on http://localhost:3000") + app.run(debug=True, port=3000) \ No newline at end of file diff --git a/tutorials/tree-of-thought-prompting/BFS_tree_of_thought.py b/tutorials/tree-of-thought-prompting/BFS_tree_of_thought.py new file mode 100644 index 0000000..aa651b7 --- /dev/null +++ b/tutorials/tree-of-thought-prompting/BFS_tree_of_thought.py @@ -0,0 +1,196 @@ +# @ Author: Bertan Berker +# @ Language: Python 3.11.9 +# This script is an example of a tree of thought implementation for solving a reasoning task +# Given the prompt of a reasoning task, the script will generate a tree of thought and then +# solve the task by traversing the tree. + +import os +from dotenv import load_dotenv +from groq import Groq +from collections import deque + +load_dotenv() + +client = Groq( + api_key=os.environ.get("GROQ_API_KEY"), +) + + +# ThoughtNode class is used to represent a node in the tree of thought +# It contains the thought, the parent node, and the children nodes +# The thought is the content of the node +# The parent node is the node that comes before this node +# The children nodes are the nodes that come after this node +class ThoughtNode: + def __init__(self, thought, parent=None, score=None): + self.thought = thought + self.parent = parent + self.children = [] + + def add_child(self, child_node): + self.children.append(child_node) + + +# call_llm function is used to call the LLM +# :param prompt: The prompt to send to the LLM +# :return: The response from the LLM +def call_llm(prompt): + + chat_completion = client.chat.completions.create( + messages=[ + { + "role": "user", + "content": "You are a world class reasoning expert. You are given a reasoning problem to solve. This is your problem:" + prompt, + } + ], + model="llama-3.3-70b-versatile", + ) + + return chat_completion.choices[0].message.content + + +# generate_thought function is used to generate thoughts for the next step +# :param prompt: The prompt to send to the LLM +# :param step_number: The number of thoughts to generate +# :return: The thoughts from the LLM +def generate_thought(prompt, step_number): + + thought_prompt = f""" + Given the reasoning problem: "{prompt}", generate {step_number} different 'Thought' options to proceed with the solution step by step. + Each thought should be short, logical, and explore a different path. + + Format: + Thought {step_number}.1: ... + Thought {step_number}.2: ... + Thought {step_number}.3: ... + """ + + thoughts_text = call_llm(thought_prompt) + return thoughts_text + + +# bfs_reasoning_solver_full_tree function is used to solve the reasoning problem +# :param user_prompt: The prompt to send to the LLM +# :param max_depth: The maximum depth of the tree +# :param thoughts_per_step: The number of thoughts to generate for each step +# :return: The root node of the tree +def bfs_reasoning_solver_full_tree(user_prompt, max_depth=5, thoughts_per_step=3): + + root = ThoughtNode(thought=user_prompt) + queue = deque([root]) # BFS queue + + for depth in range(max_depth): + print(f"\nStep {depth + 1} ā€” Expanding {len(queue)} node(s)...") + current_level_nodes = list(queue) + queue.clear() + + for node in current_level_nodes: + print(f"\nExpanding:\nā†’ {node.thought}") + + thoughts_text = generate_thought(node.thought, step_number=thoughts_per_step) + print(f"\nGenerated Thoughts:\n{thoughts_text}") + + for line in thoughts_text.splitlines(): + if line.strip().startswith(f"Thought {thoughts_per_step}."): + thought_content = line.split(":", 1)[-1].strip() + child_node = ThoughtNode(thought=thought_content, parent=node) + node.add_child(child_node) + queue.append(child_node) + + return root + + +# get_all_paths_from_root function is used to get all paths from the root to the leaves +# :param node: The root node of the tree +# :return: All paths from the root to the leaves +def get_all_paths_from_root(node): + + if not node.children: + return [[node.thought]] + + paths = [] + for child in node.children: + for subpath in get_all_paths_from_root(child): + paths.append([node.thought] + subpath) + return paths + + +# score_reasoning_path function is used to score a reasoning path +# :param path: The path to score +# :param original_prompt: The original prompt to send to the LLM +# :return: The score of the path +def score_reasoning_path(path, original_prompt): + + joined_reasoning = "\n".join([f"Step {i+1}: {step}" for i, step in enumerate(path)]) + + prompt = f""" + You're evaluating a reasoning path for the problem: "{original_prompt}" + + Here is one possible reasoning path: + {joined_reasoning} + + Please rate the overall quality and effectiveness of this reasoning path on a scale from 1 to 100. + Just respond with a number between 1 and 100. + """ + + score_str = call_llm(prompt).strip() + try: + return int(score_str) + except ValueError: + return 0 # fallback if model responds weirdly + + +# summarize_best_path function is used to summarize the best path +# :param prompt: The original prompt to send to the LLM +# :param path: The best path to summarize +# :return: The summarized path +def summarize_best_path(prompt, path): + + chat_completion = client.chat.completions.create( + messages=[ + { + "role": "user", + "content": f"Given the prompt: {prompt}, summarize the best reasoning path as precisely and simply as possible \ + and give the final answer. The reasoning path is: {path}.", + } + ], + model="llama-3.3-70b-versatile", + ) + + return chat_completion.choices[0].message.content + + +if __name__ == "__main__": + reasoning_prompt = input("Enter a reasoning problem: ") + root = bfs_reasoning_solver_full_tree(reasoning_prompt, max_depth=3, thoughts_per_step=3) + + all_paths = get_all_paths_from_root(root) + print(f"\nšŸŒ² Found {len(all_paths)} reasoning paths.\n") + + for i, path in enumerate(all_paths, start=1): + print(f"Path {i}:") + for j, step in enumerate(path, start=1): + print(f" Step {j}: {step}") + print("---------------") + + best_score = -1 + best_path = None + + print("\nšŸ” Scoring all reasoning paths...\n") + + for i, path in enumerate(all_paths, start=1): + score = score_reasoning_path(path, reasoning_prompt) + print(f"Path {i}: Scored {score}/100") + + if score > best_score: + best_score = score + best_path = path + + # Show the best path + print("\nBest Reasoning Path:") + for i, step in enumerate(best_path, 1): + print(f"Step {i}: {step}") + print(f"\nFinal Score: {best_score}/100") + + print("\nThe solution is...") + print(summarize_best_path(reasoning_prompt, best_path)) \ No newline at end of file diff --git a/tutorials/tree-of-thought-prompting/DFS_tree_of_thought.py b/tutorials/tree-of-thought-prompting/DFS_tree_of_thought.py new file mode 100644 index 0000000..aeaea16 --- /dev/null +++ b/tutorials/tree-of-thought-prompting/DFS_tree_of_thought.py @@ -0,0 +1,182 @@ +# @ Author: Bertan Berker +# @ Language: Python 3.11.9 +# This script is an example of a tree of thought implementation for solving a reasoning task +# using Depth-First Search (DFS) instead of Breadth-First Search (BFS). + +import os +from dotenv import load_dotenv +from groq import Groq +load_dotenv() + +client = Groq( + api_key=os.environ.get("GROQ_API_KEY"), +) + +# ThoughtNode class is used to represent a node in the tree of thought +# It contains the thought, the parent node, and the children nodes +# The thought is the content of the node +# The parent node is the node that comes before this node +# The children nodes are the nodes that come after this node +class ThoughtNode: + def __init__(self, thought, parent=None): + self.thought = thought + self.parent = parent + self.children = [] + + def add_child(self, child_node): + self.children.append(child_node) + + +# call_llm function is used to call the LLM +# :param prompt: The prompt to send to the LLM +# :return: The response from the LLM +def call_llm(prompt): + chat_completion = client.chat.completions.create( + messages=[ + { + "role": "user", + "content": "You are a world class reasoning expert. You are given a reasoning problem to solve. This is your problem:" + prompt, + } + ], + model="llama-3.3-70b-versatile", + ) + return chat_completion.choices[0].message.content + + +# generate_thought function is used to generate thoughts for the next step +# :param prompt: The prompt to send to the LLM +# :param step_number: The number of thoughts to generate +# :return: The thoughts from the LLM +def generate_thought(prompt, step_number): + thought_prompt = f""" + Given the reasoning problem: "{prompt}", generate {step_number} different 'Thought' options to proceed with the solution step by step. + Each thought should be short, logical, and explore a different path. + + Format: + Thought {step_number}.1: ... + Thought {step_number}.2: ... + Thought {step_number}.3: ... + """ + thoughts_text = call_llm(thought_prompt) + return thoughts_text + + +# dfs_expand function is used to expand the tree of thought +# :param node: The current node +# :param current_depth: The current depth of the tree +# :param max_depth: The maximum depth of the tree +# :param thoughts_per_step: The number of thoughts to generate for each step +# :return: None +def dfs_expand(node, current_depth, max_depth, thoughts_per_step): + if current_depth >= max_depth: + return + + print(f"\nExpanding (depth {current_depth}):\nā†’ {node.thought}") + thoughts_text = generate_thought(node.thought, step_number=thoughts_per_step) + print(f"\nGenerated Thoughts:\n{thoughts_text}") + + for line in thoughts_text.splitlines(): + if line.strip().startswith(f"Thought {thoughts_per_step}."): + thought_content = line.split(":", 1)[-1].strip() + child_node = ThoughtNode(thought=thought_content, parent=node) + node.add_child(child_node) + # DFS: go deep immediately + dfs_expand(child_node, current_depth + 1, max_depth, thoughts_per_step) + + +# dfs_reasoning_solver_full_tree function is used to solve the reasoning problem +# :param user_prompt: The prompt to send to the LLM +# :param max_depth: The maximum depth of the tree +# :param thoughts_per_step: The number of thoughts to generate for each step +# :return: The root node of the tree +def dfs_reasoning_solver_full_tree(user_prompt, max_depth=5, thoughts_per_step=3): + root = ThoughtNode(thought=user_prompt) + dfs_expand(root, current_depth=0, max_depth=max_depth, thoughts_per_step=thoughts_per_step) + return root + + +# get_all_paths_from_root function is used to get all paths from the root to the leaves +# :param node: The root node of the tree +# :return: All paths from the root to the leaves +def get_all_paths_from_root(node): + if not node.children: + return [[node.thought]] + paths = [] + for child in node.children: + for subpath in get_all_paths_from_root(child): + paths.append([node.thought] + subpath) + return paths + + +# score_reasoning_path function is used to score a reasoning path +# :param path: The path to score +# :param original_prompt: The original prompt to send to the LLM +# :return: The score of the path +def score_reasoning_path(path, original_prompt): + joined_reasoning = "\n".join([f"Step {i+1}: {step}" for i, step in enumerate(path)]) + prompt = f""" + You're evaluating a reasoning path for the problem: "{original_prompt}" + + Here is one possible reasoning path: + {joined_reasoning} + + Please rate the overall quality and effectiveness of this reasoning path on a scale from 1 to 100. + Just respond with a number between 1 and 100. + """ + score_str = call_llm(prompt).strip() + try: + return int(score_str) + except ValueError: + return 0 + + +# summarize_best_path function is used to summarize the best path +# :param prompt: The original prompt to send to the LLM +# :param path: The best path to summarize +# :return: The summarized path +def summarize_best_path(prompt, path): + chat_completion = client.chat.completions.create( + messages=[ + { + "role": "user", + "content": f"Given the prompt: {prompt}, summarize the best reasoning path as precisely and simply as possible \ + and give the final answer. The reasoning path is: {path}.", + } + ], + model="llama-3.3-70b-versatile", + ) + return chat_completion.choices[0].message.content + + +if __name__ == "__main__": + reasoning_prompt = input("Enter a reasoning problem: ") + root = dfs_reasoning_solver_full_tree(reasoning_prompt, max_depth=3, thoughts_per_step=3) + + all_paths = get_all_paths_from_root(root) + print(f"\nFound {len(all_paths)} reasoning paths.\n") + + for i, path in enumerate(all_paths, start=1): + print(f"Path {i}:") + for j, step in enumerate(path, start=1): + print(f" Step {j}: {step}") + print("---------------") + + best_score = -1 + best_path = None + + print("\nScoring all reasoning paths...\n") + + for i, path in enumerate(all_paths, start=1): + score = score_reasoning_path(path, reasoning_prompt) + print(f"Path {i}: Scored {score}/100") + if score > best_score: + best_score = score + best_path = path + + print("\nBest Reasoning Path:") + for i, step in enumerate(best_path, 1): + print(f"Step {i}: {step}") + print(f"\nFinal Score: {best_score}/100") + + print("\nThe solution is...") + print(summarize_best_path(reasoning_prompt, best_path)) \ No newline at end of file diff --git a/tutorials/tree-of-thought-prompting/README.md b/tutorials/tree-of-thought-prompting/README.md new file mode 100644 index 0000000..fb92665 --- /dev/null +++ b/tutorials/tree-of-thought-prompting/README.md @@ -0,0 +1,88 @@ +# Tree of Thought Reasoning with Groq API + +A dynamic Tree-of-Thought (ToT) implementation using the [Groq API](https://console.groq.com/docs). This project demonstrates how large language models like LLaMA 3 can reason more effectively by exploring multiple paths of thought, evaluating them, and selecting the best one. + +> Built as an open-source contribution to the [Groq API Cookbook](https://github.com/groq/groq-api-cookbook) + +--- + +## What It Does + +- Accepts **any reasoning problem** from the user +- Builds a **Tree of Thought** using: + - **Breadth-First Search (BFS)** or + - **Depth-First Search (DFS)** +- Uses **Groq + LLaMA 3** to: + - Generate multiple thoughts per step + - Evaluate and score each reasoning path +- Picks the most effective solution path +- **Visualizes** the reasoning tree + - Highlights the best path + +--- + +## šŸ›  How to Use + +### Install Dependencies + +```bash +pip install -r requirements.txt +``` +### Set Up Your `.env` File + +Create a `.env` file in the root directory with your Groq API key: + +```env +GROQ_API_KEY=your-groq-api-key-here +``` + +### Run the Script + +```bash +python BFS_tree_of_thought.py +python DFS_tree_of_thought.py +``` + +You'll be prompted to: +- Enter your reasoning problem +- Choose BFS or DFS +- View the best path and full tree visualization + +--- + +## Jupyter Notebook Support & Possible API implementation + +This project is also notebook-friendly! You can use the "Tree_of_Thought_Reasoning.ipynb" script for interactive experimentation. + +Or you can build a frontend and connect it with a simple Flask API (API.py) that utilizes the tree of thought reasoning for answer generation. This Flask API powers the reasoning engine for the app using a Tree of Thought approach. It receives user prompts at /api/chat, builds a reasoning tree via depth-first search (DFS), scores all possible reasoning paths, and returns the best summarized output. It also includes full CORS support for local frontend communication. + +--- + +## Features + +- āœ… Dynamic reasoning tree generation +- šŸ”„ BFS and DFS traversal modes +- šŸ§  Thought generation + scoring with LLM +- šŸŒ± Branch pruning with top-N child limit +- šŸ“Š Visualization using Graphviz + +--- + +## About Tree of Thought + +> Tree of Thought (ToT) is a prompting strategy that guides LLMs to reason more effectively by exploring multiple intermediate thoughts (like a tree), evaluating them, and selecting the best path. This method improves logical reasoning, math, problem-solving, and planning tasks. + +Learn more in the [Tree of Thought paper](https://arxiv.org/abs/2305.10601). + +--- + +## Contributing + +Pull requests and forks are welcome! Open an issue for bugs, questions, or feature ideas. + +--- + +## Contact: +Author: Bertan Berker + +LinkedIn: https://www.linkedin.com/in/bertan-berker/ \ No newline at end of file diff --git a/tutorials/tree-of-thought-prompting/Tree_Of_Thought_Reasoning.ipynb b/tutorials/tree-of-thought-prompting/Tree_Of_Thought_Reasoning.ipynb new file mode 100644 index 0000000..dfefbc2 --- /dev/null +++ b/tutorials/tree-of-thought-prompting/Tree_Of_Thought_Reasoning.ipynb @@ -0,0 +1,924 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "ftPM6rXtS1up" + }, + "source": [ + "# TREE OF THOUGHT REASONING\n", + "\n", + "This notebook is an example of how to use tree of thought to solve reasoning based problems better." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LBo_x6T3BZof" + }, + "outputs": [], + "source": [ + "# Downloading the required libraries\n", + "\n", + "#!pip install python-dotenv\n", + "#!pip install Groq\n", + "#!pip install networkx matplotlib\n", + "\n", + "# Importing the required libraries\n", + "\n", + "import os\n", + "from dotenv import load_dotenv\n", + "from groq import Groq\n", + "from collections import deque\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "from networkx.drawing.nx_agraph import graphviz_layout\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "from networkx.drawing.nx_agraph import graphviz_layout" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "BTaGfZpHCWmk" + }, + "outputs": [], + "source": [ + "# Load the GROQ API KEY\n", + "\n", + "load_dotenv()\n", + "\n", + "client = Groq(\n", + " api_key=os.environ.get(\"GROQ_API_KEY\"),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BUhGcKCgScVa" + }, + "source": [ + "# **FUNCTIONS FOR THOUGHT GENERATION AND EVALUATION**" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "HnOdY7UoCXa8" + }, + "outputs": [], + "source": [ + "# call_llm function is used to call the LLM\n", + "# :param prompt: The prompt to send to the LLM\n", + "# :return: The response from the LLM\n", + "def call_llm(prompt):\n", + "\n", + " chat_completion = client.chat.completions.create(\n", + " messages=[\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": \"You are a world class reasoning expert. You are given a reasoning problem to solve. This is your problem:\" + prompt,\n", + " }\n", + " ],\n", + " model=\"llama-3.3-70b-versatile\",\n", + " )\n", + "\n", + " return chat_completion.choices[0].message.content\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "id": "sXE5TDlFCXkV" + }, + "outputs": [], + "source": [ + "# generate_thought function is used to generate thoughts for the next step\n", + "# :param prompt: The prompt to send to the LLM\n", + "# :param step_number: The number of thoughts to generate\n", + "# :return: The thoughts from the LLM\n", + "def generate_thought(prompt, step_number):\n", + "\n", + " thought_prompt = f\"\"\"\n", + " Given the reasoning problem: \"{prompt}\", generate {step_number} different 'Thought' options to proceed with the solution step by step.\n", + " Each thought should be short, logical, and explore a different path.\n", + "\n", + " Format:\n", + " Thought {step_number}.1: ...\n", + " Thought {step_number}.2: ...\n", + " Thought {step_number}.3: ...\n", + " \"\"\"\n", + "\n", + " thoughts_text = call_llm(thought_prompt)\n", + " return thoughts_text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "IxQ4J8aZCXyf" + }, + "outputs": [], + "source": [ + "# get_all_paths_from_root function is used to get all paths from the root to the leaves\n", + "# :param node: The root node of the tree\n", + "# :return: All paths from the root to the leaves\n", + "def get_all_paths_from_root(node):\n", + "\n", + " if not node.children:\n", + " return [[node.thought]]\n", + "\n", + " paths = []\n", + " for child in node.children:\n", + " for subpath in get_all_paths_from_root(child):\n", + " paths.append([node.thought] + subpath)\n", + " return paths" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "zcBS8sGZCX6K" + }, + "outputs": [], + "source": [ + "# score_reasoning_path function is used to score a reasoning path\n", + "# :param path: The path to score\n", + "# :param original_prompt: The original prompt to send to the LLM\n", + "# :return: The score of the path\n", + "def score_reasoning_path(path, original_prompt):\n", + "\n", + " joined_reasoning = \"\\n\".join([f\"Step {i+1}: {step}\" for i, step in enumerate(path)])\n", + "\n", + " prompt = f\"\"\"\n", + " You're evaluating a reasoning path for the problem: \"{original_prompt}\"\n", + "\n", + " Here is one possible reasoning path:\n", + " {joined_reasoning}\n", + "\n", + " Please rate the overall quality and effectiveness of this reasoning path on a scale from 1 to 100.\n", + " Just respond with a number between 1 and 100.\n", + " \"\"\"\n", + "\n", + " score_str = call_llm(prompt).strip()\n", + " try:\n", + " return int(score_str)\n", + " except ValueError:\n", + " return 0 # fallback if model responds weirdly" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "id": "ydot_8R8CugF" + }, + "outputs": [], + "source": [ + "# summarize_best_path function is used to summarize the best path\n", + "# :param prompt: The original prompt to send to the LLM\n", + "# :param path: The best path to summarize\n", + "# :return: The summarized path\n", + "def summarize_best_path(prompt, path):\n", + "\n", + " chat_completion = client.chat.completions.create(\n", + " messages=[\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": f\"Given the prompt: {prompt}, summarize the best reasoning path as precisely and simply as possible \\\n", + " and give the final answer. The reasoning path is: {path}.\",\n", + " }\n", + " ],\n", + " model=\"llama-3.3-70b-versatile\",\n", + " )\n", + "\n", + " return chat_completion.choices[0].message.content\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "id": "7p4wLXazCWzS" + }, + "outputs": [], + "source": [ + "# ThoughtNode class is used to represent a node in the tree of thought\n", + "# It contains the thought, the parent node, and the children nodes\n", + "# The thought is the content of the node\n", + "# The parent node is the node that comes before this node\n", + "# The children nodes are the nodes that come after this node\n", + "class ThoughtNode:\n", + " def __init__(self, thought, parent=None, score=None):\n", + " self.thought = thought\n", + " self.parent = parent\n", + " self.children = []\n", + "\n", + " def add_child(self, child_node):\n", + " self.children.append(child_node)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IE5MfjmmSkOH" + }, + "source": [ + "# **FUNCTIONS FOR THE BREADTH-FIRST-SEARCH (BFS) IMPLEMENTATION OF THE TREE OF THOUGHT REASONING**" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "zYzumWvgCXqw" + }, + "outputs": [], + "source": [ + "# bfs_reasoning_solver_full_tree function is used to solve the reasoning problem\n", + "# :param user_prompt: The prompt to send to the LLM\n", + "# :param max_depth: The maximum depth of the tree\n", + "# :param thoughts_per_step: The number of thoughts to generate for each step\n", + "# :return: The root node of the tree\n", + "def bfs_reasoning_solver_full_tree(user_prompt, max_depth=5, thoughts_per_step=3):\n", + "\n", + " root = ThoughtNode(thought=user_prompt)\n", + " queue = deque([root]) # BFS queue\n", + "\n", + " for depth in range(max_depth):\n", + " print(f\"\\nStep {depth + 1} ā€” Expanding {len(queue)} node(s)...\")\n", + " current_level_nodes = list(queue)\n", + " queue.clear()\n", + "\n", + " for node in current_level_nodes:\n", + " print(f\"\\nExpanding:\\nā†’ {node.thought}\")\n", + "\n", + " thoughts_text = generate_thought(node.thought, step_number=thoughts_per_step)\n", + " print(f\"\\nGenerated Thoughts:\\n{thoughts_text}\")\n", + "\n", + " for line in thoughts_text.splitlines():\n", + " if line.strip().startswith(f\"Thought {thoughts_per_step}.\"):\n", + " thought_content = line.split(\":\", 1)[-1].strip()\n", + " child_node = ThoughtNode(thought=thought_content, parent=node)\n", + " node.add_child(child_node)\n", + " queue.append(child_node)\n", + "\n", + " return root\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "enZLMNxTSqkH" + }, + "source": [ + "# **FUNCTIONS FOR THE DEPTH-FIRST-SEARCH (DFS) IMPLEMENTATION OF THE TREE OF THOUGHT REASONING**" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "78kBmg6hC8Gi" + }, + "outputs": [], + "source": [ + "# dfs_expand function is used to expand the tree of thought\n", + "# :param node: The current node\n", + "# :param current_depth: The current depth of the tree\n", + "# :param max_depth: The maximum depth of the tree\n", + "# :param thoughts_per_step: The number of thoughts to generate for each step\n", + "# :return: None\n", + "def dfs_expand(node, current_depth, max_depth, thoughts_per_step):\n", + " if current_depth >= max_depth:\n", + " return\n", + "\n", + " print(f\"\\nExpanding (depth {current_depth}):\\nā†’ {node.thought}\")\n", + " thoughts_text = generate_thought(node.thought, step_number=thoughts_per_step)\n", + " print(f\"\\nGenerated Thoughts:\\n{thoughts_text}\")\n", + "\n", + " for line in thoughts_text.splitlines():\n", + " if line.strip().startswith(f\"Thought {thoughts_per_step}.\"):\n", + " thought_content = line.split(\":\", 1)[-1].strip()\n", + " child_node = ThoughtNode(thought=thought_content, parent=node)\n", + " node.add_child(child_node)\n", + " dfs_expand(child_node, current_depth + 1, max_depth, thoughts_per_step)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "id": "YMA3HLMxC9DU" + }, + "outputs": [], + "source": [ + "# dfs_reasoning_solver_full_tree function is used to solve the reasoning problem\n", + "# :param user_prompt: The prompt to send to the LLM\n", + "# :param max_depth: The maximum depth of the tree\n", + "# :param thoughts_per_step: The number of thoughts to generate for each step\n", + "# :return: The root node of the tree\n", + "def dfs_reasoning_solver_full_tree(user_prompt, max_depth=5, thoughts_per_step=3):\n", + " root = ThoughtNode(thought=user_prompt)\n", + " dfs_expand(root, current_depth=0, max_depth=max_depth, thoughts_per_step=thoughts_per_step)\n", + " return root" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RIz8RSwnSv3V" + }, + "source": [ + "# **TESTING OUT THE TREE OF THOUGHT!!**" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "id": "81nx0j8WFC5H" + }, + "outputs": [], + "source": [ + "# tree_of_thought function solves the user's reasoning problem based on\n", + "# tree_of_thought approach and prints the solution\n", + "# :Param None:\n", + "# :return: None\n", + "\n", + "def tree_of_thought():\n", + " global root, best_path\n", + "\n", + " if mode == \"bfs\":\n", + " root = bfs_reasoning_solver_full_tree(reasoning_prompt, max_depth=3, thoughts_per_step=3)\n", + "\n", + " else:\n", + " root = dfs_reasoning_solver_full_tree(reasoning_prompt, max_depth=3, thoughts_per_step=3)\n", + "\n", + " all_paths = get_all_paths_from_root(root)\n", + " print(f\"\\nFound {len(all_paths)} reasoning paths.\\n\")\n", + "\n", + " for i, path in enumerate(all_paths, start=1):\n", + " print(f\"Path {i}:\")\n", + " for j, step in enumerate(path, start=1):\n", + " print(f\" Step {j}: {step}\")\n", + " print(\"---------------\")\n", + "\n", + " best_score = -1\n", + "\n", + " print(\"\\nScoring all reasoning paths...\\n\")\n", + "\n", + " for i, path in enumerate(all_paths, start=1):\n", + " score = score_reasoning_path(path, reasoning_prompt)\n", + " print(f\"Path {i}: Scored {score}/100\")\n", + "\n", + " if score > best_score:\n", + " best_score = score\n", + " best_path = path\n", + "\n", + " # Show the best path\n", + " print(\"\\nBest Reasoning Path:\")\n", + " for i, step in enumerate(best_path, 1):\n", + " print(f\"Step {i}: {step}\")\n", + " print(f\"\\nFinal Score: {best_score}/100\")\n", + "\n", + " print(\"\\nThe solution is...\")\n", + " print(summarize_best_path(reasoning_prompt, best_path))" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MgT3WFngDARe", + "outputId": "d2efc7bb-4ef7-41c7-87e7-245b467cb16f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Step 1 ā€” Expanding 1 node(s)...\n", + "\n", + "Expanding:\n", + "ā†’ A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + "\n", + "Generated Thoughts:\n", + "Thought 3.1: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + "\n", + "Thought 3.2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + "\n", + "Thought 3.3: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + "\n", + "Step 2 ā€” Expanding 3 node(s)...\n", + "\n", + "Expanding:\n", + "ā†’ Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + "\n", + "Generated Thoughts:\n", + "To approach this problem, let's break down the daily progress of the snail and calculate the number of days it takes to climb to the top. Here are three different thought options to proceed with the solution:\n", + "\n", + "Thought 3.1: Calculate the net progress per day by subtracting the amount the snail slides back at night from the amount it climbs during the day, which is 3 meters - 2 meters = 1 meter. This means the snail effectively moves 1 meter up each day.\n", + "\n", + "Thought 3.2: Consider the total distance the snail needs to climb to reach the top, which is 10 meters, but since it won't slide back on the last day, we can think of it as needing to climb 8 meters effectively before the last climb. This could help in calculating the number of days required to reach near the top.\n", + "\n", + "Thought 3.3: Think about the pattern of movement day by day. On the first day, the snail climbs 3 meters and slides back 2, so it's at 1 meter. Each subsequent day, it climbs 3 meters from where it was at the end of the night before, effectively making progress up the wall. This pattern could help in understanding how many days it takes for the snail to reach a point where its final climb of 2 meters (or more) takes it to the top without sliding back.\n", + "\n", + "Expanding:\n", + "ā†’ Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + "\n", + "Generated Thoughts:\n", + "To approach this problem, we can consider the following steps:\n", + "\n", + "Thought 3.1: Simplify the equation given to understand the relationship between the days the snail takes to climb out and the height of the well. The equation 3 * days - 2 * (days - 1) >= 10 can be simplified to make it easier to solve for the number of days.\n", + "\n", + "Thought 3.2: Consider the physical constraints of the problem. Since the snail climbs 3 meters up and slides 2 meters back each day except the last, we should think about how many days it would take for the snail to be at or above the 10-meter mark without sliding back, which would require calculating the net progress over a series of days.\n", + "\n", + "Thought 3.3: Solve the inequality step by step. First, distribute the -2 across the parentheses: 3 * days - 2 * days + 2 >= 10. This simplifies to days + 2 >= 10. From here, we can isolate \"days\" to find the minimum number of days required for the snail to reach or exceed the top of the well.\n", + "\n", + "Expanding:\n", + "ā†’ Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + "\n", + "Generated Thoughts:\n", + "To approach this problem, let's consider the following steps and thoughts:\n", + "\n", + "Thought 3.1: We can model the snail's movement as an arithmetic sequence where each day the snail climbs one more meter than the previous day and slides back one more meter than the previous night, effectively making the daily net progress increase by 1 meter each day. This means the snail's net progress follows the sequence 1, 2, 3, etc., meters per day.\n", + "\n", + "Thought 3.2: To determine when the snail reaches or surpasses 10 meters, we can calculate the cumulative sum of the daily net progress. Since the snail climbs in an arithmetic sequence (1, 2, 3, ...), we can use the formula for the sum of the first n natural numbers, which is n(n + 1)/2, to find out after which day the cumulative sum equals or exceeds 10 meters.\n", + "\n", + "Thought 3.3: Alternatively, we can simulate the snail's movement day by day, keeping track of its net progress each day until it reaches or exceeds 10 meters. This approach involves iterative addition, where each day's net gain is added to the total, and checking if the total has reached or surpassed the target height of 10 meters, at which point we can stop and identify the day the snail reached the top.\n", + "\n", + "Step 3 ā€” Expanding 9 node(s)...\n", + "\n", + "Expanding:\n", + "ā†’ Calculate the net progress per day by subtracting the amount the snail slides back at night from the amount it climbs during the day, which is 3 meters - 2 meters = 1 meter. This means the snail effectively moves 1 meter up each day.\n", + "\n", + "Generated Thoughts:\n", + "To tackle this problem, let's consider the following steps and thoughts to break it down:\n", + "\n", + "Thought 3.1: Understand the Snail's Daily Movement Pattern - First, we need to grasp that the snail's net movement is the difference between what it achieves during the day and what it loses at night, which is 3 meters up during the day and 2 meters back at night, resulting in a net gain of 1 meter per day.\n", + "\n", + "Thought 3.2: Consider the Role of the Snail's Slide Back - It's crucial to consider why the snail slides back 2 meters each night. Is this consistent, or are there factors that could change this, such as moisture, temperature, or the surface it climbs? Understanding these factors could provide insights into how to maximize the snail's progress.\n", + "\n", + "Thought 3.3: Analyze the Impact of Daytime Climbing Efficiency - Since the snail climbs 3 meters during the day but only retains 1 meter of progress due to the nighttime slide, we should think about how to improve the snail's daytime efficiency. Is there a way to enhance its climbing ability, or to reduce the energy spent during the day to ensure more progress is retained overnight?\n", + "\n", + "Expanding:\n", + "ā†’ Consider the total distance the snail needs to climb to reach the top, which is 10 meters, but since it won't slide back on the last day, we can think of it as needing to climb 8 meters effectively before the last climb. This could help in calculating the number of days required to reach near the top.\n", + "\n", + "Generated Thoughts:\n", + "Thought 3.1: To calculate the number of days required, we should first determine the daily progress of the snail, considering both its climb and slide back, to establish a pattern or formula that can be applied to the 8 meters it needs to climb effectively.\n", + "\n", + "Thought 3.2: Since the snail doesn't slide back on the last day, we should focus on finding out how many days it takes for the snail to be at a point where it can reach the top (10 meters) in one final climb, which implies being at the 8-meter mark at the end of the day before the last.\n", + "\n", + "Thought 3.3: Breaking down the snail's movement into a daily net gain could provide a straightforward way to calculate the number of days required to climb 8 meters effectively, by dividing the total effective distance by the daily net gain of the snail.\n", + "\n", + "Expanding:\n", + "ā†’ Think about the pattern of movement day by day. On the first day, the snail climbs 3 meters and slides back 2, so it's at 1 meter. Each subsequent day, it climbs 3 meters from where it was at the end of the night before, effectively making progress up the wall. This pattern could help in understanding how many days it takes for the snail to reach a point where its final climb of 2 meters (or more) takes it to the top without sliding back.\n", + "\n", + "Generated Thoughts:\n", + "To tackle this problem, let's break it down into manageable parts and explore different thought processes:\n", + "\n", + "Thought 3.1: Determine the net progress the snail makes each day. Since the snail climbs 3 meters and slides back 2 meters, its net gain is 1 meter per day. This thought process can help in calculating the total number of days required for the snail to reach a certain height, assuming the height of the wall is known.\n", + "\n", + "Thought 3.2: Consider the critical point where the snail's climb takes it to or beyond the top of the wall without sliding back. If the snail needs to climb 2 meters or more on its final ascent to reach the top without sliding, we need to figure out the height at which this becomes possible. This might involve finding a pattern or using algebra to express the snail's position over time.\n", + "\n", + "Thought 3.3: Model the snail's movement mathematically. Let's denote the height of the wall as H and the number of days the snail takes to reach near the top as n. On the nth day, the snail should climb 3 meters to either reach or exceed the height H. Considering the pattern, on each day before the last, the snail effectively moves 1 meter up. So, on the day before the final climb, the snail should be at H - 3 meters (since it climbs 3 meters on the last day). This thought involves setting up an equation to solve for n, the number of days, given the height H of the wall.\n", + "\n", + "Expanding:\n", + "ā†’ Simplify the equation given to understand the relationship between the days the snail takes to climb out and the height of the well. The equation 3 * days - 2 * (days - 1) >= 10 can be simplified to make it easier to solve for the number of days.\n", + "\n", + "Generated Thoughts:\n", + "Thought 3.1: Start by simplifying the equation using algebraic manipulation. Distribute and combine like terms: 3 * days - 2 * days + 2 >= 10, which simplifies to days + 2 >= 10.\n", + "\n", + "Thought 3.2: Consider the physical context of the problem, where the snail is climbing out of a well. The equation might represent the relationship between the snail's progress and the well's height. By rearranging the equation, we can isolate the variable representing the height or the days, potentially revealing a clearer relationship.\n", + "\n", + "Thought 3.3: Apply the distributive property first to expand the equation: 3 * days - 2 * days + 2 >= 10. Then, consider factoring or further simplifying to find a more manageable form, which could help identify key factors or constraints that influence the number of days the snail takes to climb out of the well.\n", + "\n", + "Expanding:\n", + "ā†’ Consider the physical constraints of the problem. Since the snail climbs 3 meters up and slides 2 meters back each day except the last, we should think about how many days it would take for the snail to be at or above the 10-meter mark without sliding back, which would require calculating the net progress over a series of days.\n", + "\n", + "Generated Thoughts:\n", + "Thought 3.1: To find out how many days it takes for the snail to reach or exceed the 10-meter mark, we should calculate the net progress per day, which is 3 meters up and 2 meters back, resulting in a net gain of 1 meter per day, except for the last day when it won't slide back.\n", + "\n", + "Thought 3.2: We need to consider the minimum height the snail must climb on its final day to reach or exceed 10 meters without sliding back. This means the snail must be at or below the 10-meter mark at the start of the day and reach or exceed it by the end of the day, without sliding back.\n", + "\n", + "Thought 3.3: Breaking down the problem into segments, we can analyze the pattern of the snail's climb. For instance, after the first day, the snail is at 1 meter (3 meters up, 2 meters back), and this pattern continues. We can use this pattern to determine on which day the snail will reach a height from which it can climb to or beyond 10 meters on its final push without sliding back.\n", + "\n", + "Expanding:\n", + "ā†’ Solve the inequality step by step. First, distribute the -2 across the parentheses: 3 * days - 2 * days + 2 >= 10. This simplifies to days + 2 >= 10. From here, we can isolate \"days\" to find the minimum number of days required for the snail to reach or exceed the top of the well.\n", + "\n", + "Generated Thoughts:\n", + "Thought 3.1: To isolate \"days\", we should subtract 2 from both sides of the inequality days + 2 >= 10, which would result in days >= 8. This step is crucial in simplifying the inequality further to find the minimum number of days.\n", + "\n", + "Thought 3.2: Before isolating \"days\", let's re-examine the initial step of distributing -2 across the parentheses and ensure it was done correctly. The correct distribution should yield 3*days - 2*days + 2 >= 10, simplifying to days + 2 >= 10. Confirming this step will ensure the accuracy of the subsequent steps.\n", + "\n", + "Thought 3.3: Instead of immediately isolating \"days\", consider the inequality days + 2 >= 10 and think about what it means in the context of the problem. The snail needs to reach or exceed the top of the well, so we're looking for the minimum number of days where this condition is met. We can then proceed to solve for \"days\" by subtracting 2 from both sides of the inequality.\n", + "\n", + "Expanding:\n", + "ā†’ We can model the snail's movement as an arithmetic sequence where each day the snail climbs one more meter than the previous day and slides back one more meter than the previous night, effectively making the daily net progress increase by 1 meter each day. This means the snail's net progress follows the sequence 1, 2, 3, etc., meters per day.\n", + "\n", + "Generated Thoughts:\n", + "To tackle this problem, we can consider the following thought processes to understand and solve the snail's movement pattern:\n", + "\n", + "Thought 3.1: Let's express the snail's daily net progress mathematically. If the snail climbs \\(x\\) meters one day and slides back \\(y\\) meters that night, and the next day it climbs \\(x+1\\) meters and slides back \\(y+1\\) meters, the net progress each day increases by 1 meter because the difference between \\(x+1\\) and \\(y+1\\) is one more than the difference between \\(x\\) and \\(y\\).\n", + "\n", + "Thought 3.2: We should analyze the sequence of the snail's net progress over several days to identify any patterns or formulas that can help in calculating the total distance covered over a period. This sequence, being arithmetic with a common difference of 1, suggests that the total progress after \\(n\\) days might be related to the sum of the first \\(n\\) natural numbers.\n", + "\n", + "Thought 3.3: Considering the snail's movement as an arithmetic sequence, we should also think about the initial conditions and how they affect the overall movement. For instance, if the snail starts with a certain initial climb or slide, how does this influence its subsequent daily net progress? Understanding the impact of initial conditions could provide insights into how to model the snail's movement more accurately over varying periods.\n", + "\n", + "Expanding:\n", + "ā†’ To determine when the snail reaches or surpasses 10 meters, we can calculate the cumulative sum of the daily net progress. Since the snail climbs in an arithmetic sequence (1, 2, 3, ...), we can use the formula for the sum of the first n natural numbers, which is n(n + 1)/2, to find out after which day the cumulative sum equals or exceeds 10 meters.\n", + "\n", + "Generated Thoughts:\n", + "Thought 3.1: We can start by directly applying the formula for the sum of the first n natural numbers, n(n + 1)/2, and set it greater than or equal to 10 to find the day when the snail reaches or surpasses 10 meters, solving the inequality n(n + 1)/2 ā‰„ 10 for n.\n", + "\n", + "Thought 3.2: To ensure we understand the snail's progress, let's manually calculate the cumulative sum for the first few days (1, 3, 6, 10, ...) to see the pattern and when it reaches or exceeds 10 meters, providing a concrete basis for our calculations.\n", + "\n", + "Thought 3.3: Considering the nature of arithmetic sequences and cumulative sums, we can also approach this problem by iteratively adding the daily progress (1, then 2, then 3, and so on) in a loop until the sum meets or exceeds 10 meters, potentially leading to a straightforward computational solution.\n", + "\n", + "Expanding:\n", + "ā†’ Alternatively, we can simulate the snail's movement day by day, keeping track of its net progress each day until it reaches or exceeds 10 meters. This approach involves iterative addition, where each day's net gain is added to the total, and checking if the total has reached or surpassed the target height of 10 meters, at which point we can stop and identify the day the snail reached the top.\n", + "\n", + "Generated Thoughts:\n", + "To tackle the problem of simulating the snail's movement day by day and determining the day it reaches or exceeds 10 meters, we can explore the following thoughts:\n", + "\n", + "Thought 3.1: Initialize a variable to track the total distance covered by the snail and another to count the days, starting both at 0. This will provide a clear, iterative approach to calculating the snail's progress.\n", + "\n", + "Thought 3.2: Consider the daily net gain of the snail. If we know how much the snail moves up each day and how much it might slide back at night, we can calculate the net progress per day and add this to our running total until we hit or exceed the 10-meter mark.\n", + "\n", + "Thought 3.3: Develop a loop or recursive function that simulates each day of the snail's climb. Within this loop, add the daily net gain to the total distance and increment the day counter. The loop should continue until the total distance is greater than or equal to 10 meters, at which point the function can return the number of days it took for the snail to reach this height.\n", + "\n", + "Found 27 reasoning paths.\n", + "\n", + "Path 1:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Calculate the net progress per day by subtracting the amount the snail slides back at night from the amount it climbs during the day, which is 3 meters - 2 meters = 1 meter. This means the snail effectively moves 1 meter up each day.\n", + " Step 4: Understand the Snail's Daily Movement Pattern - First, we need to grasp that the snail's net movement is the difference between what it achieves during the day and what it loses at night, which is 3 meters up during the day and 2 meters back at night, resulting in a net gain of 1 meter per day.\n", + "---------------\n", + "Path 2:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Calculate the net progress per day by subtracting the amount the snail slides back at night from the amount it climbs during the day, which is 3 meters - 2 meters = 1 meter. This means the snail effectively moves 1 meter up each day.\n", + " Step 4: Consider the Role of the Snail's Slide Back - It's crucial to consider why the snail slides back 2 meters each night. Is this consistent, or are there factors that could change this, such as moisture, temperature, or the surface it climbs? Understanding these factors could provide insights into how to maximize the snail's progress.\n", + "---------------\n", + "Path 3:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Calculate the net progress per day by subtracting the amount the snail slides back at night from the amount it climbs during the day, which is 3 meters - 2 meters = 1 meter. This means the snail effectively moves 1 meter up each day.\n", + " Step 4: Analyze the Impact of Daytime Climbing Efficiency - Since the snail climbs 3 meters during the day but only retains 1 meter of progress due to the nighttime slide, we should think about how to improve the snail's daytime efficiency. Is there a way to enhance its climbing ability, or to reduce the energy spent during the day to ensure more progress is retained overnight?\n", + "---------------\n", + "Path 4:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Consider the total distance the snail needs to climb to reach the top, which is 10 meters, but since it won't slide back on the last day, we can think of it as needing to climb 8 meters effectively before the last climb. This could help in calculating the number of days required to reach near the top.\n", + " Step 4: To calculate the number of days required, we should first determine the daily progress of the snail, considering both its climb and slide back, to establish a pattern or formula that can be applied to the 8 meters it needs to climb effectively.\n", + "---------------\n", + "Path 5:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Consider the total distance the snail needs to climb to reach the top, which is 10 meters, but since it won't slide back on the last day, we can think of it as needing to climb 8 meters effectively before the last climb. This could help in calculating the number of days required to reach near the top.\n", + " Step 4: Since the snail doesn't slide back on the last day, we should focus on finding out how many days it takes for the snail to be at a point where it can reach the top (10 meters) in one final climb, which implies being at the 8-meter mark at the end of the day before the last.\n", + "---------------\n", + "Path 6:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Consider the total distance the snail needs to climb to reach the top, which is 10 meters, but since it won't slide back on the last day, we can think of it as needing to climb 8 meters effectively before the last climb. This could help in calculating the number of days required to reach near the top.\n", + " Step 4: Breaking down the snail's movement into a daily net gain could provide a straightforward way to calculate the number of days required to climb 8 meters effectively, by dividing the total effective distance by the daily net gain of the snail.\n", + "---------------\n", + "Path 7:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Think about the pattern of movement day by day. On the first day, the snail climbs 3 meters and slides back 2, so it's at 1 meter. Each subsequent day, it climbs 3 meters from where it was at the end of the night before, effectively making progress up the wall. This pattern could help in understanding how many days it takes for the snail to reach a point where its final climb of 2 meters (or more) takes it to the top without sliding back.\n", + " Step 4: Determine the net progress the snail makes each day. Since the snail climbs 3 meters and slides back 2 meters, its net gain is 1 meter per day. This thought process can help in calculating the total number of days required for the snail to reach a certain height, assuming the height of the wall is known.\n", + "---------------\n", + "Path 8:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Think about the pattern of movement day by day. On the first day, the snail climbs 3 meters and slides back 2, so it's at 1 meter. Each subsequent day, it climbs 3 meters from where it was at the end of the night before, effectively making progress up the wall. This pattern could help in understanding how many days it takes for the snail to reach a point where its final climb of 2 meters (or more) takes it to the top without sliding back.\n", + " Step 4: Consider the critical point where the snail's climb takes it to or beyond the top of the wall without sliding back. If the snail needs to climb 2 meters or more on its final ascent to reach the top without sliding, we need to figure out the height at which this becomes possible. This might involve finding a pattern or using algebra to express the snail's position over time.\n", + "---------------\n", + "Path 9:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + " Step 3: Think about the pattern of movement day by day. On the first day, the snail climbs 3 meters and slides back 2, so it's at 1 meter. Each subsequent day, it climbs 3 meters from where it was at the end of the night before, effectively making progress up the wall. This pattern could help in understanding how many days it takes for the snail to reach a point where its final climb of 2 meters (or more) takes it to the top without sliding back.\n", + " Step 4: Model the snail's movement mathematically. Let's denote the height of the wall as H and the number of days the snail takes to reach near the top as n. On the nth day, the snail should climb 3 meters to either reach or exceed the height H. Considering the pattern, on each day before the last, the snail effectively moves 1 meter up. So, on the day before the final climb, the snail should be at H - 3 meters (since it climbs 3 meters on the last day). This thought involves setting up an equation to solve for n, the number of days, given the height H of the wall.\n", + "---------------\n", + "Path 10:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Simplify the equation given to understand the relationship between the days the snail takes to climb out and the height of the well. The equation 3 * days - 2 * (days - 1) >= 10 can be simplified to make it easier to solve for the number of days.\n", + " Step 4: Start by simplifying the equation using algebraic manipulation. Distribute and combine like terms: 3 * days - 2 * days + 2 >= 10, which simplifies to days + 2 >= 10.\n", + "---------------\n", + "Path 11:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Simplify the equation given to understand the relationship between the days the snail takes to climb out and the height of the well. The equation 3 * days - 2 * (days - 1) >= 10 can be simplified to make it easier to solve for the number of days.\n", + " Step 4: Consider the physical context of the problem, where the snail is climbing out of a well. The equation might represent the relationship between the snail's progress and the well's height. By rearranging the equation, we can isolate the variable representing the height or the days, potentially revealing a clearer relationship.\n", + "---------------\n", + "Path 12:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Simplify the equation given to understand the relationship between the days the snail takes to climb out and the height of the well. The equation 3 * days - 2 * (days - 1) >= 10 can be simplified to make it easier to solve for the number of days.\n", + " Step 4: Apply the distributive property first to expand the equation: 3 * days - 2 * days + 2 >= 10. Then, consider factoring or further simplifying to find a more manageable form, which could help identify key factors or constraints that influence the number of days the snail takes to climb out of the well.\n", + "---------------\n", + "Path 13:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Consider the physical constraints of the problem. Since the snail climbs 3 meters up and slides 2 meters back each day except the last, we should think about how many days it would take for the snail to be at or above the 10-meter mark without sliding back, which would require calculating the net progress over a series of days.\n", + " Step 4: To find out how many days it takes for the snail to reach or exceed the 10-meter mark, we should calculate the net progress per day, which is 3 meters up and 2 meters back, resulting in a net gain of 1 meter per day, except for the last day when it won't slide back.\n", + "---------------\n", + "Path 14:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Consider the physical constraints of the problem. Since the snail climbs 3 meters up and slides 2 meters back each day except the last, we should think about how many days it would take for the snail to be at or above the 10-meter mark without sliding back, which would require calculating the net progress over a series of days.\n", + " Step 4: We need to consider the minimum height the snail must climb on its final day to reach or exceed 10 meters without sliding back. This means the snail must be at or below the 10-meter mark at the start of the day and reach or exceed it by the end of the day, without sliding back.\n", + "---------------\n", + "Path 15:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Consider the physical constraints of the problem. Since the snail climbs 3 meters up and slides 2 meters back each day except the last, we should think about how many days it would take for the snail to be at or above the 10-meter mark without sliding back, which would require calculating the net progress over a series of days.\n", + " Step 4: Breaking down the problem into segments, we can analyze the pattern of the snail's climb. For instance, after the first day, the snail is at 1 meter (3 meters up, 2 meters back), and this pattern continues. We can use this pattern to determine on which day the snail will reach a height from which it can climb to or beyond 10 meters on its final push without sliding back.\n", + "---------------\n", + "Path 16:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Solve the inequality step by step. First, distribute the -2 across the parentheses: 3 * days - 2 * days + 2 >= 10. This simplifies to days + 2 >= 10. From here, we can isolate \"days\" to find the minimum number of days required for the snail to reach or exceed the top of the well.\n", + " Step 4: To isolate \"days\", we should subtract 2 from both sides of the inequality days + 2 >= 10, which would result in days >= 8. This step is crucial in simplifying the inequality further to find the minimum number of days.\n", + "---------------\n", + "Path 17:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Solve the inequality step by step. First, distribute the -2 across the parentheses: 3 * days - 2 * days + 2 >= 10. This simplifies to days + 2 >= 10. From here, we can isolate \"days\" to find the minimum number of days required for the snail to reach or exceed the top of the well.\n", + " Step 4: Before isolating \"days\", let's re-examine the initial step of distributing -2 across the parentheses and ensure it was done correctly. The correct distribution should yield 3*days - 2*days + 2 >= 10, simplifying to days + 2 >= 10. Confirming this step will ensure the accuracy of the subsequent steps.\n", + "---------------\n", + "Path 18:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Consider using a formulaic approach. The snail's net progress each day is 3 meters (up) - 2 meters (down) = 1 meter per day. However, on the last day of climbing, the snail won't slide back, as it will have reached or surpassed the top of the well. We can set up an equation where the total progress equals or exceeds the well's height: 3 * days - 2 * (days - 1) >= 10.\n", + " Step 3: Solve the inequality step by step. First, distribute the -2 across the parentheses: 3 * days - 2 * days + 2 >= 10. This simplifies to days + 2 >= 10. From here, we can isolate \"days\" to find the minimum number of days required for the snail to reach or exceed the top of the well.\n", + " Step 4: Instead of immediately isolating \"days\", consider the inequality days + 2 >= 10 and think about what it means in the context of the problem. The snail needs to reach or exceed the top of the well, so we're looking for the minimum number of days where this condition is met. We can then proceed to solve for \"days\" by subtracting 2 from both sides of the inequality.\n", + "---------------\n", + "Path 19:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: We can model the snail's movement as an arithmetic sequence where each day the snail climbs one more meter than the previous day and slides back one more meter than the previous night, effectively making the daily net progress increase by 1 meter each day. This means the snail's net progress follows the sequence 1, 2, 3, etc., meters per day.\n", + " Step 4: Let's express the snail's daily net progress mathematically. If the snail climbs \\(x\\) meters one day and slides back \\(y\\) meters that night, and the next day it climbs \\(x+1\\) meters and slides back \\(y+1\\) meters, the net progress each day increases by 1 meter because the difference between \\(x+1\\) and \\(y+1\\) is one more than the difference between \\(x\\) and \\(y\\).\n", + "---------------\n", + "Path 20:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: We can model the snail's movement as an arithmetic sequence where each day the snail climbs one more meter than the previous day and slides back one more meter than the previous night, effectively making the daily net progress increase by 1 meter each day. This means the snail's net progress follows the sequence 1, 2, 3, etc., meters per day.\n", + " Step 4: We should analyze the sequence of the snail's net progress over several days to identify any patterns or formulas that can help in calculating the total distance covered over a period. This sequence, being arithmetic with a common difference of 1, suggests that the total progress after \\(n\\) days might be related to the sum of the first \\(n\\) natural numbers.\n", + "---------------\n", + "Path 21:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: We can model the snail's movement as an arithmetic sequence where each day the snail climbs one more meter than the previous day and slides back one more meter than the previous night, effectively making the daily net progress increase by 1 meter each day. This means the snail's net progress follows the sequence 1, 2, 3, etc., meters per day.\n", + " Step 4: Considering the snail's movement as an arithmetic sequence, we should also think about the initial conditions and how they affect the overall movement. For instance, if the snail starts with a certain initial climb or slide, how does this influence its subsequent daily net progress? Understanding the impact of initial conditions could provide insights into how to model the snail's movement more accurately over varying periods.\n", + "---------------\n", + "Path 22:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: To determine when the snail reaches or surpasses 10 meters, we can calculate the cumulative sum of the daily net progress. Since the snail climbs in an arithmetic sequence (1, 2, 3, ...), we can use the formula for the sum of the first n natural numbers, which is n(n + 1)/2, to find out after which day the cumulative sum equals or exceeds 10 meters.\n", + " Step 4: We can start by directly applying the formula for the sum of the first n natural numbers, n(n + 1)/2, and set it greater than or equal to 10 to find the day when the snail reaches or surpasses 10 meters, solving the inequality n(n + 1)/2 ā‰„ 10 for n.\n", + "---------------\n", + "Path 23:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: To determine when the snail reaches or surpasses 10 meters, we can calculate the cumulative sum of the daily net progress. Since the snail climbs in an arithmetic sequence (1, 2, 3, ...), we can use the formula for the sum of the first n natural numbers, which is n(n + 1)/2, to find out after which day the cumulative sum equals or exceeds 10 meters.\n", + " Step 4: To ensure we understand the snail's progress, let's manually calculate the cumulative sum for the first few days (1, 3, 6, 10, ...) to see the pattern and when it reaches or exceeds 10 meters, providing a concrete basis for our calculations.\n", + "---------------\n", + "Path 24:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: To determine when the snail reaches or surpasses 10 meters, we can calculate the cumulative sum of the daily net progress. Since the snail climbs in an arithmetic sequence (1, 2, 3, ...), we can use the formula for the sum of the first n natural numbers, which is n(n + 1)/2, to find out after which day the cumulative sum equals or exceeds 10 meters.\n", + " Step 4: Considering the nature of arithmetic sequences and cumulative sums, we can also approach this problem by iteratively adding the daily progress (1, then 2, then 3, and so on) in a loop until the sum meets or exceeds 10 meters, potentially leading to a straightforward computational solution.\n", + "---------------\n", + "Path 25:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: Alternatively, we can simulate the snail's movement day by day, keeping track of its net progress each day until it reaches or exceeds 10 meters. This approach involves iterative addition, where each day's net gain is added to the total, and checking if the total has reached or surpassed the target height of 10 meters, at which point we can stop and identify the day the snail reached the top.\n", + " Step 4: Initialize a variable to track the total distance covered by the snail and another to count the days, starting both at 0. This will provide a clear, iterative approach to calculating the snail's progress.\n", + "---------------\n", + "Path 26:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: Alternatively, we can simulate the snail's movement day by day, keeping track of its net progress each day until it reaches or exceeds 10 meters. This approach involves iterative addition, where each day's net gain is added to the total, and checking if the total has reached or surpassed the target height of 10 meters, at which point we can stop and identify the day the snail reached the top.\n", + " Step 4: Consider the daily net gain of the snail. If we know how much the snail moves up each day and how much it might slide back at night, we can calculate the net progress per day and add this to our running total until we hit or exceed the 10-meter mark.\n", + "---------------\n", + "Path 27:\n", + " Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + " Step 2: Analyze the pattern of the snail's movement day by day to identify when it reaches the top. On the first day, it climbs to 3 meters, then slides back to 1 meter at night. On the second day, it climbs to 4 meters, then slides back to 2 meters, and so on. We can list the daily progress: Day 1 (1 meter net), Day 2 (2 meters net), Day 3 (3 meters net), and continue until we reach or surpass 10 meters, keeping in mind the snail doesn't slide back on the final day of climbing.\n", + " Step 3: Alternatively, we can simulate the snail's movement day by day, keeping track of its net progress each day until it reaches or exceeds 10 meters. This approach involves iterative addition, where each day's net gain is added to the total, and checking if the total has reached or surpassed the target height of 10 meters, at which point we can stop and identify the day the snail reached the top.\n", + " Step 4: Develop a loop or recursive function that simulates each day of the snail's climb. Within this loop, add the daily net gain to the total distance and increment the day counter. The loop should continue until the total distance is greater than or equal to 10 meters, at which point the function can return the number of days it took for the snail to reach this height.\n", + "---------------\n", + "\n", + "Scoring all reasoning paths...\n", + "\n", + "Path 1: Scored 90/100\n", + "Path 2: Scored 75/100\n", + "Path 3: Scored 78/100\n", + "Path 4: Scored 88/100\n", + "Path 5: Scored 90/100\n", + "Path 6: Scored 90/100\n", + "Path 7: Scored 85/100\n", + "Path 8: Scored 88/100\n", + "Path 9: Scored 90/100\n", + "Path 10: Scored 38/100\n", + "Path 11: Scored 88/100\n", + "Path 12: Scored 87/100\n", + "Path 13: Scored 88/100\n", + "Path 14: Scored 85/100\n", + "Path 15: Scored 85/100\n", + "Path 16: Scored 88/100\n", + "Path 17: Scored 88/100\n", + "Path 18: Scored 88/100\n", + "Path 19: Scored 80/100\n", + "Path 20: Scored 85/100\n", + "Path 21: Scored 78/100\n", + "Path 22: Scored 90/100\n", + "Path 23: Scored 90/100\n", + "Path 24: Scored 90/100\n", + "Path 25: Scored 90/100\n", + "Path 26: Scored 88/100\n", + "Path 27: Scored 90/100\n", + "\n", + "Best Reasoning Path:\n", + "Step 1: A snail is stuck at the bottom of a 10-meter well. During the day, it climbs up 3 meters, but each night, it slides back down 2 meters. How many days will it take for the snail to reach the top of the well?\n", + "Step 2: Let's break down the daily progress of the snail. If it climbs 3 meters during the day and slides back 2 meters at night, it effectively moves 1 meter up each day. We can calculate the number of days it takes to climb 8 meters (10 - 2, considering the final 2 meters it will climb in the last day without sliding back), as on the 8th meter, when it climbs the final 2 meters, it will reach the top without sliding back.\n", + "Step 3: Calculate the net progress per day by subtracting the amount the snail slides back at night from the amount it climbs during the day, which is 3 meters - 2 meters = 1 meter. This means the snail effectively moves 1 meter up each day.\n", + "Step 4: Understand the Snail's Daily Movement Pattern - First, we need to grasp that the snail's net movement is the difference between what it achieves during the day and what it loses at night, which is 3 meters up during the day and 2 meters back at night, resulting in a net gain of 1 meter per day.\n", + "\n", + "Final Score: 90/100\n", + "\n", + "The solution is...\n", + "To find out how many days it will take for the snail to reach the top of the well, we calculate the net progress per day, which is 1 meter (3 meters up during the day - 2 meters back at night). Since the snail needs to climb 8 meters to have a final push to the top without sliding back, and it climbs 1 meter effectively each day, it will take 8 days to climb those 8 meters. On the 8th day, when it climbs the final 2 meters, it will reach the top of the 10-meter well.\n", + "\n", + "The final answer is 8.\n" + ] + } + ], + "source": [ + "# \"bfs\" or \"dfs\"\n", + "mode = \"bfs\"\n", + "\n", + "# Your prompt here...\n", + "reasoning_prompt = \"A snail is stuck at the bottom of a 10-meter well. \\\n", + "During the day, it climbs up 3 meters, but each night, it slides back down \\\n", + "2 meters. How many days will it take for the snail to reach the top of the well?\"\n", + "\n", + "tree_of_thought()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bTM31Mm5Fp1x" + }, + "source": [ + "**VISUALIZATION OF THE SOLUTION TREE**" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "id": "4cwRa2VbFsXj" + }, + "outputs": [], + "source": [ + "def visualize_tree_with_best_path(root_node, best_path, max_children=3):\n", + " import networkx as nx\n", + " import matplotlib.pyplot as plt\n", + " from networkx.drawing.nx_agraph import graphviz_layout\n", + "\n", + " G = nx.DiGraph()\n", + " labels = {}\n", + " best_path_nodes = set()\n", + "\n", + " # Match best path node references based on thought text\n", + " def match_best_path(root, best_path):\n", + " path_nodes = []\n", + " current_node = root\n", + " for step_text in best_path[1:]: # Skip root\n", + " for child in current_node.children:\n", + " if child.thought == step_text:\n", + " path_nodes.append(child)\n", + " current_node = child\n", + " break\n", + " return path_nodes\n", + "\n", + " best_path_nodes = set([id(n) for n in match_best_path(root_node, best_path)])\n", + "\n", + " # Build the graph and limit children per node\n", + " def add_edges(node):\n", + " labels[id(node)] = node.thought[:40] + (\"...\" if len(node.thought) > 40 else \"\")\n", + " children_to_show = node.children[:max_children] # limit here\n", + " for child in children_to_show:\n", + " G.add_edge(id(node), id(child))\n", + " add_edges(child)\n", + "\n", + " add_edges(root_node)\n", + "\n", + " try:\n", + " pos = graphviz_layout(G, prog=\"dot\")\n", + " except Exception as e:\n", + " print(\"āš ļø Graphviz layout failed:\", e)\n", + " print(\"Falling back to spring layout\")\n", + " pos = nx.spring_layout(G, k=0.9, seed=42)\n", + "\n", + " node_colors = [\n", + " \"lightgreen\" if node in best_path_nodes else \"lightblue\"\n", + " for node in G.nodes\n", + " ]\n", + "\n", + " plt.figure(figsize=(14, 10))\n", + " nx.draw(G, pos, with_labels=False, arrows=True, node_size=1600, node_color=node_colors)\n", + " nx.draw_networkx_labels(G, pos, labels, font_size=8)\n", + " plt.title(f\"Tree of Thought (Top {max_children} Branches per Node)\", fontsize=14)\n", + " plt.axis('off')\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 924 + }, + "id": "HYouOkkvFsvT", + "outputId": "629f0232-e773-49ea-ac8d-8036be038009" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "āš ļø Graphviz layout failed: requires pygraphviz http://pygraphviz.github.io/\n", + "Falling back to spring layout\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":51: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_tree_with_best_path(root, best_path, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "nkE3N-L3NIh9" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/tutorials/tree-of-thought-prompting/requirements.txt b/tutorials/tree-of-thought-prompting/requirements.txt new file mode 100644 index 0000000..0d691d8 --- /dev/null +++ b/tutorials/tree-of-thought-prompting/requirements.txt @@ -0,0 +1,7 @@ +python-dotenv +groq +networkx +matplotlib +pygraphviz +flask +flask_cors \ No newline at end of file