Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/crates/ruqu-exotic/README.md

@@ -0,0 +1,164 @@
+# ruqu-exotic
+
+[![Crates.io](https://img.shields.io/crates/v/ruqu-exotic.svg)](https://crates.io/crates/ruqu-exotic)
+[![Documentation](https://docs.rs/ruqu-exotic/badge.svg)](https://docs.rs/ruqu-exotic)
+[![License](https://img.shields.io/crates/l/ruqu-exotic.svg)](https://github.com/ruvnet/ruvector)
+
+**Experimental quantum-classical hybrid algorithms** — quantum memory decay, interference-based search, reasoning error correction, swarm interference, syndrome diagnosis, and reversible memory for AI systems.
+
+## Algorithms
+
+| Module | Description | Application |
+|--------|-------------|-------------|
+| **Quantum Decay** | Temporal coherence loss modeling | Memory systems, caching |
+| **Interference Search** | Quantum-inspired amplitude interference | Vector similarity |
+| **Reasoning QEC** | Error correction for AI reasoning chains | LLM reliability |
+| **Swarm Interference** | Multi-agent quantum coordination | Distributed AI |
+| **Syndrome Diagnosis** | Error pattern detection | System health |
+| **Reversible Memory** | Quantum-reversible state management | Undo/redo systems |
+
+## Installation
+
+```bash
+cargo add ruqu-exotic
+```
+
+## Quantum Memory Decay
+
+Model temporal coherence loss in memory systems:
+
+```rust
+use ruqu_exotic::quantum_decay::{DecayModel, MemoryState};
+
+let model = DecayModel::new()
+    .t1(100.0)      // Amplitude decay time (μs)
+    .t2(50.0)       // Phase decay time (μs)
+    .temperature(0.02);  // Thermal noise
+
+let state = MemoryState::from_embedding(embedding);
+let decayed = model.evolve(state, time: 10.0)?;
+
+println!("Fidelity after 10μs: {:.2}%", decayed.fidelity() * 100.0);
+```
+
+## Interference Search
+
+Quantum-inspired amplitude interference for similarity search:
+
+```rust
+use ruqu_exotic::interference_search::{InterferenceIndex, Query};
+
+let mut index = InterferenceIndex::new(dimension: 384);
+index.add_vectors(&embeddings)?;
+
+// Constructive interference amplifies similar vectors
+let query = Query::new(query_embedding)
+    .interference_rounds(3)
+    .phase_kickback(true);
+
+let results = index.search(query, k: 10)?;
+```
+
+## Reasoning Error Correction
+
+Detect and correct errors in AI reasoning chains:
+
+```rust
+use ruqu_exotic::reasoning_qec::{ReasoningCode, LogicalChain};
+
+let code = ReasoningCode::new()
+    .redundancy(3)           // Triple modular redundancy
+    .syndrome_bits(2);       // Error detection bits
+
+let chain = LogicalChain::from_steps(&[
+    "Premise: All A are B",
+    "Premise: X is A",
+    "Conclusion: X is B"
+]);
+
+let protected = code.encode(chain)?;
+let (decoded, errors) = code.decode_and_correct(protected)?;
+println!("Detected {} logical errors", errors.len());
+```
+
+## Swarm Interference
+
+Coordinate multi-agent systems with quantum interference:
+
+```rust
+use ruqu_exotic::swarm_interference::{SwarmState, Agent};
+
+let mut swarm = SwarmState::new(n_agents: 8);
+
+// Agents interfere constructively on consensus
+for round in 0..10 {
+    swarm.apply_interference()?;
+    swarm.measure_partial()?;  // Partial collapse
+}
+
+let consensus = swarm.final_state()?;
+```
+
+## Syndrome Diagnosis
+
+Detect error patterns in distributed systems:
+
+```rust
+use ruqu_exotic::syndrome_diagnosis::{Diagnostics, Pattern};
+
+let diag = Diagnostics::new()
+    .stabilizers(&["XXXX", "ZZZZ"])
+    .measurement_noise(0.01);
+
+let syndromes = diag.measure(&system_state)?;
+let errors = diag.decode_syndromes(syndromes)?;
+
+for error in errors {
+    println!("Error at {:?}: {:?}", error.location, error.type_);
+}
+```
+
+## Reversible Memory
+
+Quantum-reversible operations for undo/redo:
+
+```rust
+use ruqu_exotic::reversible_memory::{ReversibleStore, Operation};
+
+let mut store = ReversibleStore::new();
+
+store.apply(Operation::Insert { key: "a", value: vec![1,2,3] })?;
+store.apply(Operation::Update { key: "a", value: vec![4,5,6] })?;
+
+// Perfect reversal via uncompute
+store.reverse_last()?;  // Back to [1,2,3]
+store.reverse_last()?;  // Back to empty
+```
+
+## Integration with RuVector
+
+These algorithms integrate with the [RuVector](https://github.com/ruvnet/ruvector) vector database for quantum-enhanced AI:
+
+```rust
+use ruvector_core::Index;
+use ruqu_exotic::interference_search::InterferenceIndex;
+
+// Wrap RuVector index with interference search
+let base_index = Index::new(config)?;
+let quantum_index = InterferenceIndex::wrap(base_index)?;
+```
+
+## Related Crates
+
+- [`ruqu-core`](https://crates.io/crates/ruqu-core) — Quantum circuit simulator
+- [`ruqu-algorithms`](https://crates.io/crates/ruqu-algorithms) — VQE, Grover, QAOA, Surface Code
+- [`ruqu-wasm`](https://crates.io/crates/ruqu-wasm) — WebAssembly bindings
+
+## Documentation
+
+- [Exotic Discoveries (ADR-QE-014)](https://github.com/ruvnet/ruvector/blob/main/docs/adr/quantum-engine/ADR-QE-014-exotic-discoveries.md)
+- [MinCut Coherence (ADR-QE-012)](https://github.com/ruvnet/ruvector/blob/main/docs/adr/quantum-engine/ADR-QE-012-mincut-coherence-integration.md)
+
+## License
+
+MIT OR Apache-2.0