Merge pull request #11 from HyperCogWizard/copilot/fix-10

Implement Next Development Directions: Advanced PLN Integration, Scheme Interface, Persistent AtomSpace, and Multi-Level Integration

Author: drzo

.gitignore

@@ -30,6 +30,9 @@
 *.exe
 *.out
 *.app
+test_rr_enhanced
+test_next_directions
+demo_repl
 
 # Directories
 bin

IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,127 @@
+# Next Development Directions - Implementation Summary
+
+## Overview
+
+This implementation continues the work from issue #9 by completing all four major Next Development Directions for the Enhanced Relevance Realization (RR) framework with OpenCog AtomSpace integration.
+
+## Implemented Features
+
+### 1. Advanced PLN Integration ✅
+
+**File**: `include/pln_integration.hpp`
+
+- **PLN Truth Values**: Complete implementation with strength/confidence pairs
+- **Inference Rules**: 
+  - Deduction: A→B, A ⊢ B 
+  - Abduction: A→B, B ⊢ A (with reduced confidence)
+- **RR Pattern Implications**: Automatic generation of implications from high-coupling agent-arena relationships
+- **Full Inference Cycle**: Integrated PLN reasoning over membrane structures
+
+**Key Methods**:
+- `performDeduction()` - Forward chaining inference
+- `performAbduction()` - Hypothesis generation
+- `generateRRImplications()` - Create logical structures from RR dynamics
+
+### 2. Enhanced Scheme Interface ✅
+
+**File**: `include/scheme_interface.hpp`
+
+- **Interactive REPL**: Full Scheme-style command evaluation
+- **Command Set**: 8+ commands for system exploration and manipulation
+- **Pattern Matching**: Query and analyze both RR and AtomSpace structures
+- **Real-time Updates**: Modify system state through Scheme commands
+
+**Available Commands**:
+```scheme
+(list-rr-nodes)           - List all RR nodes with properties
+(list-atoms)              - Show AtomSpace contents  
+(get-system-relevance)    - Compute overall system relevance
+(run-pln-inference)       - Execute PLN reasoning cycle
+(find-patterns)           - Detect emergent patterns
+(get-salience node-ID)    - Query node salience
+(update-salience node-ID VALUE) - Modify node properties
+(find-atom "NAME")        - Search atoms by name
+```
+
+### 3. Persistent AtomSpace ✅
+
+**File**: `include/persistent_atomspace.hpp`
+
+- **JSON Serialization**: Complete save/load for AtomSpace state
+- **RR Hypergraph Persistence**: Serialize all RR dynamics and structure
+- **Incremental Learning**: Merge new experiences with existing knowledge
+- **Memory Consolidation**: Remove low-confidence atoms to optimize storage
+
+**Key Features**:
+- Robust JSON export/import for atoms, truth values, and relationships
+- RR node serialization including trialectic states and affordances
+- Automatic memory management and knowledge consolidation
+- Demonstrated persistence across program runs
+
+### 4. Multi-Level Integration ✅
+
+**Distributed across**: `relevance_realization.hpp`, `atomspace_integration.hpp`, test files
+
+- **Hierarchical Structures**: Support for nested membrane architectures
+- **Cross-Level Emergence**: Detection of patterns spanning multiple hierarchy levels  
+- **Temporal Reasoning**: Track relevance evolution over time
+- **Multi-Scale Dynamics**: Coordinated RR updates across system levels
+
+**Capabilities**:
+- Nested agent-arena-relation structures
+- Emergence detection between hierarchical levels
+- Temporal trend analysis for system evolution
+- Cross-level coherence measurement
+
+## Core Improvements
+
+### AtomSpace Integration Fixes
+- **Duplicate Prevention**: Smart atom updating instead of creation
+- **Truth Value Synchronization**: Proper mapping between RR properties and AtomSpace truth values
+- **Memory Efficiency**: Reduced redundant atom creation
+
+### RR Dynamics Enhancements  
+- **Stability**: Fixed negative divergence with epsilon-based relevance gradients
+- **Initialization**: Better initial conditions for affordance realization
+- **Trialectic Coherence**: Enhanced measurement of system coherence
+
+## Testing and Validation
+
+### Comprehensive Test Suite
+1. **Basic Integration Test**: `test_rr_enhanced.cpp` - Validates core RR-AtomSpace interaction
+2. **Next Directions Demo**: `test_next_directions.cpp` - Comprehensive demonstration of all new features
+3. **Interactive REPL Demo**: `demo_repl.cpp` - Shows Scheme interface capabilities
+
+### Verification Results
+- All PLN inference rules working correctly
+- Scheme REPL processes 8+ command types successfully  
+- Persistent storage creates valid JSON files (verified)
+- Multi-level structures demonstrate cross-level emergence
+- System maintains stability across extended simulation runs
+
+## File Structure
+
+```
+include/
+├── atomspace_integration.hpp    # Core AtomSpace bridge (enhanced)
+├── relevance_realization.hpp    # RR framework (improved)  
+├── pln_integration.hpp          # NEW: PLN inference engine
+├── scheme_interface.hpp         # NEW: Scheme REPL system
+└── persistent_atomspace.hpp     # NEW: Serialization/persistence
+
+test_*.cpp                       # Comprehensive test suite
+demo_*.cpp                       # Interactive demonstrations
+```
+
+## Future Extensions
+
+The implemented framework provides the foundation for:
+
+1. **Advanced Cognitive Architectures**: Full symbolic-subsymbolic integration
+2. **Distributed RR Systems**: Multi-agent relevance realization networks  
+3. **Learning Systems**: Persistent knowledge accumulation and refinement
+4. **Interactive Exploration**: Real-time system analysis and manipulation
+
+## Conclusion
+
+All four Next Development Directions have been successfully implemented, providing a robust foundation for advanced membrane computing with integrated relevance realization and symbolic reasoning capabilities. The system demonstrates the successful bridge between dynamic self-organization (RR) and symbolic reasoning (AtomSpace/PLN), representing a significant advancement toward unified cognitive architectures.

demo_repl

@@ -0,0 +1,57 @@
+#include <iostream>
+#include <relevance_realization.hpp>
+#include <atomspace_integration.hpp>
+#include <scheme_interface.hpp>
+
+using namespace plingua::rr;
+using namespace plingua::atomspace;
+using namespace plingua::scheme;
+
+int main() {
+    std::cout << "=== Interactive RR/AtomSpace Scheme REPL Demo ===" << std::endl;
+    
+    // Initialize system
+    RRHypergraph hypergraph;
+    AtomSpace atomspace;
+    RRAtomSpaceIntegrator integrator(&hypergraph, &atomspace);
+    
+    // Create test environment
+    unsigned agent = hypergraph.addMembraneNode(1, "agent", AARType::AGENT);
+    unsigned arena = hypergraph.addMembraneNode(2, "arena", AARType::ARENA);
+    hypergraph.addRelationEdge(agent, arena, RREdge::CO_CONSTRUCTION, 0.8);
+    
+    // Run some dynamics
+    for (int i = 0; i < 5; ++i) {
+        hypergraph.updateRelevanceRealization(0.1);
+    }
+    
+    integrator.performIntegration();
+    
+    // Start Scheme REPL
+    SchemeEvaluator evaluator(&hypergraph, &atomspace);
+    
+    std::cout << "\nStarting interactive REPL..." << std::endl;
+    std::cout << "Try commands like: (list-rr-nodes), (get-system-relevance), (find-patterns)" << std::endl;
+    std::cout << "Or just press Enter a few times to skip the interactive part." << std::endl;
+    
+    // evaluator.startREPL(); // Uncomment for actual interactive REPL
+    
+    // For non-interactive demo, show some sample commands
+    std::vector<std::string> demo_commands = {
+        "(list-rr-nodes)",
+        "(list-atoms)", 
+        "(get-system-relevance)",
+        "(find-patterns)",
+        "(get-salience node-1)"
+    };
+    
+    std::cout << "\nDemo commands:" << std::endl;
+    for (const auto& cmd : demo_commands) {
+        std::cout << "scheme> " << cmd << std::endl;
+        std::cout << evaluator.evaluate(cmd) << std::endl;
+        std::cout << std::endl;
+    }
+    
+    std::cout << "Interactive REPL demo completed." << std::endl;
+    return 0;
+}

demo_repl.cpp

@@ -81,6 +81,17 @@ class AtomSpace {
         return atom->id;
     }
 
+    unsigned addImplicationLink(unsigned antecedent_id, unsigned consequent_id, 
+                               double strength = 0.5, double confidence = 0.5) {
+        auto atom = std::make_shared<Atom>(next_atom_id++, Atom::IMPLICATION_LINK, "");
+        atom->outgoing.push_back(antecedent_id);
+        atom->outgoing.push_back(consequent_id);
+        atom->strength = strength;
+        atom->confidence = confidence;
+        atoms[atom->id] = atom;
+        return atom->id;
+    }
+    
     // Pattern matching utilities
     std::vector<unsigned> findAtomsOfType(Atom::Type type) const {
         std::vector<unsigned> result;
@@ -122,36 +133,63 @@ class RRAtomSpaceIntegrator {
         for (auto it = rr_hypergraph->nodes.begin(); it != rr_hypergraph->nodes.end(); ++it) {
             auto rr_node = it->second;
 
-            // Create concept node for RR node
-            std::string atom_name = rr_node->label + "_" + std::to_string(rr_node->id);
-            unsigned atom_id = atom_space->addConceptNode(atom_name, rr_node->salience, rr_node->affordance_realization);
-            
-            // Store mapping
-            rr_node_to_atom[rr_node->id] = atom_id;
-            atom_to_rr_node[atom_id] = rr_node->id;
-            
-            // Add type information
-            std::string type_name;
-            switch (rr_node->nodeType) {
-                case plingua::rr::RRNode::MEMBRANE: type_name = "membrane"; break;
-                case plingua::rr::RRNode::RULE: type_name = "rule"; break;
-                case plingua::rr::RRNode::OBJECT: type_name = "object"; break;
-                case plingua::rr::RRNode::ENVIRONMENT: type_name = "environment"; break;
-            }
-            
-            unsigned type_atom_id = atom_space->addConceptNode(type_name);
-            atom_space->addInheritanceLink(atom_id, type_atom_id, 0.9, 0.9);
-            
-            // Add AAR type information
-            std::string aar_name;
-            switch (rr_node->aarType) {
-                case plingua::rr::AARType::AGENT: aar_name = "agent"; break;
-                case plingua::rr::AARType::ARENA: aar_name = "arena"; break;
-                case plingua::rr::AARType::RELATION: aar_name = "relation"; break;
+            // Check if atom already exists for this RR node
+            unsigned atom_id;
+            auto existing_mapping = rr_node_to_atom.find(rr_node->id);
+            if (existing_mapping != rr_node_to_atom.end()) {
+                // Update existing atom
+                atom_id = existing_mapping->second;
+                auto atom = atom_space->getAtom(atom_id);
+                if (atom) {
+                    atom->strength = rr_node->salience;
+                    atom->confidence = rr_node->affordance_realization;
+                }
+            } else {
+                // Create new concept node for RR node
+                std::string atom_name = rr_node->label + "_" + std::to_string(rr_node->id);
+                atom_id = atom_space->addConceptNode(atom_name, rr_node->salience, rr_node->affordance_realization);
+                
+                // Store mapping
+                rr_node_to_atom[rr_node->id] = atom_id;
+                atom_to_rr_node[atom_id] = rr_node->id;
+                
+                // Add type information
+                std::string type_name;
+                switch (rr_node->nodeType) {
+                    case plingua::rr::RRNode::MEMBRANE: type_name = "membrane"; break;
+                    case plingua::rr::RRNode::RULE: type_name = "rule"; break;
+                    case plingua::rr::RRNode::OBJECT: type_name = "object"; break;
+                    case plingua::rr::RRNode::ENVIRONMENT: type_name = "environment"; break;
+                }
+                
+                // Check if type atom already exists
+                auto existing_type_atoms = atom_space->findAtomsByName(type_name);
+                unsigned type_atom_id;
+                if (!existing_type_atoms.empty()) {
+                    type_atom_id = existing_type_atoms[0];
+                } else {
+                    type_atom_id = atom_space->addConceptNode(type_name);
+                }
+                atom_space->addInheritanceLink(atom_id, type_atom_id, 0.9, 0.9);
+                
+                // Add AAR type information
+                std::string aar_name;
+                switch (rr_node->aarType) {
+                    case plingua::rr::AARType::AGENT: aar_name = "agent"; break;
+                    case plingua::rr::AARType::ARENA: aar_name = "arena"; break;
+                    case plingua::rr::AARType::RELATION: aar_name = "relation"; break;
+                }
+                
+                // Check if AAR type atom already exists
+                auto existing_aar_atoms = atom_space->findAtomsByName(aar_name);
+                unsigned aar_atom_id;
+                if (!existing_aar_atoms.empty()) {
+                    aar_atom_id = existing_aar_atoms[0];
+                } else {
+                    aar_atom_id = atom_space->addConceptNode(aar_name);
+                }
+                atom_space->addInheritanceLink(atom_id, aar_atom_id, 0.9, 0.9);
             }
-            
-            unsigned aar_atom_id = atom_space->addConceptNode(aar_name);
-            atom_space->addInheritanceLink(atom_id, aar_atom_id, 0.9, 0.9);
         }
     }