Implement neural-symbolic worker with AtomSpace-inspired cognitive architecture

README.md

@@ -86,6 +86,7 @@ Racket's unique capabilities make it ideal for cognitive architecture research:
 - Build symbolic reasoning systems with S-expression knowledge graphs
 - Create neural-symbolic hybrid systems via FFI
 - Explore meta-learning through self-modifying code
+- **NEW: Neural-Symbolic Worker** - Integrated perception-reasoning-action-learning cycle with AtomSpace-inspired knowledge representation
 
 **For Cognitive Scientists:**
 - Model 4E cognition (Embodied, Embedded, Enacted, Extended)
@@ -98,6 +99,7 @@ Racket's unique capabilities make it ideal for cognitive architecture research:
 - Type-safe reasoning with gradual typing
 - Distributed processing with Racket places
 - Interactive development with DrRacket
+- **NEW: Hybrid reasoning** - Combine symbolic pattern matching with neural embeddings
 
 ## Quick Start
 
@@ -112,10 +114,45 @@ cd kracket
 
 # Run a cognitive example
 racket examples/cognitive-synergy/simple-cognitive-loop.rkt
+
+# Run the neural-symbolic worker demo
+racket examples/neural-symbolic/demo.rkt
 ```
 
 ### For Exploration
 
+**Cognitive Synergy Examples:**
+```bash
+# Multi-agent systems
+racket examples/cognitive-synergy/multi-agent-system.rkt
+
+# Meta-learning demonstration
+racket examples/cognitive-synergy/meta-learning-demo.rkt
+
+# Knowledge graph reasoning
+racket examples/cognitive-synergy/knowledge-graph-reasoning.rkt
+```
+
+**Neural-Symbolic Integration:**
+```racket
+#lang racket
+(require "examples/neural-symbolic/neural-worker.rkt")
+
+;; Create a neural-symbolic worker
+(define worker (make-neural-worker))
+
+;; Add symbolic knowledge
+(worker-add-knowledge worker '(concept dog))
+(worker-add-knowledge worker '(concept animal))
+
+;; Hybrid inference (symbolic + neural)
+(worker-process worker '(infer (isa dog animal)))
+
+;; Neural similarity computation
+(worker-process worker '(similar dog))
+```
+
+**Traditional Cognitive Loop:**
 ```racket
 #lang racket
 
@@ -135,6 +172,19 @@ racket examples/cognitive-synergy/simple-cognitive-loop.rkt
      (optimize-at-compile-time strategy)]))
 ```
 
+### Neural-Symbolic Worker Configuration
+
+The repository includes a **neural-symbolic worker** configured in `neural-worker-d.json`:
+
+- **Architecture**: Bidirectional neural-symbolic integration
+- **Symbolic Layer**: AtomSpace-inspired knowledge representation
+- **Neural Layer**: 128-dimensional embeddings with cosine similarity
+- **Cognitive Cycle**: Perception → Reasoning → Action → Learning
+- **Capabilities**: Pattern matching, forward chaining, hybrid inference
+- **Meta-Cognition**: Self-reflection and adaptive strategy selection
+
+See `examples/neural-symbolic/README.md` for detailed documentation.
+
 ### For Integration
 
 To integrate or update repositories from the Racket organization:

examples/neural-symbolic/README.md

@@ -0,0 +1,219 @@
+# Neural-Symbolic Worker Examples
+
+This directory contains the implementation of a **neural-symbolic cognitive worker** that integrates symbolic reasoning with neural network embeddings, demonstrating cognitive synergy principles in the Racket substrate.
+
+## Overview
+
+The neural-symbolic worker embodies the core principles of hybrid AI, combining:
+
+- **Symbolic AI**: Pattern matching, logical inference, knowledge representation
+- **Neural Networks**: Distributed embeddings, similarity-based reasoning
+- **Cognitive Architecture**: Perception-Reasoning-Action-Learning cycle
+- **Meta-Cognition**: Self-reflection and adaptive learning strategies
+
+## Architecture
+
+```
+Neural-Symbolic Worker
+│
+├── Symbolic Layer (AtomSpace-inspired)
+│   ├── Concepts (ConceptNode)
+│   ├── Predicates (PredicateNode)
+│   └── Relations (InheritanceLink, EvaluationLink)
+│
+├── Neural Layer (Embeddings)
+│   ├── Atom Embeddings (128-dimensional vectors)
+│   ├── Similarity Computation (cosine similarity)
+│   └── Gradient-Based Learning
+│
+└── Integration Layer
+    ├── Hybrid Inference (weighted combination)
+    ├── Bidirectional Translation
+    └── Synergy Detection
+```
+
+## Components
+
+### Core Module: `neural-worker.rkt`
+
+The main implementation of the neural-symbolic worker with:
+
+- **AtomSpace**: Symbolic knowledge store (hash-based)
+- **Embeddings**: Neural vector representations
+- **Hybrid Processing**: Combines symbolic and neural reasoning
+- **Learning**: Updates both symbolic and neural components
+
+**Key Functions:**
+- `make-neural-worker` - Create a new worker instance
+- `worker-add-knowledge` - Add symbolic knowledge
+- `worker-process` - Process queries and inferences
+- `worker-learn` - Learn from examples
+- `worker-get-embedding` - Retrieve neural embeddings
+
+### Cognitive Cycle Modules
+
+#### `perception.rkt`
+Converts sensory input into internal cognitive representations:
+- Text parsing
+- Symbolic perception
+- Feature extraction
+
+#### `reasoning.rkt`
+Implements hybrid symbolic-neural reasoning:
+- Forward chaining (symbolic)
+- Backward chaining (symbolic)
+- Embedding-based confidence (neural)
+- Hybrid inference combination
+
+#### `action.rkt`
+Generates actions based on reasoning results:
+- Action selection based on confidence
+- Action execution
+- Context-aware behavior
+
+#### `learning.rkt`
+Learning mechanisms for both paradigms:
+- Symbolic knowledge updates
+- Neural embedding adjustments
+- Error-based learning
+- Meta-learning strategies
+
+## Configuration
+
+The worker is configured via `neural-worker-d.json`:
+
+```json
+{
+  "name": "neural-symbolic-worker",
+  "architecture": {
+    "paradigm": "neural-symbolic-integration",
+    "substrate": "racket-opencog-bridge"
+  },
+  "capabilities": {
+    "symbolic_reasoning": true,
+    "neural_processing": true,
+    "integration": "bidirectional"
+  }
+}
+```
+
+## Usage
+
+### Running the Demo
+
+```bash
+racket demo.rkt
+```
+
+This demonstrates:
+1. Worker creation and initialization
+2. Symbolic knowledge addition
+3. Perception processing
+4. Knowledge base queries
+5. Hybrid reasoning
+6. Neural embeddings
+7. Similarity computation
+8. Learning mechanisms
+9. Complete cognitive cycle
+10. Worker statistics
+11. Meta-cognitive reflection
+
+### Using in Your Code
+
+```racket
+#lang racket
+(require "neural-worker.rkt")
+
+;; Create worker
+(define worker (make-neural-worker))
+
+;; Add knowledge
+(worker-add-knowledge worker '(concept dog))
+(worker-add-knowledge worker '(concept animal))
+(worker-add-knowledge worker '(relation isa dog animal))
+
+;; Query
+(worker-process worker '(query (all-concepts)))
+
+;; Infer
+(worker-process worker '(infer (isa dog animal)))
+
+;; Learn
+(worker-learn worker '(concept cat) '(meows))
+```
+
+## Cognitive Synergy Demonstrated
+
+### 1. Symbolic-Neural Synergy
+- Symbolic reasoning provides interpretability
+- Neural embeddings enable similarity-based reasoning
+- Combined confidence improves decision quality
+
+### 2. Multi-Level Processing
+- Low-level: Vector operations on embeddings
+- Mid-level: Pattern matching and rule application
+- High-level: Meta-cognitive strategy selection
+
+### 3. Bidirectional Translation
+- Concepts → Embeddings (symbolic to neural)
+- Similarity → Inference (neural to symbolic)
+- Continuous knowledge flow
+
+### 4. Emergent Capabilities
+- Knowledge generalization through embeddings
+- Pattern recognition through symbolic rules
+- Adaptive learning through meta-cognition
+
+## Integration with Org-Racket
+
+This neural-symbolic worker integrates with the broader Org-Racket cognitive architecture:
+
+- **AtomSpace-inspired**: Compatible with OpenCog concepts
+- **Racket-native**: Uses language features (pattern matching, structs)
+- **Modular**: Clean separation of concerns
+- **Extensible**: Easy to add new reasoning strategies
+
+## Testing
+
+Each module includes tests. Run them with:
+
+```bash
+# Test individual modules
+raco test neural-worker.rkt
+raco test perception.rkt
+raco test reasoning.rkt
+raco test action.rkt
+raco test learning.rkt
+
+# Test all
+raco test .
+```
+
+## Future Enhancements
+
+- [ ] FFI integration with PyTorch/TensorFlow
+- [ ] Attention mechanism (ECAN-inspired)
+- [ ] Probabilistic Logic Networks (PLN)
+- [ ] Distributed processing with Racket places
+- [ ] Real-time visualization of cognitive processes
+- [ ] Advanced meta-learning strategies
+
+## Theoretical Foundation
+
+This implementation is inspired by:
+
+- **OpenCog**: AtomSpace, ECAN, PLN concepts
+- **CogPrime**: Cognitive synergy principles
+- **Neural-Symbolic AI**: Hybrid reasoning paradigms
+- **4E Cognition**: Embodied, Embedded, Enacted, Extended
+
+## References
+
+- OpenCog Framework: https://opencog.org/
+- CogPrime Theory: "Engineering General Intelligence" (Goertzel et al.)
+- Neural-Symbolic Integration: Garcez, Lamb, Gabbay
+- Racket Language: https://racket-lang.org/
+
+---
+
+**"Where symbols meet vectors, cognition emerges."**

examples/neural-symbolic/action.rkt

@@ -0,0 +1,82 @@
+#lang racket
+
+;; Action Module for Neural-Symbolic Worker
+;; Generates actions based on reasoning results
+
+(require racket/match)
+
+(provide act
+         generate-action
+         execute-action
+         get-assoc-value)
+
+;; Helper: safely get value from association list
+(define (get-assoc-value key alist default)
+  (define pair (assoc key alist))
+  (if pair (cadr pair) default))
+
+;; Main action function
+(define (act reasoning-result)
+  (match reasoning-result
+    [(list 'hybrid-inference args ...)
+     (generate-action-from-inference reasoning-result)]
+
+    [(list 'inferred conclusions)
+     (generate-action-from-conclusion conclusions)]
+
+    [_ (list 'action 'observe 'no-action-needed)]))
+
+;; Generate action from inference result
+(define (generate-action-from-inference inference)
+  (define confidence-value 
+    (get-assoc-value 'combined-confidence inference 0.5))
+
+  (cond
+    [(> confidence-value 0.8)
+     (list 'action 'assert 'high-confidence)]
+    [(> confidence-value 0.5)
+     (list 'action 'explore 'medium-confidence)]
+    [else
+     (list 'action 'learn 'low-confidence)]))
+
+;; Generate action from conclusion
+(define (generate-action-from-conclusion conclusions)
+  (if (list? conclusions)
+      (list 'action 'apply (car conclusions))
+      (list 'action 'report conclusions)))
+
+;; General action generator
+(define (generate-action context intent)
+  (list 'action
+        'intent intent
+        'context context
+        'timestamp (current-inexact-milliseconds)))
+
+;; Execute an action (for demonstration)
+(define (execute-action action)
+  (match action
+    [(list 'action type args ...)
+     (list 'executed type 'with-args args 'success #t)]
+    [_ (list 'executed 'unknown 'success #f)]))
+
+;; Module test
+(module+ test
+  (require rackunit)
+
+  (test-case "action from inference"
+    (define inference '(hybrid-inference 
+                       symbolic (inferred test)
+                       neural-confidence 0.9
+                       combined-confidence 0.85))
+    (define action (act inference))
+    (check-equal? (car action) 'action)
+    (check-equal? (cadr action) 'assert))
+
+  (test-case "action generation"
+    (define action (generate-action 'test-context 'learn))
+    (check-equal? (car action) 'action))
+
+  (test-case "action execution"
+    (define action '(action assert high-confidence))
+    (define result (execute-action action))
+    (check-equal? (car result) 'executed)))