From aade226dae93b418c559e5db73f440d0080af5f7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 28 Dec 2025 21:45:10 +0000
Subject: [PATCH 1/5] Initial plan


From 057d63859ec4fe3a2369a8a987b3455862a159fb Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 28 Dec 2025 21:55:47 +0000
Subject: [PATCH 2/5] Implement neural-symbolic worker configuration and
 modules

Co-authored-by: drzo <15202748+drzo@users.noreply.github.com>
---
 examples/neural-symbolic/README.md         | 219 ++++++++++++++++++++
 examples/neural-symbolic/action.rkt        |  75 +++++++
 examples/neural-symbolic/demo.rkt          | 120 +++++++++++
 examples/neural-symbolic/learning.rkt      |  99 ++++++++++
 examples/neural-symbolic/neural-worker.rkt | 220 +++++++++++++++++++++
 examples/neural-symbolic/perception.rkt    |  98 +++++++++
 examples/neural-symbolic/reasoning.rkt     | 103 ++++++++++
 neural-worker-d.json                       | 110 ++++++++++-
 8 files changed, 1043 insertions(+), 1 deletion(-)
 create mode 100644 examples/neural-symbolic/README.md
 create mode 100644 examples/neural-symbolic/action.rkt
 create mode 100644 examples/neural-symbolic/demo.rkt
 create mode 100644 examples/neural-symbolic/learning.rkt
 create mode 100644 examples/neural-symbolic/neural-worker.rkt
 create mode 100644 examples/neural-symbolic/perception.rkt
 create mode 100644 examples/neural-symbolic/reasoning.rkt

diff --git a/examples/neural-symbolic/README.md b/examples/neural-symbolic/README.md
new file mode 100644
index 0000000..0883ec7
--- /dev/null
+++ b/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."**
diff --git a/examples/neural-symbolic/action.rkt b/examples/neural-symbolic/action.rkt
new file mode 100644
index 0000000..e9f6113
--- /dev/null
+++ b/examples/neural-symbolic/action.rkt
@@ -0,0 +1,75 @@
+#lang racket
+
+;; Action Module for Neural-Symbolic Worker
+;; Generates actions based on reasoning results
+
+(require racket/match)
+
+(provide act
+         generate-action
+         execute-action)
+
+;; 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 (assoc 'combined-confidence inference))
+  
+  (cond
+    [(and confidence (> (cadr confidence) 0.8))
+     (list 'action 'assert 'high-confidence)]
+    [(and confidence (> (cadr confidence) 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)))
diff --git a/examples/neural-symbolic/demo.rkt b/examples/neural-symbolic/demo.rkt
new file mode 100644
index 0000000..8209d1d
--- /dev/null
+++ b/examples/neural-symbolic/demo.rkt
@@ -0,0 +1,120 @@
+#lang racket
+
+;; Neural-Symbolic Worker Demonstration
+;; Shows the complete cognitive cycle with neural-symbolic integration
+
+(require "neural-worker.rkt"
+         "perception.rkt"
+         "reasoning.rkt"
+         "action.rkt"
+         "learning.rkt")
+
+(printf "=== Neural-Symbolic Worker Demo ===\n\n")
+
+;; Create a neural-symbolic worker
+(printf "1. Creating neural-symbolic worker...\n")
+(define worker (make-neural-worker))
+(printf "   ✓ Worker created\n\n")
+
+;; Add some initial knowledge (symbolic)
+(printf "2. Adding symbolic knowledge to atomspace...\n")
+(worker-add-knowledge worker '(concept dog))
+(worker-add-knowledge worker '(concept cat))
+(worker-add-knowledge worker '(concept animal))
+(worker-add-knowledge worker '(relation isa dog animal))
+(worker-add-knowledge worker '(relation isa cat animal))
+(printf "   ✓ Added concepts: dog, cat, animal\n")
+(printf "   ✓ Added relations: dog->animal, cat->animal\n\n")
+
+;; Demonstrate perception
+(printf "3. Perception: Processing sensory input...\n")
+(define sensory-input '(text "The dog barks"))
+(define percept (parse-sensory-input sensory-input))
+(printf "   Input: ~a\n" sensory-input)
+(printf "   Percept: ~a\n\n" percept)
+
+;; Query the knowledge base
+(printf "4. Querying knowledge base...\n")
+(define concepts (worker-process worker '(query (all-concepts))))
+(printf "   All concepts: ~a\n\n" concepts)
+
+;; Demonstrate hybrid reasoning
+(printf "5. Hybrid Reasoning: Symbolic + Neural...\n")
+(define inference-result (worker-process worker '(infer (isa dog animal))))
+(printf "   Query: (isa dog animal)\n")
+(printf "   Result: ~a\n\n" inference-result)
+
+;; Demonstrate neural embeddings
+(printf "6. Neural Embeddings: Vector representations...\n")
+(define dog-embedding (worker-get-embedding worker 'dog))
+(printf "   Dog embedding (first 5 dims): ~a\n" 
+        (vector-take dog-embedding 5))
+
+(define cat-embedding (worker-get-embedding worker 'cat))
+(printf "   Cat embedding (first 5 dims): ~a\n\n" 
+        (vector-take cat-embedding 5))
+
+;; Demonstrate similarity computation
+(printf "7. Neural Similarity: Finding similar concepts...\n")
+(define similarities (worker-process worker '(similar dog)))
+(printf "   Similar to 'dog': ~a\n\n" similarities)
+
+;; Demonstrate learning
+(printf "8. Learning: Adding new knowledge and adjusting embeddings...\n")
+(worker-learn worker '(concept bird) '(flies))
+(define bird-embedding (worker-get-embedding worker 'bird))
+(printf "   ✓ Learned concept 'bird'\n")
+(printf "   Bird embedding (first 5 dims): ~a\n\n" 
+        (vector-take bird-embedding 5))
+
+;; Complete cognitive cycle demonstration
+(printf "9. Complete Cognitive Cycle:\n")
+(printf "   Perception -> Reasoning -> Action -> Learning\n\n")
+
+(define (cognitive-cycle input)
+  ;; Perception
+  (printf "   [Perception] Processing: ~a\n" input)
+  (define perceived (perceive input))
+  
+  ;; Reasoning
+  (printf "   [Reasoning] Applying inference...\n")
+  (define kb '((concept dog) (concept animal) (isa dog animal)))
+  (define reasoning-result (hybrid-reason kb perceived))
+  
+  ;; Action
+  (printf "   [Action] Generating action...\n")
+  (define action-result (act reasoning-result))
+  
+  ;; Learning
+  (printf "   [Learning] Updating knowledge...\n")
+  (define learning-result (learn '() `(positive-example ,perceived) 'good))
+  
+  (printf "\n   Cycle complete!\n")
+  (printf "   - Perceived: ~a\n" perceived)
+  (printf "   - Reasoned: ~a\n" (cadr (assoc 'symbolic reasoning-result)))
+  (printf "   - Action: ~a\n" action-result)
+  (printf "   - Learned: ~a\n\n" learning-result))
+
+(cognitive-cycle '(symbolic (concept robot)))
+
+;; Display worker statistics
+(printf "10. Worker Statistics:\n")
+(define stats (neural-worker-stats worker))
+(printf "   - Processed: ~a operations\n" (hash-ref stats 'processed))
+(printf "   - Learned: ~a examples\n" (hash-ref stats 'learned))
+(printf "   - Synergies: ~a hybrid inferences\n\n" (hash-ref stats 'synergies))
+
+;; Demonstrate meta-cognitive capabilities
+(printf "11. Meta-Cognitive Reflection:\n")
+(define performance-history '(0.6 0.7 0.75 0.8))
+(define meta-learning-result (meta-learn '() performance-history))
+(printf "   Performance history: ~a\n" performance-history)
+(printf "   Meta-learning: ~a\n" meta-learning-result)
+(printf "   Strategy: ~a\n\n" (cadr (assoc 'strategy meta-learning-result)))
+
+(printf "=== Demo Complete ===\n")
+(printf "\nKey Insights:\n")
+(printf "• Symbolic reasoning provides interpretable knowledge structures\n")
+(printf "• Neural embeddings enable similarity-based reasoning\n")
+(printf "• Hybrid approach combines strengths of both paradigms\n")
+(printf "• Cognitive synergy emerges from component integration\n")
diff --git a/examples/neural-symbolic/learning.rkt b/examples/neural-symbolic/learning.rkt
new file mode 100644
index 0000000..1fef1ba
--- /dev/null
+++ b/examples/neural-symbolic/learning.rkt
@@ -0,0 +1,99 @@
+#lang racket
+
+;; Learning Module for Neural-Symbolic Worker
+;; Implements learning mechanisms for both symbolic and neural components
+
+(require racket/match)
+
+(provide learn
+         update-knowledge
+         adjust-embeddings
+         meta-learn)
+
+;; Main learning function
+(define (learn worker-state experience feedback)
+  (match experience
+    [(list 'positive-example example)
+     (update-knowledge worker-state example #t)]
+    
+    [(list 'negative-example example)
+     (update-knowledge worker-state example #f)]
+    
+    [(list 'correction expected actual)
+     (learn-from-error worker-state expected actual)]
+    
+    [_ (update-knowledge worker-state experience #t)]))
+
+;; Update symbolic knowledge base
+(define (update-knowledge state knowledge positive?)
+  (if positive?
+      (list 'learned 'added knowledge)
+      (list 'learned 'noted-negative knowledge)))
+
+;; Adjust neural embeddings based on feedback
+(define (adjust-embeddings embeddings concept feedback learning-rate)
+  (define embedding (hash-ref embeddings concept #f))
+  
+  (if embedding
+      (let ([adjusted (for/vector ([v (in-vector embedding)])
+                        (+ v (* learning-rate feedback (- (random) 0.5))))])
+        (hash-set embeddings concept adjusted)
+        (list 'adjusted concept 'with-feedback feedback))
+      (list 'no-embedding-found concept)))
+
+;; Learn from prediction errors
+(define (learn-from-error state expected actual)
+  (define error-signal (compute-error expected actual))
+  (list 'error-correction
+        'error error-signal
+        'adjustment 'backpropagate))
+
+;; Compute error signal
+(define (compute-error expected actual)
+  (cond
+    [(and (number? expected) (number? actual))
+     (- expected actual)]
+    [(equal? expected actual) 0]
+    [else 1]))
+
+;; Meta-learning: learning about learning
+(define (meta-learn learning-history performance-metrics)
+  (define avg-performance
+    (if (null? performance-metrics)
+        0.5
+        (/ (apply + performance-metrics) (length performance-metrics))))
+  
+  (list 'meta-learning
+        'strategy (if (> avg-performance 0.7) 'exploit 'explore)
+        'performance avg-performance
+        'recommendation (if (> avg-performance 0.7)
+                           'continue-current-strategy
+                           'try-alternative-approach)))
+
+;; Gradient-based learning (simplified)
+(define (gradient-descent parameters gradients learning-rate)
+  (for/list ([param parameters]
+             [grad gradients])
+    (- param (* learning-rate grad))))
+
+;; Module test
+(module+ test
+  (require rackunit)
+  
+  (test-case "positive learning"
+    (define result (learn '() '(positive-example (concept test)) 'good))
+    (check-equal? (car result) 'learned))
+  
+  (test-case "error correction"
+    (define result (learn '() '(correction expected actual) 'error))
+    (check-equal? (car result) 'error-correction))
+  
+  (test-case "embedding adjustment"
+    (define embeddings (hash 'dog (vector 0.1 0.2 0.3)))
+    (define result (adjust-embeddings embeddings 'dog 0.5 0.01))
+    (check-equal? (car result) 'adjusted))
+  
+  (test-case "meta-learning"
+    (define result (meta-learn '() '(0.6 0.7 0.8)))
+    (check-equal? (car result) 'meta-learning)
+    (check-true (assoc 'strategy result))))
diff --git a/examples/neural-symbolic/neural-worker.rkt b/examples/neural-symbolic/neural-worker.rkt
new file mode 100644
index 0000000..b820071
--- /dev/null
+++ b/examples/neural-symbolic/neural-worker.rkt
@@ -0,0 +1,220 @@
+#lang racket
+
+;; Neural-Symbolic Worker Implementation
+;; Integrates symbolic reasoning with neural network embeddings
+;; for Racket cognitive architecture
+
+(require racket/match
+         racket/contract
+         math/matrix)
+
+(provide (contract-out
+          [neural-worker? (-> any/c boolean?)]
+          [make-neural-worker (-> neural-worker?)]
+          [worker-process (-> neural-worker? any/c any/c)]
+          [worker-learn (-> neural-worker? any/c any/c void?)]
+          [worker-get-embedding (-> neural-worker? symbol? (or/c vector? #f))]
+          [worker-add-knowledge (-> neural-worker? any/c void?)]))
+
+;; Neural-Symbolic Worker Structure
+(struct neural-worker
+  ([atomspace (hash)]          ; Symbolic knowledge store
+   [embeddings (hash)]         ; Neural embeddings
+   [config (hash)]             ; Configuration
+   [stats (hash)])             ; Performance statistics
+  #:mutable
+  #:transparent)
+
+;; Create a new neural-symbolic worker
+(define (make-neural-worker)
+  (neural-worker
+   (make-hash)  ; atomspace
+   (make-hash)  ; embeddings
+   (hash 'embedding-dim 128
+         'learning-rate 0.001
+         'symbolic-weight 0.6
+         'neural-weight 0.4)
+   (hash 'processed 0
+         'learned 0
+         'synergies 0)))
+
+;; Atom representation for symbolic processing
+(struct atom (type name) #:transparent)
+(struct link (type outgoing) #:transparent)
+
+;; Add knowledge to the worker's atomspace
+(define (worker-add-knowledge worker knowledge)
+  (match knowledge
+    [(list 'concept name)
+     (hash-set! (neural-worker-atomspace worker) 
+                name 
+                (atom 'ConceptNode name))]
+    [(list 'relation pred subj obj)
+     (define key (list pred subj obj))
+     (hash-set! (neural-worker-atomspace worker)
+                key
+                (link 'EvaluationLink (list pred subj obj)))]
+    [_ (void)])
+  
+  ;; Initialize embedding for new concept
+  (when (and (list? knowledge) 
+             (eq? (car knowledge) 'concept))
+    (define name (cadr knowledge))
+    (unless (hash-has-key? (neural-worker-embeddings worker) name)
+      (hash-set! (neural-worker-embeddings worker)
+                 name
+                 (random-embedding (hash-ref (neural-worker-config worker) 
+                                             'embedding-dim))))))
+
+;; Generate random embedding vector
+(define (random-embedding dim)
+  (for/vector ([i (in-range dim)])
+    (* 0.1 (- (random) 0.5))))
+
+;; Get embedding for a concept
+(define (worker-get-embedding worker name)
+  (hash-ref (neural-worker-embeddings worker) name #f))
+
+;; Process input through cognitive cycle
+(define (worker-process worker input)
+  ;; Update statistics
+  (hash-set! (neural-worker-stats worker) 
+             'processed 
+             (+ 1 (hash-ref (neural-worker-stats worker) 'processed)))
+  
+  (match input
+    ;; Query pattern: retrieve knowledge
+    [(list 'query pattern)
+     (symbolic-query worker pattern)]
+    
+    ;; Inference pattern: apply reasoning
+    [(list 'infer premise)
+     (hybrid-inference worker premise)]
+    
+    ;; Similarity pattern: neural processing
+    [(list 'similar concept)
+     (neural-similarity worker concept)]
+    
+    ;; Default: return input
+    [_ input]))
+
+;; Symbolic query processing
+(define (symbolic-query worker pattern)
+  (define atomspace (neural-worker-atomspace worker))
+  (match pattern
+    [(list 'all-concepts)
+     (for/list ([(k v) (in-hash atomspace)])
+       (if (atom? v) (atom-name v) k))]
+    
+    [(list 'concept name)
+     (hash-ref atomspace name #f)]
+    
+    [_ '()]))
+
+;; Hybrid symbolic-neural inference
+(define (hybrid-inference worker premise)
+  (define sym-weight (hash-ref (neural-worker-config worker) 'symbolic-weight))
+  (define neu-weight (hash-ref (neural-worker-config worker) 'neural-weight))
+  
+  ;; Track synergy
+  (hash-set! (neural-worker-stats worker)
+             'synergies
+             (+ 1 (hash-ref (neural-worker-stats worker) 'synergies)))
+  
+  ;; Symbolic component: pattern matching
+  (define symbolic-result
+    (match premise
+      [(list 'isa x 'animal)
+       (list 'has-property x 'alive)]
+      [_ premise]))
+  
+  ;; Neural component: embedding-based reasoning
+  (define neural-result
+    (if (and (list? premise) (>= (length premise) 2))
+        (let ([concept (cadr premise)])
+          (if (hash-has-key? (neural-worker-embeddings worker) concept)
+              (list 'embedding-confidence 
+                    (vector-ref (worker-get-embedding worker concept) 0))
+              '(confidence 0.5)))
+        '(confidence 0.5)))
+  
+  ;; Combine symbolic and neural results
+  (list 'inference
+        'symbolic symbolic-result
+        'neural neural-result
+        'weights (list sym-weight neu-weight)))
+
+;; Neural similarity computation
+(define (neural-similarity worker concept)
+  (define embedding (worker-get-embedding worker concept))
+  (if embedding
+      (let ([similar-concepts
+             (for/list ([(name emb) (in-hash (neural-worker-embeddings worker))])
+               (cons name (cosine-similarity embedding emb)))])
+        (take (sort similar-concepts > #:key cdr) 
+              (min 5 (length similar-concepts))))
+      '()))
+
+;; Cosine similarity between vectors
+(define (cosine-similarity v1 v2)
+  (define dot-product
+    (for/sum ([a (in-vector v1)]
+              [b (in-vector v2)])
+      (* a b)))
+  (define mag1 (sqrt (for/sum ([a (in-vector v1)]) (* a a))))
+  (define mag2 (sqrt (for/sum ([b (in-vector v2)]) (* b b))))
+  (if (and (> mag1 0) (> mag2 0))
+      (/ dot-product (* mag1 mag2))
+      0.0))
+
+;; Learning from examples
+(define (worker-learn worker example expected)
+  ;; Update statistics
+  (hash-set! (neural-worker-stats worker)
+             'learned
+             (+ 1 (hash-ref (neural-worker-stats worker) 'learned)))
+  
+  ;; Symbolic learning: add to atomspace
+  (worker-add-knowledge worker example)
+  
+  ;; Neural learning: adjust embeddings (simplified)
+  (when (and (list? example) (eq? (car example) 'concept))
+    (define name (cadr example))
+    (define embedding (worker-get-embedding worker name))
+    (when embedding
+      (define learning-rate (hash-ref (neural-worker-config worker) 'learning-rate))
+      ;; Simple embedding adjustment
+      (hash-set! (neural-worker-embeddings worker)
+                 name
+                 (for/vector ([v (in-vector embedding)])
+                   (+ v (* learning-rate (- (random) 0.5))))))))
+
+;; Module test
+(module+ test
+  (require rackunit)
+  
+  (define worker (make-neural-worker))
+  
+  (test-case "worker creation"
+    (check-true (neural-worker? worker)))
+  
+  (test-case "knowledge addition"
+    (worker-add-knowledge worker '(concept dog))
+    (worker-add-knowledge worker '(concept cat))
+    (define result (worker-process worker '(query (all-concepts))))
+    (check-true (member 'dog result)))
+  
+  (test-case "embedding retrieval"
+    (define embedding (worker-get-embedding worker 'dog))
+    (check-true (vector? embedding))
+    (check-equal? (vector-length embedding) 128))
+  
+  (test-case "hybrid inference"
+    (worker-add-knowledge worker '(concept animal))
+    (define result (worker-process worker '(infer (isa dog animal))))
+    (check-true (list? result))
+    (check-equal? (car result) 'inference))
+  
+  (test-case "learning"
+    (worker-learn worker '(concept bird) '(flies))
+    (check-true (hash-has-key? (neural-worker-embeddings worker) 'bird))))
diff --git a/examples/neural-symbolic/perception.rkt b/examples/neural-symbolic/perception.rkt
new file mode 100644
index 0000000..64f03f8
--- /dev/null
+++ b/examples/neural-symbolic/perception.rkt
@@ -0,0 +1,98 @@
+#lang racket
+
+;; Perception Module for Neural-Symbolic Worker
+;; Processes sensory input and converts to internal representations
+
+(require racket/match)
+
+(provide perceive
+         parse-sensory-input
+         extract-features)
+
+;; Main perception function
+(define (perceive input)
+  (match input
+    ;; Text-based perception
+    [(list 'text text-data)
+     (perceive-text text-data)]
+    
+    ;; Symbolic perception
+    [(list 'symbolic symbolic-data)
+     (perceive-symbolic symbolic-data)]
+    
+    ;; Structured data perception
+    [(list 'structured data)
+     (perceive-structured data)]
+    
+    ;; Default: pass through as symbolic
+    [_ (list 'concept input)]))
+
+;; Perceive text input
+(define (perceive-text text)
+  (define words (string-split text))
+  (for/list ([word words])
+    (list 'concept (string->symbol word))))
+
+;; Perceive symbolic input
+(define (perceive-symbolic data)
+  (match data
+    [(list pred subj obj)
+     (list 'relation pred subj obj)]
+    [concept
+     (list 'concept concept)]))
+
+;; Perceive structured data
+(define (perceive-structured data)
+  (cond
+    [(hash? data)
+     (for/list ([(k v) (in-hash data)])
+       (list 'property k v))]
+    [(list? data)
+     (map perceive data)]
+    [else (list 'concept data)]))
+
+;; Parse sensory input into cognitive representation
+(define (parse-sensory-input input)
+  (define perceived (perceive input))
+  (list 'percept
+        'raw input
+        'processed perceived
+        'timestamp (current-inexact-milliseconds)))
+
+;; Extract features from perceived data
+(define (extract-features percept)
+  (match percept
+    [(list 'percept args ...)
+     (define processed (assoc 'processed (cdr percept)))
+     (if processed
+         (list 'features
+               'count (if (list? (cadr processed)) 
+                         (length (cadr processed)) 
+                         1)
+               'type (if (list? (cadr processed))
+                        (car (cadr processed))
+                        'unknown))
+         '(features empty))]
+    [_ '(features empty)]))
+
+;; Module test
+(module+ test
+  (require rackunit)
+  
+  (test-case "text perception"
+    (define result (perceive '(text "hello world")))
+    (check-equal? (length result) 2)
+    (check-equal? (car (car result)) 'concept))
+  
+  (test-case "symbolic perception"
+    (define result (perceive '(symbolic (isa dog animal))))
+    (check-equal? (car result) 'relation))
+  
+  (test-case "sensory parsing"
+    (define result (parse-sensory-input '(text "test")))
+    (check-equal? (car result) 'percept))
+  
+  (test-case "feature extraction"
+    (define percept (parse-sensory-input '(symbolic (concept test))))
+    (define features (extract-features percept))
+    (check-equal? (car features) 'features)))
diff --git a/examples/neural-symbolic/reasoning.rkt b/examples/neural-symbolic/reasoning.rkt
new file mode 100644
index 0000000..60121cd
--- /dev/null
+++ b/examples/neural-symbolic/reasoning.rkt
@@ -0,0 +1,103 @@
+#lang racket
+
+;; Reasoning Module for Neural-Symbolic Worker
+;; Implements hybrid symbolic-neural reasoning
+
+(require racket/match)
+
+(provide reason
+         forward-chain
+         backward-chain
+         hybrid-reason)
+
+;; Main reasoning function
+(define (reason knowledge-base query strategy)
+  (match strategy
+    ['forward (forward-chain knowledge-base query)]
+    ['backward (backward-chain knowledge-base query)]
+    ['hybrid (hybrid-reason knowledge-base query)]
+    [_ (hybrid-reason knowledge-base query)]))
+
+;; Forward chaining inference
+(define (forward-chain kb query)
+  (define results '())
+  
+  ;; Apply rules from knowledge base
+  (for ([fact kb])
+    (match fact
+      [(list 'rule (list 'implies premise conclusion))
+       (when (matches-pattern? premise query)
+         (set! results (cons conclusion results)))]
+      [_ (void)]))
+  
+  (if (null? results)
+      (list 'no-inference query)
+      (list 'inferred results)))
+
+;; Backward chaining inference
+(define (backward-chain kb goal)
+  (define (find-rules-for goal)
+    (filter
+     (lambda (fact)
+       (match fact
+         [(list 'rule (list 'implies _ conclusion))
+          (equal? conclusion goal)]
+         [_ #f]))
+     kb))
+  
+  (define rules (find-rules-for goal))
+  (if (null? rules)
+      (list 'cannot-prove goal)
+      (list 'proved goal 'via (length rules) 'rules)))
+
+;; Hybrid symbolic-neural reasoning
+(define (hybrid-reason kb query)
+  ;; Symbolic component
+  (define symbolic-result (forward-chain kb query))
+  
+  ;; Neural component (simulated - embeddings-based confidence)
+  (define neural-confidence
+    (if (member query kb)
+        0.95
+        0.4))
+  
+  ;; Combine results
+  (list 'hybrid-inference
+        'symbolic symbolic-result
+        'neural-confidence neural-confidence
+        'combined-confidence (if (eq? (car symbolic-result) 'inferred)
+                                 (max neural-confidence 0.8)
+                                 neural-confidence)))
+
+;; Helper: check if premise matches pattern
+(define (matches-pattern? premise pattern)
+  (cond
+    [(and (list? premise) (list? pattern))
+     (and (>= (length premise) 1)
+          (>= (length pattern) 1)
+          (or (equal? (car premise) (car pattern))
+              (eq? (car pattern) '_)))]
+    [else (equal? premise pattern)]))
+
+;; Module test
+(module+ test
+  (require rackunit)
+  
+  (define test-kb
+    '((concept dog)
+      (concept animal)
+      (rule (implies (isa dog animal) (has-property animal alive)))
+      (isa dog animal)))
+  
+  (test-case "forward chaining"
+    (define result (forward-chain test-kb '(isa _ _)))
+    (check-true (list? result)))
+  
+  (test-case "backward chaining"
+    (define result (backward-chain test-kb '(has-property animal alive)))
+    (check-true (list? result)))
+  
+  (test-case "hybrid reasoning"
+    (define result (hybrid-reason test-kb '(concept dog)))
+    (check-equal? (car result) 'hybrid-inference)
+    (check-true (assoc 'combined-confidence result))))
diff --git a/neural-worker-d.json b/neural-worker-d.json
index 8b53aa5..f89cb82 100644
--- a/neural-worker-d.json
+++ b/neural-worker-d.json
@@ -1,3 +1,111 @@
 {
-  "prompt": "I need your help implementing an integration between PyTorch neural network tensor embeddings and the workerd generalized supply chain system.\n\n**Context:**\nThis is a workerd-based supply chain management system located at /home/runner/work/wds/wds with:\n- Actors: suppliers, producers, distributors, wholesalers, retailers, marketplaces\n- Relationships between actors\n- Products and services\n- A dynamic lookup/query system\n- Extension architecture in ext/workerd-ext/\n\n**Problem Statement:**\n\"explore how torch nn tensor embeddings could integrate with workerd generalized supply chain to enable integrated erp+scm flow dynamics analysis for a whole network of entities in real time\"\n\n**What I need you to do:**\n1. Design and implement a neural network tensor embedding system that can:\n   - Represent actors, products, relationships as embeddings\n   - Enable real-time flow dynamics analysis across the network\n   - Integrate with the existing workerd extension architecture\n   - Support ERP+SCM analysis capabilities\n\n2. Create the necessary files including:\n   - A new module for tensor embeddings and neural network integration\n   - Configuration for the embedding system\n   - Integration with the existing supply chain lookup system\n   - Examples demonstrating real-time flow analysis\n   - Tests to validate the integration\n\n3. The implementation should:\n   - Follow workerd extension patterns (as seen in ext/workerd-ext/)\n   - Be minimal and focused on the integration\n   - Use capability-based security model\n   - Support real-time analysis of supply chain dynamics\n   - Enable network-wide ERP+SCM flow analysis\n\n**Key Requirements:**\n- Tensor embeddings for actors, products, relationships\n- Neural network layers for flow dynamics prediction\n- Real-time analysis capabilities\n- Integration with existing workerd bindings\n- Support for whole network analysis\n\nPlease implement this integration completely, including all necessary files, configurations, and tests."
+  "name": "neural-symbolic-worker",
+  "version": "1.0.0",
+  "description": "Neural-symbolic worker for Racket cognitive architecture integration",
+  "type": "cognitive-worker",
+  "architecture": {
+    "paradigm": "neural-symbolic-integration",
+    "substrate": "racket-opencog-bridge",
+    "cognitive_components": [
+      "perception",
+      "reasoning",
+      "action",
+      "learning"
+    ]
+  },
+  "capabilities": {
+    "symbolic_reasoning": {
+      "enabled": true,
+      "engine": "pattern-matching",
+      "inference": "forward-chaining",
+      "knowledge_representation": "atomspace"
+    },
+    "neural_processing": {
+      "enabled": true,
+      "embedding_dimension": 128,
+      "learning_rate": 0.001,
+      "architecture_type": "feed-forward",
+      "activation": "tanh"
+    },
+    "integration": {
+      "mode": "bidirectional",
+      "symbolic_to_neural": "embedding",
+      "neural_to_symbolic": "interpretation",
+      "synergy_enabled": true
+    }
+  },
+  "atomspace": {
+    "atom_types": [
+      "ConceptNode",
+      "PredicateNode",
+      "VariableNode",
+      "InheritanceLink",
+      "EvaluationLink",
+      "ImplicationLink"
+    ],
+    "truth_value_model": "simple",
+    "attention_allocation": "ECAN-inspired"
+  },
+  "neural_embeddings": {
+    "atom_embedding": {
+      "dimension": 128,
+      "initialization": "xavier",
+      "trainable": true
+    },
+    "relationship_embedding": {
+      "dimension": 64,
+      "initialization": "xavier",
+      "trainable": true
+    }
+  },
+  "cognitive_cycle": {
+    "perception": {
+      "module": "examples/neural-symbolic/perception.rkt",
+      "input_format": "s-expression"
+    },
+    "reasoning": {
+      "module": "examples/neural-symbolic/reasoning.rkt",
+      "strategy": "hybrid",
+      "symbolic_weight": 0.6,
+      "neural_weight": 0.4
+    },
+    "action": {
+      "module": "examples/neural-symbolic/action.rkt",
+      "output_format": "s-expression"
+    },
+    "learning": {
+      "module": "examples/neural-symbolic/learning.rkt",
+      "strategy": "gradient-based",
+      "meta_learning": true
+    }
+  },
+  "runtime": {
+    "language": "racket",
+    "required_modules": [
+      "racket/base",
+      "racket/match",
+      "racket/contract",
+      "math/matrix"
+    ],
+    "optional_ffi": [
+      "pytorch",
+      "tensorflow"
+    ]
+  },
+  "meta_cognitive": {
+    "self_modification": true,
+    "optimization_strategy": "compile-time-macros",
+    "reflection_enabled": true,
+    "adaptation_threshold": 0.15
+  },
+  "deployment": {
+    "mode": "local",
+    "concurrency": "racket-places",
+    "resource_management": "attention-based",
+    "monitoring": {
+      "cognitive_metrics": true,
+      "performance_tracking": true,
+      "synergy_analysis": true
+    }
+  }
 }

From 92d5d89e3c3b843366c429110ca71677ae1ffc35 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 28 Dec 2025 21:59:21 +0000
Subject: [PATCH 3/5] Update README with neural-symbolic worker documentation

Co-authored-by: drzo <15202748+drzo@users.noreply.github.com>
---
 README.md | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/README.md b/README.md
index 8e40417..f6745dd 100644
--- a/README.md
+++ b/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:

From 95293436b8828e47ad78da164702fa4641e29aa0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 28 Dec 2025 22:02:24 +0000
Subject: [PATCH 4/5] Fix assoc usage and edge cases in neural-symbolic modules

Co-authored-by: drzo <15202748+drzo@users.noreply.github.com>
---
 examples/neural-symbolic/action.rkt        | 8 +++++---
 examples/neural-symbolic/demo.rkt          | 6 ++++--
 examples/neural-symbolic/neural-worker.rkt | 6 ++++--
 examples/neural-symbolic/reasoning.rkt     | 2 +-
 4 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/examples/neural-symbolic/action.rkt b/examples/neural-symbolic/action.rkt
index e9f6113..4bef03c 100644
--- a/examples/neural-symbolic/action.rkt
+++ b/examples/neural-symbolic/action.rkt
@@ -22,12 +22,14 @@
 
 ;; Generate action from inference result
 (define (generate-action-from-inference inference)
-  (define confidence (assoc 'combined-confidence inference))
+  (define confidence-pair (assoc 'combined-confidence inference))
+  (define confidence-value 
+    (if confidence-pair (cadr confidence-pair) 0.5))
   
   (cond
-    [(and confidence (> (cadr confidence) 0.8))
+    [(> confidence-value 0.8)
      (list 'action 'assert 'high-confidence)]
-    [(and confidence (> (cadr confidence) 0.5))
+    [(> confidence-value 0.5)
      (list 'action 'explore 'medium-confidence)]
     [else
      (list 'action 'learn 'low-confidence)]))
diff --git a/examples/neural-symbolic/demo.rkt b/examples/neural-symbolic/demo.rkt
index 8209d1d..1d6161a 100644
--- a/examples/neural-symbolic/demo.rkt
+++ b/examples/neural-symbolic/demo.rkt
@@ -91,7 +91,8 @@
   
   (printf "\n   Cycle complete!\n")
   (printf "   - Perceived: ~a\n" perceived)
-  (printf "   - Reasoned: ~a\n" (cadr (assoc 'symbolic reasoning-result)))
+  (define symbolic-pair (assoc 'symbolic reasoning-result))
+  (printf "   - Reasoned: ~a\n" (if symbolic-pair (cadr symbolic-pair) 'none))
   (printf "   - Action: ~a\n" action-result)
   (printf "   - Learned: ~a\n\n" learning-result))
 
@@ -110,7 +111,8 @@
 (define meta-learning-result (meta-learn '() performance-history))
 (printf "   Performance history: ~a\n" performance-history)
 (printf "   Meta-learning: ~a\n" meta-learning-result)
-(printf "   Strategy: ~a\n\n" (cadr (assoc 'strategy meta-learning-result)))
+(define strategy-pair (assoc 'strategy meta-learning-result))
+(printf "   Strategy: ~a\n\n" (if strategy-pair (cadr strategy-pair) 'unknown))
 
 (printf "=== Demo Complete ===\n")
 (printf "\nKey Insights:\n")
diff --git a/examples/neural-symbolic/neural-worker.rkt b/examples/neural-symbolic/neural-worker.rkt
index b820071..d04f3a8 100644
--- a/examples/neural-symbolic/neural-worker.rkt
+++ b/examples/neural-symbolic/neural-worker.rkt
@@ -151,8 +151,10 @@
       (let ([similar-concepts
              (for/list ([(name emb) (in-hash (neural-worker-embeddings worker))])
                (cons name (cosine-similarity embedding emb)))])
-        (take (sort similar-concepts > #:key cdr) 
-              (min 5 (length similar-concepts))))
+        (if (null? similar-concepts)
+            '()
+            (take (sort similar-concepts > #:key cdr) 
+                  (min 5 (length similar-concepts)))))
       '()))
 
 ;; Cosine similarity between vectors
diff --git a/examples/neural-symbolic/reasoning.rkt b/examples/neural-symbolic/reasoning.rkt
index 60121cd..bd1d732 100644
--- a/examples/neural-symbolic/reasoning.rkt
+++ b/examples/neural-symbolic/reasoning.rkt
@@ -100,4 +100,4 @@
   (test-case "hybrid reasoning"
     (define result (hybrid-reason test-kb '(concept dog)))
     (check-equal? (car result) 'hybrid-inference)
-    (check-true (assoc 'combined-confidence result))))
+    (check-not-false (assoc 'combined-confidence result))))

From 8e3cd8c760f5701e19c7a58a1fc661768113f4fe Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 28 Dec 2025 22:06:00 +0000
Subject: [PATCH 5/5] Add helper function for consistent assoc handling and fix
 remaining tests

Co-authored-by: drzo <15202748+drzo@users.noreply.github.com>
---
 examples/neural-symbolic/action.rkt   | 11 ++++++++---
 examples/neural-symbolic/demo.rkt     | 13 +++++++++----
 examples/neural-symbolic/learning.rkt |  2 +-
 3 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/examples/neural-symbolic/action.rkt b/examples/neural-symbolic/action.rkt
index 4bef03c..9925aba 100644
--- a/examples/neural-symbolic/action.rkt
+++ b/examples/neural-symbolic/action.rkt
@@ -7,7 +7,13 @@
 
 (provide act
          generate-action
-         execute-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)
@@ -22,9 +28,8 @@
 
 ;; Generate action from inference result
 (define (generate-action-from-inference inference)
-  (define confidence-pair (assoc 'combined-confidence inference))
   (define confidence-value 
-    (if confidence-pair (cadr confidence-pair) 0.5))
+    (get-assoc-value 'combined-confidence inference 0.5))
   
   (cond
     [(> confidence-value 0.8)
diff --git a/examples/neural-symbolic/demo.rkt b/examples/neural-symbolic/demo.rkt
index 1d6161a..dc54bf1 100644
--- a/examples/neural-symbolic/demo.rkt
+++ b/examples/neural-symbolic/demo.rkt
@@ -9,6 +9,11 @@
          "action.rkt"
          "learning.rkt")
 
+;; Helper function for safe assoc value extraction
+(define (get-assoc-value key alist default)
+  (define pair (assoc key alist))
+  (if pair (cadr pair) default))
+
 (printf "=== Neural-Symbolic Worker Demo ===\n\n")
 
 ;; Create a neural-symbolic worker
@@ -91,8 +96,8 @@
   
   (printf "\n   Cycle complete!\n")
   (printf "   - Perceived: ~a\n" perceived)
-  (define symbolic-pair (assoc 'symbolic reasoning-result))
-  (printf "   - Reasoned: ~a\n" (if symbolic-pair (cadr symbolic-pair) 'none))
+  (printf "   - Reasoned: ~a\n" 
+          (get-assoc-value 'symbolic reasoning-result 'none))
   (printf "   - Action: ~a\n" action-result)
   (printf "   - Learned: ~a\n\n" learning-result))
 
@@ -111,8 +116,8 @@
 (define meta-learning-result (meta-learn '() performance-history))
 (printf "   Performance history: ~a\n" performance-history)
 (printf "   Meta-learning: ~a\n" meta-learning-result)
-(define strategy-pair (assoc 'strategy meta-learning-result))
-(printf "   Strategy: ~a\n\n" (if strategy-pair (cadr strategy-pair) 'unknown))
+(printf "   Strategy: ~a\n\n" 
+        (get-assoc-value 'strategy meta-learning-result 'unknown))
 
 (printf "=== Demo Complete ===\n")
 (printf "\nKey Insights:\n")
diff --git a/examples/neural-symbolic/learning.rkt b/examples/neural-symbolic/learning.rkt
index 1fef1ba..06af28c 100644
--- a/examples/neural-symbolic/learning.rkt
+++ b/examples/neural-symbolic/learning.rkt
@@ -96,4 +96,4 @@
   (test-case "meta-learning"
     (define result (meta-learn '() '(0.6 0.7 0.8)))
     (check-equal? (car result) 'meta-learning)
-    (check-true (assoc 'strategy result))))
+    (check-not-false (assoc 'strategy result))))