docs: add detailed codelet decorator explanation with comments
This commit is contained in:
@ -1,54 +0,0 @@
|
||||
# README_bond.md
|
||||
|
||||
## Overview
|
||||
`bond.py` implements the Bond system, a key component of the Copycat system that manages the relationships between objects in strings. It handles the creation, evaluation, and management of bonds that represent meaningful connections between objects based on their properties and relationships.
|
||||
|
||||
## Core Components
|
||||
- `Bond` class: Main class that represents a bond between objects
|
||||
- Bond evaluation system
|
||||
- Bond compatibility management
|
||||
|
||||
## Key Features
|
||||
- Manages bonds between objects in strings
|
||||
- Evaluates bond strength based on multiple factors
|
||||
- Handles bond direction and category
|
||||
- Supports bond flipping and versioning
|
||||
- Manages bond compatibility and support
|
||||
|
||||
## Bond Components
|
||||
- `source`: Source object of the bond
|
||||
- `destination`: Destination object of the bond
|
||||
- `category`: Category of the bond
|
||||
- `facet`: Aspect of the bond
|
||||
- `directionCategory`: Direction of the bond
|
||||
- `sourceDescriptor`: Descriptor of the source object
|
||||
- `destinationDescriptor`: Descriptor of the destination object
|
||||
|
||||
## Main Methods
|
||||
- `updateInternalStrength()`: Calculate internal bond strength
|
||||
- `updateExternalStrength()`: Calculate external bond strength
|
||||
- `buildBond()`: Create and establish bond
|
||||
- `breakBond()`: Remove bond
|
||||
- `localSupport()`: Calculate local support
|
||||
- `numberOfLocalSupportingBonds()`: Count supporting bonds
|
||||
- `sameCategories()`: Compare bond categories
|
||||
- `localDensity()`: Calculate local bond density
|
||||
|
||||
## Bond Types
|
||||
- Letter category bonds
|
||||
- Direction-based bonds
|
||||
- Category-based bonds
|
||||
- Flipped bonds
|
||||
- Modified bonds
|
||||
|
||||
## Dependencies
|
||||
- Requires `workspaceStructure` module
|
||||
- Used by the main `copycat` module
|
||||
|
||||
## Notes
|
||||
- Bonds are evaluated based on member compatibility and facet factors
|
||||
- The system supports both same-type and different-type bonds
|
||||
- Bonds can have direction categories (left, right)
|
||||
- The system handles bond compatibility and support
|
||||
- Bonds can be flipped to create alternative versions
|
||||
- Local density and support factors influence bond strength
|
||||
@ -1,49 +0,0 @@
|
||||
# README_coderack.md
|
||||
|
||||
## Overview
|
||||
`coderack.py` implements the Coderack, a key component of the Copycat system that manages the execution of codelets (small, focused procedures) that drive the analogical reasoning process. It handles the posting, selection, and execution of codelets based on their urgency and the current state of the system.
|
||||
|
||||
## Core Components
|
||||
- `Coderack` class: Main class that manages codelet execution
|
||||
- Codelet management system
|
||||
- Urgency-based codelet selection
|
||||
|
||||
## Key Features
|
||||
- Manages a collection of codelets (small procedures)
|
||||
- Implements urgency-based codelet selection
|
||||
- Supports both top-down and bottom-up codelet posting
|
||||
- Handles codelet execution and removal
|
||||
- Manages rule, correspondence, description, and group proposals
|
||||
|
||||
## Codelet Types
|
||||
- Breaker codelets
|
||||
- Description codelets (top-down and bottom-up)
|
||||
- Bond codelets (top-down and bottom-up)
|
||||
- Group codelets (top-down and whole-string)
|
||||
- Rule codelets (scout, strength-tester, builder, translator)
|
||||
- Correspondence codelets (bottom-up and important-object)
|
||||
- Replacement finder codelets
|
||||
|
||||
## Main Methods
|
||||
- `post(codelet)`: Add a codelet to the coderack
|
||||
- `chooseAndRunCodelet()`: Select and execute a codelet
|
||||
- `postTopDownCodelets()`: Post codelets from activated slipnet nodes
|
||||
- `postBottomUpCodelets()`: Post codelets based on workspace state
|
||||
- `proposeRule()`: Create and post a rule proposal
|
||||
- `proposeCorrespondence()`: Create and post a correspondence proposal
|
||||
- `proposeDescription()`: Create and post a description proposal
|
||||
- `proposeGroup()`: Create and post a group proposal
|
||||
- `proposeBond()`: Create and post a bond proposal
|
||||
|
||||
## Dependencies
|
||||
- Requires `codeletMethods` module
|
||||
- Uses `bond`, `codelet`, `correspondence`, `description`, `group`, and `rule` modules
|
||||
- Uses `logging` for debug output
|
||||
- Uses `math` for urgency calculations
|
||||
|
||||
## Notes
|
||||
- Codelets are organized by urgency bins
|
||||
- The system maintains a maximum of 100 codelets
|
||||
- Codelet selection is influenced by temperature and workspace state
|
||||
- The system supports both deterministic and probabilistic codelet posting
|
||||
- Codelet urgency is calculated based on various factors including conceptual depth
|
||||
@ -16,9 +16,19 @@ from .correspondence import Correspondence
|
||||
def codelet(name):
|
||||
"""Decorator for otherwise-unused functions that are in fact used as codelet behaviors"""
|
||||
def wrap(f):
|
||||
# Verify that the decorated function has exactly two parameters:
|
||||
# 1. ctx - the context object containing workspace, slipnet, etc.
|
||||
# 2. codelet - the codelet instance itself
|
||||
# The None values in the tuple represent: no default args, no *args, no **kwargs
|
||||
assert tuple(inspect.getargspec(f)) == (['ctx', 'codelet'], None, None, None)
|
||||
|
||||
# Mark this function as a valid codelet method
|
||||
f.is_codelet_method = True
|
||||
|
||||
# Store the codelet name
|
||||
f.codelet_name = name
|
||||
|
||||
# Return the decorated function
|
||||
return f
|
||||
return wrap
|
||||
|
||||
|
||||
@ -30,27 +30,63 @@ The codelet system is a fundamental component of the Copycat architecture that d
|
||||
- Cleanup codelets
|
||||
|
||||
## Usage
|
||||
Codelets are created and managed through the codelet system:
|
||||
Codelets are created and managed through the codelet system.
|
||||
|
||||
The behavior parameter in codelet.set_behavior would typically be a reference to one of the **many codelet methods defined in codeletMethods.py**.
|
||||
For example, a codelet might be assigned a behavior like:
|
||||
- build_group - to create a new group of related elements
|
||||
- evaluate_bond - to assess the strength of a bond
|
||||
- scout_for_correspondence - to look for potential mappings between structures
|
||||
The behavior is what gives each codelet its purpose and role in the system's parallel processing architecture. When the codelet is executed via codelet.run(), it performs this assigned behavior in the context of the current workspace state.
|
||||
|
||||
```python
|
||||
# Create a codelet
|
||||
codelet = Codelet(name, priority)
|
||||
|
||||
# Set behavior
|
||||
''''
|
||||
The behavior parameter would typically be a reference to one of the **many codelet methods defined in codeletMethods.py**.
|
||||
For example, a codelet might be assigned a behavior like:
|
||||
build_group - to create a new group of related elements
|
||||
evaluate_bond - to assess the strength of a bond
|
||||
scout_for_correspondence - to look for potential mappings between structures
|
||||
The behavior is what gives each codelet its purpose and role in the system's parallel processing architecture. When the codelet is executed via codelet.run(), it performs this assigned behavior in the context of the current workspace state.
|
||||
'''
|
||||
codelet.set_behavior(behavior)
|
||||
|
||||
# Execute codelet
|
||||
result = codelet.run()
|
||||
```
|
||||
|
||||
## Codelet Decorator
|
||||
The `@codelet` decorator is defined in `codeletMethods.py` and is used to mark functions as codelet behaviors. Here's its implementation:
|
||||
|
||||
```python
|
||||
def codelet(name):
|
||||
"""Decorator for otherwise-unused functions that are in fact used as codelet behaviors"""
|
||||
def wrap(f):
|
||||
# Verify that the decorated function has exactly two parameters:
|
||||
# 1. ctx - the context object containing workspace, slipnet, etc.
|
||||
# 2. codelet - the codelet instance itself
|
||||
# The None values in the tuple represent: no default args, no *args, no **kwargs
|
||||
assert tuple(inspect.getargspec(f)) == (['ctx', 'codelet'], None, None, None)
|
||||
|
||||
# Mark this function as a valid codelet method
|
||||
f.is_codelet_method = True
|
||||
|
||||
# Store the codelet type name for reference
|
||||
f.codelet_name = name
|
||||
return f
|
||||
return wrap
|
||||
```
|
||||
|
||||
The decorator:
|
||||
1. Takes a `name` parameter that identifies the type of codelet
|
||||
2. Wraps the decorated function with additional metadata:
|
||||
- Marks the function as a codelet method with `is_codelet_method = True`
|
||||
- Stores the codelet name with `codelet_name = name`
|
||||
3. Verifies that the decorated function has the correct signature (must take `ctx` and `codelet` parameters)
|
||||
|
||||
Example usage:
|
||||
```python
|
||||
@codelet('breaker')
|
||||
def breaker(ctx, codelet):
|
||||
# Codelet behavior implementation
|
||||
pass
|
||||
```
|
||||
|
||||
## Dependencies
|
||||
- Python 3.x
|
||||
- No external dependencies required
|
||||
|
||||
@ -1,40 +0,0 @@
|
||||
# README_copycat.md
|
||||
|
||||
## Overview
|
||||
`copycat.py` is the core module of the Copycat system, implementing the main analogical reasoning algorithm. It coordinates the interaction between various components like the workspace, slipnet, coderack, and temperature system.
|
||||
|
||||
## Core Components
|
||||
- `Copycat` class: Main class that orchestrates the analogical reasoning process
|
||||
- `Reporter` class: Base class for defining different types of reporters (GUI, curses, etc.)
|
||||
|
||||
## Key Features
|
||||
- Implements the main Copycat algorithm for analogical reasoning
|
||||
- Manages the interaction between different system components
|
||||
- Supports multiple interfaces (GUI, curses, command-line)
|
||||
- Provides temperature-based control of the reasoning process
|
||||
- Handles multiple iterations and answer collection
|
||||
|
||||
## Main Methods
|
||||
- `run(initial, modified, target, iterations)`: Run the algorithm for a specified number of iterations
|
||||
- `runGUI()`: Run the algorithm with graphical interface
|
||||
- `run_forever(initial, modified, target)`: Run the algorithm continuously
|
||||
- `runTrial()`: Run a single trial of the algorithm
|
||||
- `step()`: Execute a single step of the algorithm
|
||||
- `update_workspace(currentTime)`: Update all workspace components
|
||||
|
||||
## Dependencies
|
||||
- Requires `coderack`, `randomness`, `slipnet`, `temperature`, and `workspace` modules
|
||||
- Uses `pprint` for pretty printing results
|
||||
- Optional GUI support through the `gui` module
|
||||
|
||||
## Usage
|
||||
The module is typically used through one of the interface modules:
|
||||
- `main.py` for command-line interface
|
||||
- `gui.py` for graphical interface
|
||||
- `curses_main.py` for terminal-based interface
|
||||
|
||||
## Notes
|
||||
- The system uses a temperature-based control mechanism to guide the reasoning process
|
||||
- Results include answer statistics, temperature, and time metrics
|
||||
- The system supports both single-run and continuous operation modes
|
||||
- The reporter system allows for flexible output handling
|
||||
@ -1,51 +0,0 @@
|
||||
# README_correspondence.md
|
||||
|
||||
## Overview
|
||||
`correspondence.py` implements the Correspondence system, a key component of the Copycat system that manages the mapping relationships between objects in the initial and target strings. It handles the creation, evaluation, and management of correspondences that link objects based on their properties and relationships.
|
||||
|
||||
## Core Components
|
||||
- `Correspondence` class: Main class that represents a mapping between objects
|
||||
- Concept mapping system
|
||||
- Correspondence strength evaluation
|
||||
|
||||
## Key Features
|
||||
- Manages mappings between objects in initial and target strings
|
||||
- Evaluates correspondence strength based on multiple factors
|
||||
- Handles concept slippages and mappings
|
||||
- Supports both direct and accessory concept mappings
|
||||
- Manages correspondence compatibility and support
|
||||
|
||||
## Correspondence Components
|
||||
- `objectFromInitial`: Object from the initial string
|
||||
- `objectFromTarget`: Object from the target string
|
||||
- `conceptMappings`: List of concept mappings
|
||||
- `accessoryConceptMappings`: Additional concept mappings
|
||||
- `flipTargetObject`: Flag for target object flipping
|
||||
|
||||
## Main Methods
|
||||
- `updateInternalStrength()`: Calculate internal correspondence strength
|
||||
- `updateExternalStrength()`: Calculate external correspondence strength
|
||||
- `buildCorrespondence()`: Create and establish correspondence
|
||||
- `breakCorrespondence()`: Remove correspondence
|
||||
- `incompatible()`: Check correspondence compatibility
|
||||
- `supporting()`: Check if correspondence supports another
|
||||
- `internallyCoherent()`: Check internal coherence
|
||||
|
||||
## Concept Mapping Types
|
||||
- Distinguishing mappings
|
||||
- Relevant distinguishing mappings
|
||||
- Bond mappings
|
||||
- Direction mappings
|
||||
- Symmetric mappings
|
||||
|
||||
## Dependencies
|
||||
- Requires `conceptMapping`, `group`, `letter`, and `workspaceStructure` modules
|
||||
- Uses `formulas` for mapping calculations
|
||||
- Used by the main `copycat` module
|
||||
|
||||
## Notes
|
||||
- Correspondences are evaluated based on concept mapping strength and coherence
|
||||
- The system supports both direct and indirect concept mappings
|
||||
- Correspondences can be incompatible with each other
|
||||
- The system handles both letter and group correspondences
|
||||
- Concept slippages are tracked and managed
|
||||
@ -1,53 +0,0 @@
|
||||
# README_group.md
|
||||
|
||||
## Overview
|
||||
`group.py` implements the Group system, a key component of the Copycat system that manages the grouping of objects in strings. It handles the creation, evaluation, and management of groups that represent meaningful collections of objects based on their properties and relationships.
|
||||
|
||||
## Core Components
|
||||
- `Group` class: Main class that represents a group of objects
|
||||
- Group evaluation system
|
||||
- Group description management
|
||||
|
||||
## Key Features
|
||||
- Manages groups of objects in strings
|
||||
- Evaluates group strength based on multiple factors
|
||||
- Handles group descriptions and bond descriptions
|
||||
- Supports group flipping and versioning
|
||||
- Manages group compatibility and support
|
||||
|
||||
## Group Components
|
||||
- `groupCategory`: Category of the group
|
||||
- `directionCategory`: Direction of the group
|
||||
- `facet`: Aspect of the group
|
||||
- `objectList`: List of objects in the group
|
||||
- `bondList`: List of bonds in the group
|
||||
- `descriptions`: List of group descriptions
|
||||
- `bondDescriptions`: List of bond descriptions
|
||||
|
||||
## Main Methods
|
||||
- `updateInternalStrength()`: Calculate internal group strength
|
||||
- `updateExternalStrength()`: Calculate external group strength
|
||||
- `buildGroup()`: Create and establish group
|
||||
- `breakGroup()`: Remove group
|
||||
- `localSupport()`: Calculate local support
|
||||
- `numberOfLocalSupportingGroups()`: Count supporting groups
|
||||
- `sameGroup()`: Compare groups for equality
|
||||
|
||||
## Group Types
|
||||
- Single letter groups
|
||||
- Multi-letter groups
|
||||
- Direction-based groups
|
||||
- Category-based groups
|
||||
- Length-based groups
|
||||
|
||||
## Dependencies
|
||||
- Requires `description`, `workspaceObject`, and `formulas` modules
|
||||
- Used by the main `copycat` module
|
||||
|
||||
## Notes
|
||||
- Groups are evaluated based on bond association and length
|
||||
- The system supports both single and multi-object groups
|
||||
- Groups can have multiple descriptions and bond descriptions
|
||||
- The system handles group compatibility and support
|
||||
- Groups can be flipped to create alternative versions
|
||||
- Length descriptions are probabilistically added based on temperature
|
||||
@ -1,47 +0,0 @@
|
||||
# README_rule.md
|
||||
|
||||
## Overview
|
||||
`rule.py` implements the Rule system, a key component of the Copycat system that manages the transformation rules used in analogical reasoning. It handles the creation, evaluation, and application of rules that describe how to transform strings based on their properties and relationships.
|
||||
|
||||
## Core Components
|
||||
- `Rule` class: Main class that represents a transformation rule
|
||||
- Rule evaluation system
|
||||
- Rule translation and application system
|
||||
|
||||
## Key Features
|
||||
- Defines transformation rules with facets, descriptors, categories, and relations
|
||||
- Evaluates rule strength based on multiple factors
|
||||
- Supports rule translation through concept slippages
|
||||
- Handles string transformations based on rules
|
||||
- Manages rule compatibility with correspondences
|
||||
|
||||
## Rule Components
|
||||
- `facet`: The aspect of the object to change (e.g., length)
|
||||
- `descriptor`: The property being changed
|
||||
- `category`: The type of object being changed
|
||||
- `relation`: The transformation to apply
|
||||
|
||||
## Main Methods
|
||||
- `updateInternalStrength()`: Calculate rule strength
|
||||
- `updateExternalStrength()`: Update external strength
|
||||
- `activateRuleDescriptions()`: Activate rule-related concepts
|
||||
- `buildTranslatedRule()`: Apply rule to target string
|
||||
- `incompatibleRuleCorrespondence()`: Check rule-correspondence compatibility
|
||||
- `ruleEqual()`: Compare rules for equality
|
||||
|
||||
## Rule Types
|
||||
- Length-based rules (predecessor, successor)
|
||||
- Character-based rules (predecessor, successor)
|
||||
- Category-based rules
|
||||
|
||||
## Dependencies
|
||||
- Requires `workspaceStructure` and `formulas` modules
|
||||
- Uses `logging` for debug output
|
||||
- Used by the main `copycat` module
|
||||
|
||||
## Notes
|
||||
- Rules are evaluated based on conceptual depth and descriptor sharing
|
||||
- Rule strength is calculated using weighted averages
|
||||
- Rules can be translated through concept slippages
|
||||
- The system supports both single-character and length-based transformations
|
||||
- Rules can be incompatible with certain correspondences
|
||||
@ -1,51 +0,0 @@
|
||||
# README_slipnet.md
|
||||
|
||||
## Overview
|
||||
`slipnet.py` implements the Slipnet, a key component of the Copycat system that represents the conceptual network of relationships between different concepts. It manages a network of nodes (concepts) and links (relationships) that are used in analogical reasoning.
|
||||
|
||||
## Core Components
|
||||
- `Slipnet` class: Main class that manages the conceptual network
|
||||
- Network of `Slipnode` objects representing concepts
|
||||
- Network of `Sliplink` objects representing relationships
|
||||
|
||||
## Key Features
|
||||
- Manages a network of conceptual nodes and their relationships
|
||||
- Handles activation spreading between nodes
|
||||
- Supports both slip and non-slip links
|
||||
- Implements various types of relationships:
|
||||
- Letter categories
|
||||
- String positions
|
||||
- Alphabetic positions
|
||||
- Directions
|
||||
- Bond types
|
||||
- Group types
|
||||
- Other relations
|
||||
|
||||
## Node Types
|
||||
- Letters (a-z)
|
||||
- Numbers (1-5)
|
||||
- String positions (leftmost, rightmost, middle, single, whole)
|
||||
- Alphabetic positions (first, last)
|
||||
- Directions (left, right)
|
||||
- Bond types (predecessor, successor, sameness)
|
||||
- Group types (predecessorGroup, successorGroup, samenessGroup)
|
||||
- Categories (letterCategory, stringPositionCategory, etc.)
|
||||
|
||||
## Link Types
|
||||
- Slip links (lateral connections)
|
||||
- Non-slip links (fixed connections)
|
||||
- Category links (hierarchical connections)
|
||||
- Instance links (specific examples)
|
||||
- Property links (attributes)
|
||||
- Opposite links (antonyms)
|
||||
|
||||
## Dependencies
|
||||
- Requires `slipnode` and `sliplink` modules
|
||||
- Used by the main `copycat` module
|
||||
|
||||
## Notes
|
||||
- The network is initialized with predefined nodes and links
|
||||
- Activation spreads through the network during reasoning
|
||||
- Some nodes are initially clamped to high activation
|
||||
- The network supports both hierarchical and lateral relationships
|
||||
- The system uses conceptual depth to determine link strengths
|
||||
@ -1,51 +0,0 @@
|
||||
# README_temperature.md
|
||||
|
||||
## Overview
|
||||
`temperature.py` implements the Temperature system, a crucial component of the Copycat system that controls the balance between exploration and exploitation during analogical reasoning. It provides various formulas for adjusting probabilities based on the current temperature, which affects how the system makes decisions.
|
||||
|
||||
## Core Components
|
||||
- `Temperature` class: Main class that manages the temperature system
|
||||
- Multiple adjustment formulas for probability modification
|
||||
- Temperature history tracking
|
||||
|
||||
## Key Features
|
||||
- Manages temperature-based control of the reasoning process
|
||||
- Provides multiple formulas for probability adjustment
|
||||
- Supports temperature clamping and unclamping
|
||||
- Tracks temperature history and differences
|
||||
- Allows dynamic switching between adjustment formulas
|
||||
|
||||
## Adjustment Formulas
|
||||
- `original`: Basic temperature-based adjustment
|
||||
- `entropy`: Entropy-based adjustment
|
||||
- `inverse`: Inverse weighted adjustment
|
||||
- `fifty_converge`: Convergence to 0.5
|
||||
- `soft_curve`: Soft curve adjustment
|
||||
- `weighted_soft_curve`: Weighted soft curve
|
||||
- `alt_fifty`: Alternative fifty convergence
|
||||
- `average_alt`: Averaged alternative
|
||||
- `best`: Working best formula
|
||||
- `sbest`: Soft best formula
|
||||
- `pbest`: Parameterized best
|
||||
- `meta`: Meta-level adjustment
|
||||
- `pmeta`: Parameterized meta
|
||||
- `none`: No adjustment
|
||||
|
||||
## Main Methods
|
||||
- `update(value)`: Update temperature value
|
||||
- `clampUntil(when)`: Clamp temperature until specified time
|
||||
- `tryUnclamp(currentTime)`: Attempt to unclamp temperature
|
||||
- `value()`: Get current temperature
|
||||
- `getAdjustedProbability(value)`: Get temperature-adjusted probability
|
||||
- `useAdj(adj)`: Switch to different adjustment formula
|
||||
|
||||
## Dependencies
|
||||
- Uses `math` for mathematical operations
|
||||
- Used by the main `copycat` module
|
||||
|
||||
## Notes
|
||||
- Temperature starts at 100.0 and can be clamped
|
||||
- Lower temperatures encourage more conservative decisions
|
||||
- Higher temperatures allow more exploratory behavior
|
||||
- The system tracks average differences between adjusted and original probabilities
|
||||
- Different adjustment formulas can be used for different reasoning strategies
|
||||
@ -1,42 +0,0 @@
|
||||
# README_workspace.md
|
||||
|
||||
## Overview
|
||||
`workspace.py` implements the Workspace, a central component of the Copycat system that manages the current state of the analogical reasoning process. It maintains the strings being compared, their objects, structures, and the overall state of the reasoning process.
|
||||
|
||||
## Core Components
|
||||
- `Workspace` class: Main class that manages the reasoning workspace
|
||||
- `WorkspaceString` objects for initial, modified, and target strings
|
||||
- Collection of objects and structures (bonds, correspondences, etc.)
|
||||
|
||||
## Key Features
|
||||
- Manages the three strings involved in the analogy (initial, modified, target)
|
||||
- Tracks objects and their relationships
|
||||
- Maintains structures like bonds, correspondences, and rules
|
||||
- Calculates various unhappiness metrics
|
||||
- Updates object values and structure strengths
|
||||
- Manages the temperature-based control system
|
||||
|
||||
## Main Methods
|
||||
- `resetWithStrings(initial, modified, target)`: Initialize workspace with new strings
|
||||
- `updateEverything()`: Update all objects and structures
|
||||
- `getUpdatedTemperature()`: Calculate current temperature
|
||||
- `buildRule(rule)`: Add or replace the current rule
|
||||
- `breakRule()`: Remove the current rule
|
||||
- `buildDescriptions(objekt)`: Add descriptions to an object
|
||||
|
||||
## State Management
|
||||
- Tracks total, intra-string, and inter-string unhappiness
|
||||
- Maintains lists of objects and structures
|
||||
- Manages the current rule and final answer
|
||||
- Tracks changed objects and their correspondences
|
||||
|
||||
## Dependencies
|
||||
- Requires `formulas`, `bond`, `correspondence`, `letter`, and `workspaceString` modules
|
||||
- Used by the main `copycat` module
|
||||
|
||||
## Notes
|
||||
- The workspace is the central state container for the reasoning process
|
||||
- Unhappiness metrics guide the temperature-based control system
|
||||
- The system supports both rule-based and correspondence-based reasoning
|
||||
- Objects can have multiple descriptions and relationships
|
||||
- The workspace maintains the final answer when reasoning is complete
|
||||
Reference in New Issue
Block a user