Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/examples/mincut/strange_loop/README.md

@@ -0,0 +1,232 @@
+# Strange Loop Self-Organizing Swarms
+
+## What is a Strange Loop?
+
+A **strange loop** is a phenomenon first described by Douglas Hofstadter in his book "Gödel, Escher, Bach". It occurs when a hierarchical system has a level that refers back to itself, creating a self-referential cycle.
+
+Think of an Escher drawing where stairs keep going up but somehow end where they started. Or think of a camera filming itself in a mirror - what it sees affects what appears in the mirror, which affects what it sees...
+
+## The Strange Loop in This Example
+
+This example demonstrates a computational strange loop where:
+
+```
+┌──────────────────────────────────────────┐
+│  Swarm observes its own structure        │
+│         ↓                                 │
+│  Swarm finds weaknesses                  │
+│         ↓                                 │
+│  Swarm reorganizes itself                │
+│         ↓                                 │
+│  Swarm observes its NEW structure        │
+│         ↓                                 │
+│  (loop back to start)                    │
+└──────────────────────────────────────────┘
+```
+
+### The Key Insight
+
+The swarm is simultaneously:
+- The **observer** (analyzing connectivity)
+- The **observed** (being analyzed)
+- The **actor** (reorganizing based on analysis)
+
+This creates a feedback cycle that leads to **emergent self-organization** - behavior that wasn't explicitly programmed but emerges from the loop itself.
+
+## How It Works
+
+### 1. Self-Observation (`observe_self()`)
+
+The swarm uses **min-cut analysis** to examine its own structure:
+
+```rust
+// The swarm "looks at itself"
+let min_cut = solver.karger_stein(100);
+let critical_edges = self.find_critical_edges(min_cut);
+```
+
+It discovers:
+- What is its minimum cut value? (How fragile is the connectivity?)
+- Which edges are critical? (Where are the weak points?)
+- How stable is the current configuration?
+
+### 2. Self-Modeling (`update_self_model()`)
+
+The swarm builds an internal model of itself:
+
+```rust
+// Predictions about own future state
+predicted_vulnerabilities: Vec<(usize, usize)>,
+predicted_min_cut: i64,
+confidence: f64,
+```
+
+This is **meta-cognition** - thinking about thinking. The swarm predicts how it will behave.
+
+### 3. Self-Modification (`apply_reorganization()`)
+
+Based on what it observes, the swarm changes itself:
+
+```rust
+ReorganizationAction::Strengthen { edges, weight_increase }
+// The swarm makes itself stronger where it's weak
+```
+
+### 4. The Loop Closes
+
+After reorganizing, the swarm observes its **new self**, and the cycle continues. Each iteration:
+- Improves the structure
+- Increases stability
+- Builds more confidence in predictions
+
+## Why This Matters
+
+### Emergent Intelligence
+
+The swarm exhibits behavior that seems "intelligent":
+- It recognizes its own weaknesses
+- It learns from experience (past observations)
+- It adapts and improves over time
+- It achieves a stable state through self-organization
+
+**None of this intelligence was explicitly programmed** - it emerged from the strange loop!
+
+### Self-Reference Creates Complexity
+
+Just like how human consciousness arises from neurons observing and affecting other neurons (including themselves), this computational system creates emergent properties through self-reference.
+
+### Applications
+
+This pattern appears in many systems:
+- **Neural networks** learning from their own predictions
+- **Evolutionary algorithms** adapting based on fitness
+- **Distributed systems** self-healing based on health checks
+- **AI agents** improving through self-critique
+
+## Running the Example
+
+```bash
+cd /home/user/ruvector/examples/mincut/strange_loop
+cargo run
+```
+
+You'll see:
+1. Initial weak swarm configuration
+2. Each iteration of the strange loop:
+   - Self-observation
+   - Self-model update
+   - Decision making
+   - Reorganization
+3. Convergence to stable state
+4. Journey summary showing emergent improvement
+
+## Key Observations
+
+### What You'll Notice
+
+1. **Learning Curve**: Early iterations make dramatic changes; later ones are subtle
+2. **Confidence Growth**: The self-model becomes more confident over time
+3. **Emergent Stability**: The swarm finds a stable configuration without being told what "stable" means
+4. **Self-Awareness**: The system tracks its own history and uses it for predictions
+
+### The "Aha!" Moment
+
+Watch for when the swarm:
+- Identifies a weakness (low min-cut)
+- Strengthens critical edges
+- Observes the improvement
+- Continues until satisfied with its own robustness
+
+This is **computational self-improvement** through strange loops!
+
+## Philosophical Implications
+
+### Hofstadter's Vision
+
+Hofstadter proposed that consciousness itself is a strange loop - our sense of "I" emerges from the brain observing and modeling itself at increasingly abstract levels.
+
+This example is a tiny computational echo of that idea:
+- The swarm has a "self" (its graph structure)
+- The swarm observes that self (min-cut analysis)
+- The swarm models that self (predictions)
+- The swarm modifies that self (reorganization)
+
+The loop creates something greater than the sum of its parts.
+
+### From Simple Rules to Complex Behavior
+
+The fascinating thing is that the complex, seemingly "intelligent" behavior emerges from:
+- Simple min-cut analysis
+- Basic reorganization rules
+- The feedback loop structure
+
+This demonstrates how **complexity can emerge from simplicity** when systems can reference themselves.
+
+## Technical Details
+
+### Min-Cut as Self-Observation
+
+We use min-cut analysis because it reveals:
+- **Global vulnerability**: The weakest point in connectivity
+- **Critical structure**: Which edges matter most
+- **Robustness metric**: Quantitative measure of stability
+
+### The Feedback Mechanism
+
+Each iteration:
+```
+State_n → Observe(State_n) → Decide(observation) →
+  → Modify(State_n) → State_{n+1}
+```
+
+The key is that `State_{n+1}` becomes the input to the next iteration, closing the loop.
+
+### Convergence
+
+The swarm reaches stability when:
+- Min-cut value is high enough
+- Critical edges are few
+- Recent observations show consistent stability
+- Self-model predictions match reality
+
+## Further Exploration
+
+### Modify the Example
+
+Try changing:
+- `stability_threshold`: Make convergence harder/easier
+- Initial graph structure: Start with different weaknesses
+- Reorganization strategies: Add new actions
+- Number of nodes: Scale up the swarm
+
+### Research Questions
+
+- What happens with 100 nodes?
+- Can multiple swarms observe each other? (mutual strange loops)
+- What if the swarm has conflicting goals?
+- Can the swarm evolve its own reorganization strategies?
+
+## References
+
+- **"Gödel, Escher, Bach"** by Douglas Hofstadter - The original exploration of strange loops
+- **"I Am a Strange Loop"** by Douglas Hofstadter - A more accessible treatment
+- **Min-Cut Algorithms** - Used here as the self-observation mechanism
+- **Self-Organizing Systems** - Broader field of emergent complexity
+
+## The Big Picture
+
+This example shows that when a system can:
+1. Observe itself
+2. Model itself
+3. Modify itself
+4. Loop back to step 1
+
+Something magical happens - **emergent self-organization** that looks like intelligence.
+
+The strange loop is the key. It's not just feedback - it's **self-referential feedback at multiple levels of abstraction**.
+
+And that, Hofstadter argues, is the essence of consciousness itself.
+
+---
+
+*"In the end, we are self-perceiving, self-inventing, locked-in mirages that are little miracles of self-reference."* - Douglas Hofstadter