Atom of Thoughts (AoT) is a tool for solving complex problems by decomposing them into independent, reusable atomic units of thought. Unlike traditional sequential thinking, this tool enables more powerful problem solving by allowing atomic units of thought to form dependencies with each other.

When to use:

• Solving problems requiring complex reasoning

• Generating hypotheses that need verification from multiple perspectives

• Deriving high-confidence conclusions in scenarios where accuracy is crucial

• Minimizing logical errors in critical tasks

• Decision-making requiring multiple verification steps

Atom types:

• premise: Basic assumptions or given information for problem solving

• reasoning: Logical reasoning process based on other atoms

• hypothesis: Proposed solutions or intermediate conclusions

• verification: Process to evaluate the validity of other atoms (especially hypotheses)

• conclusion: Verified hypotheses or final problem solutions

Parameter descriptions:

• atomId: Unique identifier for the atom (e.g., 'A1', 'H2')

• content: Actual content of the atom

• atomType: Type of atom (one of: premise, reasoning, hypothesis, verification, conclusion)

• dependencies: List of IDs of other atoms this atom depends on

• confidence: Confidence level of this atom (value between 0-1)

• isVerified: Whether this atom has been verified

• depth: Depth level of this atom (in the decomposition-contraction process)

Additional features:

1. Decomposition-Contraction mechanism:

   • Decompose atoms into smaller sub-atoms and contract back after verification

   • startDecomposition(atomId): Start atom decomposition

   • addToDecomposition(decompositionId, atomId): Add sub-atom to decomposition

   • completeDecomposition(decompositionId): Complete decomposition process

2. Automatic termination mechanism:

   • Automatically terminate when reaching maximum depth or finding high-confidence conclusion

   • getTerminationStatus(): Return termination status and reason

   • getBestConclusion(): Return highest confidence conclusion

Usage method:

1. Understand the problem and define necessary premise atoms

2. Create reasoning atoms based on premises

3. Create hypothesis atoms based on reasoning

4. Create verification atoms to verify hypotheses

5. Derive conclusion atoms based on verified hypotheses

6. Use atom decomposition to explore deeper when necessary

7. Present the high-confidence conclusion atom as the final answer

A lightweight version of Atom of Thoughts (AoT) designed for faster processing and quicker results. This streamlined version sacrifices some depth of analysis for speed, making it ideal for time-sensitive reasoning tasks.

When to use:

• Quick brainstorming sessions requiring atomic thought organization

• Time-sensitive problem solving where speed is prioritized over exhaustive analysis

• Simpler reasoning tasks that don't require deep decomposition

• Initial exploration before using the full AoT for deeper analysis

• Learning or demonstration purposes where response time is important

Key differences from full AoT:

• Lower maximum depth (3 instead of 5) for faster processing

• Simplified verification process

• Immediate conclusion suggestion for high-confidence hypotheses

• Reduced computational overhead and response payload

• Optimized for speed rather than exhaustive analysis

Atom types and parameters are the same as the full AoT tool.

A command tool to control the decomposition-contraction mechanism and automatic termination of Atom of Thoughts.

Use this tool to access advanced features of AoT:

1. Decomposition (decompose): Decompose a specified atom into smaller sub-atoms

2. Complete decomposition (complete_decomposition): Complete an ongoing decomposition process

3. Check termination status (termination_status): Check the termination status of the current AoT process

4. Get best conclusion (best_conclusion): Get the verified conclusion with the highest confidence

5. Change settings (set_max_depth): Change the maximum depth limit

Command descriptions:

• command: Command to execute (decompose, complete_decomposition, termination_status, best_conclusion, set_max_depth)

• atomId: Atom ID to use with the command (only required for decompose command)

• decompositionId: ID of the decomposition process (only required for complete_decomposition command)

• maxDepth: Maximum depth value to set (only required for set_max_depth command)