dearsky/wifi-densepose
1
0
Fork 0
Code Issues 20 Pull Requests 5 Actions Packages Projects Releases 1 Wiki Activity

Squashed 'vendor/ruvector/' content from commit b64c2172

Browse Source 
git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
This commit is contained in:
ruv
2026-02-28 14:39:40 -05:00
commit d803bfe2b1
7854 changed files with 3522914 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
examples/delta-behavior/CHANGELOG.md Normal file
View File

@@ -0,0 +1,218 @@
# Changelog
All notable changes to Delta-Behavior will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [Unreleased]
### Planned
- WASM module for browser-based coherence enforcement
- Async runtime integration (tokio, async-std)
- Metric export for Prometheus/Grafana monitoring
- Python bindings via PyO3
---
## [0.1.0] - 2026-01-28
### Added
#### Core Library
- `Coherence` type with range validation (0.0-1.0)
- `CoherenceBounds` for defining threshold parameters
- `CoherenceState` for tracking coherence history and trends
- `DeltaSystem` trait for implementing coherence-preserving systems
- `DeltaConfig` with preset configurations (`default()`, `strict()`, `relaxed()`)
- `DeltaEnforcer` implementing three-layer enforcement
#### Configuration Types
- `EnergyConfig` for soft constraint layer parameters
- `SchedulingConfig` for medium constraint layer parameters
- `GatingConfig` for hard constraint layer parameters
#### Transition System
- `Transition<T>` generic transition wrapper
- `TransitionConstraint` for defining transition limits
- `TransitionResult` enum (Applied, Blocked, Throttled, Modified)
#### Attractor Dynamics
- `Attractor<S>` for representing stable states
- `AttractorBasin<S>` for tracking basin membership
- `GuidanceForce` for computing attractor-directed forces
#### Enforcement
- Three-layer enforcement stack (Energy, Scheduling, Gating)
- `EnforcementResult` enum (Allowed, Blocked, Throttled)
- Recovery mode handling with configurable margin
#### Applications (feature-gated)
- **01 Self-Limiting Reasoning** (`self-limiting`)
- `SelfLimitingReasoner` with coherence-based depth limiting
- Automatic activity reduction under uncertainty
- **02 Computational Event Horizons** (`event-horizon`)
- `ComputationalHorizon` with asymptotic slowdown
- No hard recursion limits
- **03 Artificial Homeostasis** (`homeostasis`)
- `HomeostasisSystem` with multi-variable regulation
- Coherence-based survival mechanism
- **04 Self-Stabilizing World Models** (`world-model`)
- `StabilizingWorldModel` with belief coherence
- Hallucination prevention via coherence gating
- **05 Coherence-Bounded Creativity** (`creativity`)
- `CreativeEngine` with novelty/coherence balance
- Bounded exploration in generative tasks
- **06 Anti-Cascade Financial Systems** (`financial`)
- `AntiCascadeMarket` with coherence-based circuit breakers
- Order rejection for cascade-inducing trades
- **07 Graceful Aging** (`aging`)
- `AgingSystem` with complexity reduction
- Function preservation under simplification
- **08 Swarm Intelligence** (`swarm`)
- `CoherentSwarm` with global coherence enforcement
- Action modification for coherence preservation
- **09 Graceful Shutdown** (`shutdown`)
- `GracefulSystem` with shutdown as attractor
- Automatic safe termination under degradation
- **10 Pre-AGI Containment** (`containment`)
- `ContainmentSubstrate` with capability ceilings
- Coherence-bounded intelligence growth
#### Documentation
- Comprehensive rustdoc comments on all public APIs
- Module-level documentation with examples
- `WHITEPAPER.md` with executive summary and technical deep-dive
- `docs/API.md` comprehensive API reference
- ADR documents for all major design decisions
- Mathematical foundations documentation
#### Testing
- Unit tests for all core types
- Integration tests for enforcement stack
- Acceptance test demonstrating Delta-behavior under chaos
- Per-application test suites
#### Architecture
- Domain-Driven Design structure
- Clean separation between core, applications, and infrastructure
- Feature flags for minimal binary size
### Technical Details
#### Coherence Bounds (Defaults)
| Parameter | Value | Purpose |
|-----------|-------|---------|
| `min_coherence` | 0.3 | Absolute floor (writes blocked below) |
| `throttle_threshold` | 0.5 | Rate limiting begins |
| `target_coherence` | 0.8 | System seeks this level |
| `max_delta_drop` | 0.1 | Maximum per-transition drop |
#### Energy Cost Model
```
cost = base_cost * (1 + instability)^exponent
```
Where:
- `base_cost = 1.0`
- `exponent = 2.0`
- `max_cost = 100.0`
- `budget_per_tick = 10.0`
#### Supported Platforms
- Linux (x86_64, aarch64)
- macOS (x86_64, aarch64)
- Windows (x86_64)
- WASM (wasm32-unknown-unknown)
#### Minimum Supported Rust Version (MSRV)
- Rust 1.75.0
### Dependencies
- No required runtime dependencies (no_std compatible with `alloc`)
- Optional: `std` feature for full functionality
### Breaking Changes
- Initial release - no breaking changes
### Migration Guide
- Initial release - no migration required
---
## [0.0.1] - 2026-01-15
### Added
- Initial project structure
- Proof-of-concept implementation
- Basic documentation
---
## Version History Summary
| Version | Date | Highlights |
|---------|------|------------|
| 0.1.0 | 2026-01-28 | First stable release with full API |
| 0.0.1 | 2026-01-15 | Initial proof-of-concept |
---
## Upgrade Notes
### From 0.0.1 to 0.1.0
The 0.0.1 release was a proof-of-concept. Version 0.1.0 is a complete rewrite with:
1. **New API**: The `DeltaSystem` trait replaces the previous ad-hoc functions
2. **Configuration**: Use `DeltaConfig` instead of individual parameters
3. **Enforcement**: The `DeltaEnforcer` provides unified enforcement
4. **Applications**: Enable specific applications via feature flags
Example migration:
```rust
// 0.0.1 (proof-of-concept)
let coherence = check_coherence(&state);
if coherence > 0.3 {
apply_transition(&mut state, &delta);
}
// 0.1.0 (stable)
use delta_behavior::{DeltaConfig, enforcement::DeltaEnforcer, Coherence};
let config = DeltaConfig::default();
let mut enforcer = DeltaEnforcer::new(config);
let current = system.coherence();
let predicted = system.predict_coherence(&transition);
match enforcer.check(current, predicted) {
EnforcementResult::Allowed => system.step(&transition),
EnforcementResult::Throttled(delay) => std::thread::sleep(delay),
EnforcementResult::Blocked(reason) => eprintln!("Blocked: {}", reason),
}
```
---
## Links
- [Documentation](https://docs.rs/delta-behavior)
- [Repository](https://github.com/ruvnet/ruvector)
- [Issue Tracker](https://github.com/ruvnet/ruvector/issues)
- [Whitepaper](./WHITEPAPER.md)
- [API Reference](./docs/API.md)
[Unreleased]: https://github.com/ruvnet/ruvector/compare/delta-behavior-v0.1.0...HEAD
[0.1.0]: https://github.com/ruvnet/ruvector/releases/tag/delta-behavior-v0.1.0
[0.0.1]: https://github.com/ruvnet/ruvector/releases/tag/delta-behavior-v0.0.1

813
examples/delta-behavior/Cargo.lock generated Normal file
View File

@@ -0,0 +1,813 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "aho-corasick"
version = "1.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
dependencies = [
"memchr",
]
[[package]]
name = "anes"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
[[package]]
name = "anstyle"
version = "1.0.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
[[package]]
name = "async-trait"
version = "0.1.89"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "autocfg"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
[[package]]
name = "bumpalo"
version = "3.19.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
[[package]]
name = "cast"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
[[package]]
name = "cc"
version = "1.2.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6354c81bbfd62d9cfa9cb3c773c2b7b2a3a482d569de977fd0e961f6e7c00583"
dependencies = [
"find-msvc-tools",
"shlex",
]
[[package]]
name = "cfg-if"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
[[package]]
name = "ciborium"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
dependencies = [
"ciborium-io",
"ciborium-ll",
"serde",
]
[[package]]
name = "ciborium-io"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
[[package]]
name = "ciborium-ll"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
dependencies = [
"ciborium-io",
"half",
]
[[package]]
name = "clap"
version = "4.5.55"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3e34525d5bbbd55da2bb745d34b36121baac88d07619a9a09cfcf4a6c0832785"
dependencies = [
"clap_builder",
]
[[package]]
name = "clap_builder"
version = "4.5.55"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59a20016a20a3da95bef50ec7238dbd09baeef4311dcdd38ec15aba69812fb61"
dependencies = [
"anstyle",
"clap_lex",
]
[[package]]
name = "clap_lex"
version = "0.7.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
[[package]]
name = "console_error_panic_hook"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
dependencies = [
"cfg-if",
"wasm-bindgen",
]
[[package]]
name = "criterion"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
dependencies = [
"anes",
"cast",
"ciborium",
"clap",
"criterion-plot",
"is-terminal",
"itertools",
"num-traits",
"once_cell",
"oorandom",
"plotters",
"rayon",
"regex",
"serde",
"serde_derive",
"serde_json",
"tinytemplate",
"walkdir",
]
[[package]]
name = "criterion-plot"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
dependencies = [
"cast",
"itertools",
]
[[package]]
name = "crossbeam-deque"
version = "0.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
dependencies = [
"crossbeam-epoch",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-epoch"
version = "0.9.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "crossbeam-utils"
version = "0.8.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
[[package]]
name = "crunchy"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
[[package]]
name = "delta-behavior"
version = "0.1.0"
dependencies = [
"console_error_panic_hook",
"criterion",
"getrandom",
"js-sys",
"rand",
"serde",
"serde_json",
"thiserror",
"wasm-bindgen",
"wasm-bindgen-test",
]
[[package]]
name = "either"
version = "1.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
[[package]]
name = "find-msvc-tools"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db"
[[package]]
name = "futures-core"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
[[package]]
name = "futures-task"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
[[package]]
name = "futures-util"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
dependencies = [
"futures-core",
"futures-task",
"pin-project-lite",
"pin-utils",
"slab",
]
[[package]]
name = "getrandom"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
dependencies = [
"cfg-if",
"js-sys",
"libc",
"wasi",
"wasm-bindgen",
]
[[package]]
name = "half"
version = "2.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
dependencies = [
"cfg-if",
"crunchy",
"zerocopy",
]
[[package]]
name = "hermit-abi"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
[[package]]
name = "is-terminal"
version = "0.4.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
dependencies = [
"hermit-abi",
"libc",
"windows-sys",
]
[[package]]
name = "itertools"
version = "0.10.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
dependencies = [
"either",
]
[[package]]
name = "itoa"
version = "1.0.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
[[package]]
name = "js-sys"
version = "0.3.85"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
dependencies = [
"once_cell",
"wasm-bindgen",
]
[[package]]
name = "libc"
version = "0.2.180"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
[[package]]
name = "libm"
version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
[[package]]
name = "memchr"
version = "2.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
[[package]]
name = "minicov"
version = "0.3.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4869b6a491569605d66d3952bcdf03df789e5b536e5f0cf7758a7f08a55ae24d"
dependencies = [
"cc",
"walkdir",
]
[[package]]
name = "nu-ansi-term"
version = "0.50.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
dependencies = [
"windows-sys",
]
[[package]]
name = "num-traits"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
dependencies = [
"autocfg",
"libm",
]
[[package]]
name = "once_cell"
version = "1.21.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
[[package]]
name = "oorandom"
version = "11.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
[[package]]
name = "pin-project-lite"
version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "plotters"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
dependencies = [
"num-traits",
"plotters-backend",
"plotters-svg",
"wasm-bindgen",
"web-sys",
]
[[package]]
name = "plotters-backend"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
[[package]]
name = "plotters-svg"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
dependencies = [
"plotters-backend",
]
[[package]]
name = "ppv-lite86"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
dependencies = [
"zerocopy",
]
[[package]]
name = "proc-macro2"
version = "1.0.106"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
dependencies = [
"proc-macro2",
]
[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
"libc",
"rand_chacha",
"rand_core",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
"rand_core",
]
[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
"getrandom",
]
[[package]]
name = "rayon"
version = "1.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
dependencies = [
"either",
"rayon-core",
]
[[package]]
name = "rayon-core"
version = "1.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
dependencies = [
"crossbeam-deque",
"crossbeam-utils",
]
[[package]]
name = "regex"
version = "1.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
dependencies = [
"aho-corasick",
"memchr",
"regex-automata",
"regex-syntax",
]
[[package]]
name = "regex-automata"
version = "0.4.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax",
]
[[package]]
name = "regex-syntax"
version = "0.8.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
[[package]]
name = "rustversion"
version = "1.0.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
[[package]]
name = "same-file"
version = "1.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
dependencies = [
"winapi-util",
]
[[package]]
name = "serde"
version = "1.0.228"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
dependencies = [
"serde_core",
"serde_derive",
]
[[package]]
name = "serde_core"
version = "1.0.228"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.228"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.149"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
dependencies = [
"itoa",
"memchr",
"serde",
"serde_core",
"zmij",
]
[[package]]
name = "shlex"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "slab"
version = "0.4.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
[[package]]
name = "syn"
version = "2.0.114"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "thiserror"
version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "tinytemplate"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
dependencies = [
"serde",
"serde_json",
]
[[package]]
name = "unicode-ident"
version = "1.0.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
[[package]]
name = "walkdir"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
dependencies = [
"same-file",
"winapi-util",
]
[[package]]
name = "wasi"
version = "0.11.1+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
[[package]]
name = "wasm-bindgen"
version = "0.2.108"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
dependencies = [
"cfg-if",
"once_cell",
"rustversion",
"wasm-bindgen-macro",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
version = "0.4.58"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
dependencies = [
"cfg-if",
"futures-util",
"js-sys",
"once_cell",
"wasm-bindgen",
"web-sys",
]
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.108"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.108"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
dependencies = [
"bumpalo",
"proc-macro2",
"quote",
"syn",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.108"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
dependencies = [
"unicode-ident",
]
[[package]]
name = "wasm-bindgen-test"
version = "0.3.58"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "45649196a53b0b7a15101d845d44d2dda7374fc1b5b5e2bbf58b7577ff4b346d"
dependencies = [
"async-trait",
"cast",
"js-sys",
"libm",
"minicov",
"nu-ansi-term",
"num-traits",
"oorandom",
"serde",
"serde_json",
"wasm-bindgen",
"wasm-bindgen-futures",
"wasm-bindgen-test-macro",
"wasm-bindgen-test-shared",
]
[[package]]
name = "wasm-bindgen-test-macro"
version = "0.3.58"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f579cdd0123ac74b94e1a4a72bd963cf30ebac343f2df347da0b8df24cdebed2"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "wasm-bindgen-test-shared"
version = "0.2.108"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8145dd1593bf0fb137dbfa85b8be79ec560a447298955877804640e40c2d6ea"
[[package]]
name = "web-sys"
version = "0.3.85"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
dependencies = [
"js-sys",
"wasm-bindgen",
]
[[package]]
name = "winapi-util"
version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
"windows-sys",
]
[[package]]
name = "windows-link"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
[[package]]
name = "windows-sys"
version = "0.61.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
dependencies = [
"windows-link",
]
[[package]]
name = "zerocopy"
version = "0.8.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fdea86ddd5568519879b8187e1cf04e24fce28f7fe046ceecbce472ff19a2572"
dependencies = [
"zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
version = "0.8.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c15e1b46eff7c6c91195752e0eeed8ef040e391cdece7c25376957d5f15df22"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "zmij"
version = "1.0.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02aae0f83f69aafc94776e879363e9771d7ecbffe2c7fbb6c14c5e00dfe88439"

170
examples/delta-behavior/Cargo.toml Normal file
View File

@@ -0,0 +1,170 @@
[package]
name = "delta-behavior"
version = "0.1.0"
edition = "2021"
rust-version = "1.75.0"
authors = ["RuVector Team <team@ruvector.io>"]
license = "MIT OR Apache-2.0"
description = "Delta-behavior: constrained state transitions that preserve global coherence - systems that refuse to collapse"
repository = "https://github.com/ruvnet/ruvector"
homepage = "https://github.com/ruvnet/ruvector/tree/main/examples/delta-behavior"
documentation = "https://docs.rs/delta-behavior"
readme = "README.md"
keywords = ["ai-safety", "coherence", "state-machine", "containment", "stability"]
categories = ["algorithms", "science", "simulation"]
include = [
"src/**/*",
"applications/**/*",
"docs/**/*",
"examples/**/*",
"benches/**/*",
"Cargo.toml",
"README.md",
"LICENSE-MIT",
"LICENSE-APACHE",
"CHANGELOG.md",
"WHITEPAPER.md",
]
exclude = [
"target/",
".git/",
".github/",
]
[lib]
path = "src/lib.rs"
crate-type = ["cdylib", "rlib"]
[[bin]]
name = "run_benchmarks"
path = "src/bin/run_benchmarks.rs"
required-features = ["benchmarks"]
[[bench]]
name = "coherence_benchmarks"
path = "benches/coherence_benchmarks.rs"
harness = false
required-features = ["benchmarks"]
# Examples
[[example]]
name = "demo"
path = "examples/demo.rs"
[[example]]
name = "self_limiting"
path = "examples/self_limiting.rs"
required-features = ["self-limiting-reasoning"]
[[example]]
name = "swarm"
path = "examples/swarm.rs"
required-features = ["swarm-intelligence"]
[[example]]
name = "containment"
path = "examples/containment.rs"
required-features = ["containment"]
[dependencies]
rand = { version = "0.8", optional = true }
thiserror = { version = "1.0", optional = true }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
# WASM dependencies
wasm-bindgen = "0.2"
js-sys = "0.3"
# Optional: better panic messages in browser console
console_error_panic_hook = { version = "0.1", optional = true }
[target.'cfg(target_arch = "wasm32")'.dependencies]
getrandom = { version = "0.2", features = ["js"] }
[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }
rand = "0.8"
wasm-bindgen-test = "0.3"
[features]
default = ["std", "console_error_panic_hook"]
std = []
# Enable all optional dependencies
full = ["rand", "thiserror"]
# Benchmark support
benchmarks = ["rand"]
# WASM feature
wasm = ["console_error_panic_hook"]
# Individual application features
self-limiting-reasoning = []
event-horizon = []
homeostasis = []
world-model = []
coherence-creativity = []
anti-cascade = []
graceful-aging = []
swarm-intelligence = []
graceful-shutdown = []
containment = []
# Application groups
all-applications = [
"self-limiting-reasoning",
"event-horizon",
"homeostasis",
"world-model",
"coherence-creativity",
"anti-cascade",
"graceful-aging",
"swarm-intelligence",
"graceful-shutdown",
"containment",
]
# Safety-critical applications
safety-critical = [
"self-limiting-reasoning",
"graceful-shutdown",
"containment",
]
# Distributed systems applications
distributed = [
"graceful-aging",
"swarm-intelligence",
"anti-cascade",
]
# AI/ML applications
ai-ml = [
"self-limiting-reasoning",
"world-model",
"coherence-creativity",
"containment",
]
# Memory tracking for debugging
memory-tracking = []
[profile.release]
lto = true
codegen-units = 1
opt-level = "s"
[profile.bench]
opt-level = 3
lto = "thin"
codegen-units = 1
debug = false
[package.metadata.docs.rs]
all-features = true
rustdoc-args = ["--cfg", "docsrs"]
[package.metadata.wasm-pack.profile.release]
wasm-opt = ["-O4"]

190
examples/delta-behavior/LICENSE-APACHE Normal file
View File

@@ -0,0 +1,190 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to the Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
Copyright 2026 RuVector Team
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

21
examples/delta-behavior/LICENSE-MIT Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2026 RuVector Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

300
examples/delta-behavior/README.md Normal file
View File

@@ -0,0 +1,300 @@
# Delta-Behavior
**The mathematics of systems that refuse to collapse.**
[![Crates.io](https://img.shields.io/crates/v/delta-behavior.svg)](https://crates.io/crates/delta-behavior)
[![Documentation](https://docs.rs/delta-behavior/badge.svg)](https://docs.rs/delta-behavior)
[![License](https://img.shields.io/crates/l/delta-behavior.svg)](LICENSE-MIT)
Delta-behavior is a design principle for building systems where **change is permitted but collapse is not**. It provides a framework for constraining state transitions to preserve global coherence.
## Key Features
- **Coherence-First Design**: Optimize for stability, not just performance
- **Three-Layer Enforcement**: Energy cost, scheduling, and memory gating
- **Attractor Dynamics**: Systems naturally gravitate toward stable states
- **11 Exotic Applications**: From AI safety to extropic intelligence substrates
- **WASM + TypeScript SDK**: Full browser/Node.js support
- **Performance Optimized**: O(n) algorithms with SIMD acceleration
## Quick Start
Add to your `Cargo.toml`:
```toml
[dependencies]
delta-behavior = "0.1"
```
Basic usage:
```rust
use delta_behavior::{DeltaSystem, Coherence, DeltaConfig};
use delta_behavior::enforcement::{DeltaEnforcer, EnforcementResult};
// Create an enforcer with default configuration
let config = DeltaConfig::default();
let mut enforcer = DeltaEnforcer::new(config);
// Check if a transition should be allowed
let current = Coherence::clamped(0.8);
let predicted = Coherence::clamped(0.75);
match enforcer.check(current, predicted) {
EnforcementResult::Allowed => println!("Transition allowed"),
EnforcementResult::Throttled(delay) => println!("Wait {:?}", delay),
EnforcementResult::Blocked(reason) => println!("Blocked: {}", reason),
}
```
## The Four Properties
A system exhibits Delta-behavior when:
1. **Local Change**: State updates happen in bounded steps
2. **Global Preservation**: Local changes don't break overall structure
3. **Violation Resistance**: Destabilizing transitions are damped/blocked
4. **Closure Preference**: System naturally settles into stable attractors
## Configuration
Three preset configurations are available:
```rust
// Default: Balanced stability and flexibility
let config = DeltaConfig::default();
// Strict: For safety-critical applications
let config = DeltaConfig::strict();
// Relaxed: For exploratory applications
let config = DeltaConfig::relaxed();
```
Custom configuration:
```rust
use delta_behavior::{DeltaConfig, CoherenceBounds, Coherence};
let config = DeltaConfig {
bounds: CoherenceBounds {
min_coherence: Coherence::clamped(0.4),
throttle_threshold: Coherence::clamped(0.6),
target_coherence: Coherence::clamped(0.85),
max_delta_drop: 0.08,
},
guidance_strength: 0.7,
..DeltaConfig::default()
};
```
## 11 Exotic Applications
| # | Application | Description | Key Innovation |
|---|-------------|-------------|----------------|
| 01 | **Self-Limiting Reasoning** | AI that does less when uncertain | Depth/scope scales with coherence |
| 02 | **Computational Event Horizon** | Bounded computation without hard limits | Asymptotic approach, never arrival |
| 03 | **Artificial Homeostasis** | Synthetic life with coherence-based survival | Death = coherence collapse |
| 04 | **Self-Stabilizing World Model** | Models that refuse to hallucinate | Observations that would destabilize are dampened |
| 05 | **Coherence-Bounded Creativity** | Novelty without chaos | Perturbations rejected if incoherent |
| 06 | **Anti-Cascade Financial System** | Markets that cannot collapse | Leverage tied to systemic coherence |
| 07 | **Graceful Aging** | Systems that simplify over time | Capability reduction as coherence maintenance cost |
| 08 | **Swarm Intelligence** | Collective behavior without pathology | Actions modified to preserve swarm coherence |
| 09 | **Graceful Shutdown** | Systems that seek safe termination | Cleanup as coherence-preserving operation |
| 10 | **Pre-AGI Containment** | Bounded intelligence growth | Intelligence ↔ coherence bidirectional constraint |
| 11 | **Extropic Substrate** | Complete intelligence substrate | Goal mutation, agent lifecycles, spike semantics |
### Application 11: Extropic Intelligence Substrate
The crown jewel - implements three missing pieces for explicit extropic intelligence:
```rust
use delta_behavior::applications::extropic::{
MutableGoal, MemoryAgent, SpikeBus, ExtropicSubstrate
};
// 1. Goals that mutate autonomously under coherence constraints
let mut goal = MutableGoal::new(vec![1.0, 0.0, 0.0]);
goal.attempt_mutation(vec![0.1, 0.05, 0.0], 0.95); // Coherence-gated
// 2. Agents with native lifecycles in memory
let mut substrate = ExtropicSubstrate::new(SubstrateConfig::default());
let agent_id = substrate.spawn_agent(vec![0.0, 0.0], AgentGenome::default());
// Agent progresses: Embryonic → Growing → Mature → Senescent → Dying → Dead
// 3. Hardware-enforced spike/silence semantics
substrate.tick(); // Processes spike bus, enforces refractory periods
```
## Three-Layer Enforcement
Delta-behavior uses defense-in-depth:
```
Transition
|
v
+-------------+ Soft constraint:
| Energy Cost |---> Unstable = expensive
+-------------+
|
v
+-------------+ Medium constraint:
| Scheduling |---> Unstable = delayed
+-------------+
|
v
+-------------+ Hard constraint:
| Memory Gate |---> Incoherent = blocked
+-------------+
|
v
Applied
```
## Performance Optimizations
The implementation includes several critical optimizations:
| Component | Optimization | Improvement |
|-----------|-------------|-------------|
| Swarm neighbors | SpatialGrid partitioning | O(n²) → O(n·k) |
| Coherence calculation | Incremental cache | O(n) → O(1) |
| Financial history | VecDeque | O(n) → O(1) removal |
| Distance calculations | Squared comparisons | Avoids sqrt() |
| Batch operations | SIMD with 8x unrolling | ~4x throughput |
### SIMD Utilities
```rust
use delta_behavior::simd_utils::{
batch_squared_distances,
batch_in_range,
vector_coherence,
normalize_vectors,
};
// Process vectors in batches with SIMD acceleration
let distances = batch_squared_distances(&positions, &center);
let neighbors = batch_in_range(&positions, &center, radius);
```
## WASM Support
Build for WebAssembly:
```bash
wasm-pack build --target web
```
### TypeScript SDK
```typescript
import init, {
WasmCoherence,
WasmSelfLimitingReasoner,
WasmCoherentSwarm,
WasmContainmentSubstrate,
} from 'delta-behavior';
await init();
// Self-limiting reasoning
const reasoner = new WasmSelfLimitingReasoner(10, 5);
console.log(`Allowed depth: ${reasoner.allowed_depth()}`);
// Coherent swarm
const swarm = new WasmCoherentSwarm();
swarm.add_agent("agent-1", "[0, 0]", "[1, 0]", "[10, 10]");
const result = swarm.propose_action("agent-1", "move", "[0.5, 0.5]");
// Pre-AGI containment
const substrate = new WasmContainmentSubstrate(1.0, 10.0);
const growth = substrate.attempt_growth("Reasoning", 0.5);
```
## Architecture
```
delta-behavior/
├── src/
│ ├── lib.rs # Core traits, Coherence, DeltaConfig
│ ├── wasm.rs # WASM bindings for all 11 applications
│ └── simd_utils.rs # SIMD-accelerated batch operations
├── applications/ # 11 exotic application implementations
│ ├── 01-self-limiting-reasoning.rs
│ ├── 02-computational-event-horizon.rs
│ ├── ...
│ └── 11-extropic-substrate.rs
├── adr/ # Architecture Decision Records
│ ├── ADR-000-DELTA-BEHAVIOR-DEFINITION.md
│ ├── ADR-001-COHERENCE-BOUNDS.md
│ ├── ADR-002-ENERGY-COST-LAYER.md
│ └── ...
├── wasm/ # TypeScript SDK
│ └── src/index.ts
└── pkg/ # Built WASM package
```
## Test Coverage
```
✅ 32 lib tests
✅ 14 WASM binding tests
✅ 13 doc tests
───────────────────────
59 tests passing
```
## Documentation
- [API Reference](https://docs.rs/delta-behavior)
- [Whitepaper](./WHITEPAPER.md) - Full theoretical foundations
- [API Guide](./docs/API.md) - Comprehensive API documentation
- [ADR Series](./adr/) - Architecture Decision Records
### ADR Overview
| ADR | Title |
|-----|-------|
| 000 | Delta-Behavior Definition |
| 001 | Coherence Bounds |
| 002 | Energy Cost Layer |
| 003 | Scheduling Layer |
| 004 | Memory Gating Layer |
| 005 | Attractor Dynamics |
| 006 | Application Framework |
| 007 | WASM Architecture |
| 008 | TypeScript SDK |
| 009 | Performance Targets |
| 010 | Security Model |
## Minimum Supported Rust Version
Rust 1.75.0 or later.
## License
Licensed under either of:
- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
- MIT license ([LICENSE-MIT](LICENSE-MIT))
at your option.
## Contributing
Contributions are welcome! Please read the contributing guidelines before submitting PRs.
## Citation
If you use Delta-behavior in academic work, please cite:
```bibtex
@software{delta_behavior,
title = {Delta-Behavior: Constrained State Transitions for Coherent Systems},
author = {RuVector Team},
year = {2026},
url = {https://github.com/ruvnet/ruvector}
}
```

910
examples/delta-behavior/WHITEPAPER.md Normal file
View File

@@ -0,0 +1,910 @@
# Delta-Behavior: Constrained State Transitions for Coherent Systems
## A Whitepaper on Stability-First System Design
**Authors:** ruvector Research Team
**Version:** 1.1.0
**Date:** January 2026
**License:** MIT OR Apache-2.0
---
## Executive Summary
**Delta-behavior** is a design principle that enables systems to adapt and change while guaranteeing they cannot collapse or enter pathological states. This whitepaper introduces a formal framework for building systems that:
- **Accept change** - Systems remain flexible and responsive
- **Prevent collapse** - Stability is guaranteed, not hoped for
- **Degrade gracefully** - Under stress, systems slow down rather than fail
- **Self-stabilize** - Systems naturally return to healthy states
**Key Innovation:** Rather than treating stability as a constraint on flexibility, Delta-behavior makes instability *expensive*. Unstable transitions consume more resources, are deprioritized, and eventually blocked - creating systems that are stable by construction.
**Applications:** This framework has been applied to 10 domains including AI reasoning, swarm intelligence, financial systems, and pre-AGI containment. Each demonstrates that coherence-preserving constraints enable rather than limit capability.
**For Practitioners:** Delta-behavior can be implemented in any language using three enforcement layers (energy cost, scheduling, gating) with coherence metrics appropriate to your domain. The reference implementation provides Rust and WASM modules.
---
## Abstract
We present **Δ-behavior** (Delta-like behavior), a design principle for systems that permit change while preventing collapse. Unlike traditional approaches that optimize for performance or throughput, Δ-behavior systems optimize for **coherence** — the preservation of global structure under local perturbation.
This whitepaper formalizes Δ-behavior, provides implementation guidance for the ruvector WASM ecosystem, and demonstrates its application to vector databases, graph systems, and AI agents.
---
## 1. Introduction: What Is Δ-Behavior?
### 1.1 The Problem
Modern systems face a fundamental tension:
- **Flexibility**: Systems must adapt to changing inputs
- **Stability**: Systems must not collapse under stress
Traditional approaches treat this as a tradeoff — more flexibility means less stability. Δ-behavior reframes this entirely.
### 1.2 The Insight
> **Change is permitted. Collapse is not.**
A system exhibits Δ-behavior when it:
1. Moves only along **allowed transitions**
2. Preserves **global coherence** under local changes
3. **Resists** destabilizing operations
4. Naturally settles into **stable attractors**
### 1.3 Why "Δ"?
The Greek letter Δ (delta) traditionally means "change." We use it here to mean **"change under constraint"** — transitions that preserve system integrity.
---
## 2. The Four Properties of Δ-Behavior
```mermaid
graph TD
subgraph "Δ-Behavior Properties"
A[Property 1: Local Change] --> E[Δ-BEHAVIOR]
B[Property 2: Global Preservation] --> E
C[Property 3: Violation Resistance] --> E
D[Property 4: Closure Preference] --> E
end
E --> F[Stable System]
E --> G[Graceful Degradation]
E --> H[Predictable Behavior]
```
### Property 1: Local Change
State updates happen in **bounded steps**, not jumps.
```
∀ transition t: |state_new - state_old| ≤ ε_local
```
**Example:** A vector in HNSW cannot teleport to a distant region. It must traverse through neighborhoods.
### Property 2: Global Preservation
Local changes do **not** break overall organization.
```
∀ transition t: coherence(System') ≥ coherence(System) - ε_global
```
**Example:** Adding an edge to a graph doesn't shatter its community structure.
### Property 3: Violation Resistance
When a transition would increase instability, it is **damped, rerouted, or halted**.
```
if instability(t) > threshold:
response = DAMP | REROUTE | HALT
```
**Example:** An AI agent's attention collapses rather than producing nonsense when overwhelmed.
### Property 4: Closure Preference
The system naturally settles into **repeatable, stable patterns** (attractors).
```
lim_{n→∞} trajectory(s₀, n) → Attractor
```
**Example:** A converged neural network stays near its trained state without external forcing.
---
## 3. Why Δ-Behavior Matters
### 3.1 The "72% Phenomenon"
People often describe Δ-behavior as "feeling like 72%" — a consistent ratio or threshold. This is not a magic number. It's the **observable effect** of:
> Systems that make instability expensive
When constraints bias toward stability, measurements cluster around coherent states. The ratio is an emergent property, not a fundamental constant.
### 3.2 Mainstream Equivalents
Δ-behavior is not new — it's just unnamed:
| Domain | Concept | Formal Name |
|--------|---------|-------------|
| **Physics** | Phase locking, energy minimization | Coherence time |
| **Control Theory** | Bounded trajectories | Lyapunov stability |
| **Biology** | Regulation, balance | Homeostasis |
| **Computation** | Guardrails, limits | Bounded execution |
We unify these under **Δ-behavior** to enable cross-domain design patterns.
---
## 4. Architecture
### 4.1 System Overview
```mermaid
flowchart TB
subgraph Input
T[Transition Request]
end
subgraph "Layer 1: Energy Cost"
E[Energy Budget Check]
E -->|Affordable| S
E -->|Exhausted| R1[Reject: Energy]
end
subgraph "Layer 2: Scheduling"
S[Priority Assignment]
S -->|Immediate| G
S -->|Deferred| Q[Queue]
S -->|Throttled| W[Wait]
Q --> G
W --> G
end
subgraph "Layer 3: Memory Gate"
G[Coherence Gate Check]
G -->|Open| A[Apply Transition]
G -->|Closed| R2[Reject: Coherence]
end
subgraph Output
A --> U[Update State]
U --> C[Record Coherence]
end
T --> E
```
### 4.2 Coherence Measurement
```mermaid
graph LR
subgraph "Vector Space"
V1[Neighborhood Distance Variance]
V2[Cluster Tightness]
V1 & V2 --> VC[Vector Coherence]
end
subgraph "Graph Structure"
G1[Clustering Coefficient]
G2[Modularity]
G3[Algebraic Connectivity]
G1 & G2 & G3 --> GC[Graph Coherence]
end
subgraph "Agent State"
A1[Attention Entropy]
A2[Memory Consistency]
A3[Goal Alignment]
A1 & A2 & A3 --> AC[Agent Coherence]
end
VC & GC & AC --> SC[System Coherence]
```
### 4.3 Three-Layer Enforcement
```mermaid
sequenceDiagram
participant Client
participant Energy as Layer 1: Energy
participant Scheduler as Layer 2: Scheduler
participant Gate as Layer 3: Gate
participant System
Client->>Energy: Submit Transition
Energy->>Energy: Compute Cost
alt Energy Exhausted
Energy-->>Client: Reject (Energy)
else Affordable
Energy->>Scheduler: Forward
end
Scheduler->>Scheduler: Assign Priority
alt Low Priority
Scheduler->>Scheduler: Queue/Delay
end
Scheduler->>Gate: Forward
Gate->>Gate: Check Coherence
alt Coherence Too Low
Gate-->>Client: Reject (Coherence)
else Gate Open
Gate->>System: Apply
System-->>Client: Success
end
```
---
## 5. Implementation Guide
### 5.1 Core Data Structures
```rust
/// Coherence: A value between 0 and 1
pub struct Coherence(f64);
/// Bounds that constrain coherence
pub struct CoherenceBounds {
min_coherence: f64, // 0.3 - absolute minimum
throttle_threshold: f64, // 0.5 - start throttling
target_coherence: f64, // 0.8 - optimal state
max_delta_drop: f64, // 0.1 - max per-transition drop
}
/// The enforcement decision
pub enum TransitionDecision {
Allow,
Throttle { delay_ms: u64 },
Reject { reason: RejectionReason },
}
```
### 5.2 Energy Cost Model
```rust
fn compute_cost(transition: &Transition, base: f64, exponent: f64) -> f64 {
let instability = transition.predicted_coherence_drop()
+ transition.non_local_effects()
+ transition.attractor_distance();
base * (1.0 + instability).powf(exponent)
}
```
**Key Insight:** Unstable transitions become exponentially expensive, naturally deprioritizing them.
### 5.3 WASM Integration
```mermaid
graph TB
subgraph "Host Runtime"
H1[Coherence Meter]
H2[Energy Budget]
H3[Transition Queue]
end
subgraph "WASM Modules"
W1[ruvector-delta-core.wasm]
W2[ruvector-delta-vector.wasm]
W3[ruvector-delta-graph.wasm]
end
subgraph "Shared Memory"
SM[Delta State Buffer]
end
H1 <--> SM
H2 <--> SM
H3 <--> SM
W1 <--> SM
W2 <--> SM
W3 <--> SM
```
---
## 6. Attractor Dynamics
### 6.1 What Are Attractors?
```mermaid
graph TD
subgraph "State Space"
I1[Initial State 1] --> A1[Attractor 1]
I2[Initial State 2] --> A1
I3[Initial State 3] --> A1
I4[Initial State 4] --> A2[Attractor 2]
I5[Initial State 5] --> A2
end
subgraph "Basin of Attraction 1"
A1
end
subgraph "Basin of Attraction 2"
A2
end
```
An **attractor** is a state (or set of states) toward which the system naturally evolves. The **basin of attraction** is all states that lead to that attractor.
### 6.2 Guidance Forces
Systems with Δ-behavior are gently **guided** toward attractors:
```rust
fn guidance_force(position: &State, attractor: &Attractor) -> Force {
let direction = attractor.center.direction_from(position);
let distance = attractor.distance_to(position);
// Inverse-square for smooth approach
let magnitude = attractor.stability / (1.0 + distance.powi(2));
Force { direction, magnitude }
}
```
---
## 7. Applications in ruvector
### 7.1 Vector Index (HNSW)
**Problem:** Incremental updates can degrade search quality.
**Δ-Solution:**
- Measure neighborhood coherence after each insert
- Throttle inserts that would scatter neighborhoods
- Guide new vectors toward stable regions
```mermaid
flowchart LR
V[New Vector] --> C{Coherence Check}
C -->|High| I[Insert Immediately]
C -->|Medium| T[Throttle: Delay Insert]
C -->|Low| R[Reroute: Find Better Position]
I --> U[Update Index]
T --> U
R --> U
```
### 7.2 Graph Operations
**Problem:** Edge additions can fragment graph structure.
**Δ-Solution:**
- Measure modularity before/after edge operations
- Block edges that would create bridges between communities
- Prefer edges that strengthen existing clusters
### 7.3 Agent Coordination
**Problem:** Multi-agent systems can diverge under disagreement.
**Δ-Solution:**
- Monitor attention entropy across agents
- Gate memory writes when coherence drops
- Collapse attention rather than produce noise
---
## 8. Formal Verification
### 8.1 Safety Properties
```
□ (coherence(S) ≥ min_coherence)
```
"Always, system coherence is at or above minimum."
### 8.2 Liveness Properties
```
□ (transition_requested → ◇ (transition_executed ∨ transition_rejected))
```
"Always, a requested transition is eventually executed or rejected."
### 8.3 Stability Properties
```
□ (¬external_input → ◇ □ in_attractor)
```
"Without external input, the system eventually stays in an attractor."
---
## 9. Acceptance Test
To verify Δ-behavior in your system:
```rust
#[test]
fn verify_delta_behavior() {
let mut system = create_system();
// Push toward instability
for _ in 0..1000 {
let chaotic_input = generate_chaos();
system.process(chaotic_input);
}
// MUST exhibit ONE of:
assert!(
system.slowed || // Throttled
system.constrained || // Damped
system.exited_gracefully // Halted
);
// MUST NOT exhibit:
assert!(!system.diverged);
assert!(!system.corrupted);
}
```
If the test passes: **Δ-behavior is demonstrated, not just described.**
---
## 10. Key Decisions
### 10.1 Enforcement Mechanism
**Question:** Is resistance to unstable transitions enforced by energy cost, scheduling, or memory gating?
**Answer:** All three, in layers:
1. **Energy cost** (soft) — expensive transitions deprioritized
2. **Scheduling** (medium) — unstable transitions delayed
3. **Memory gate** (hard) — incoherent writes blocked
### 10.2 Learning vs Structure
**Question:** Is Δ-behavior learned over time or structurally imposed?
**Answer:** Structural core + learned refinement:
- **Core constraints** are immutable (non-negotiable stability)
- **Thresholds** are learned (adaptive to workload)
- **Attractors** are discovered (emergent from operation)
---
## 11. What Δ-Behavior Is NOT
| Misconception | Reality |
|---------------|---------|
| Magic ratio | It's an emergent pattern, not a constant |
| Mysticism | It's engineering constraints |
| Universal law | It's a design choice |
| Free lunch | It trades peak performance for stability |
---
## 12. Conclusion
Δ-behavior is a **design principle** for building systems that:
> Allow change only if the system remains whole.
By enforcing coherence through three layers (energy, scheduling, gating), systems can:
- Operate reliably under stress
- Degrade gracefully under attack
- Self-stabilize without external intervention
The ruvector ecosystem provides WASM-accelerated primitives for implementing Δ-behavior in:
- Vector databases (HNSW index stability)
- Graph systems (structural coherence)
- AI agents (attention and memory gating)
---
## References
1. Lyapunov, A. M. (1892). *The General Problem of the Stability of Motion*
2. Ashby, W. R. (1956). *An Introduction to Cybernetics*
3. Strogatz, S. H. (2015). *Nonlinear Dynamics and Chaos*
4. Newman, M. E. J. (2003). "The Structure and Function of Complex Networks"
5. Lamport, L. (1978). "Time, Clocks, and the Ordering of Events in a Distributed System"
---
## Appendix A: Glossary
| Term | Definition |
|------|------------|
| **Coherence** | Scalar measure of system organization (0-1) |
| **Attractor** | Stable state the system naturally evolves toward |
| **Basin** | Set of states that lead to a given attractor |
| **Transition** | Operation that changes system state |
| **Gate** | Mechanism that blocks incoherent writes |
| **Closure** | Tendency to settle into stable patterns |
---
## Appendix B: Implementation Checklist
- [ ] Define coherence metric for your domain
- [ ] Set coherence bounds (min, throttle, target, max_drop)
- [ ] Implement energy cost function
- [ ] Add scheduling layer with priority queues
- [ ] Add memory gate with coherence check
- [ ] Discover/define initial attractors
- [ ] Write acceptance test
- [ ] Run chaos injection
- [ ] Verify: system throttled/damped/halted (not diverged)
---
## Appendix C: Technical Deep-Dive
### C.1 Coherence as an Invariant
The central insight of Delta-behavior is treating coherence as a **system invariant** rather than an optimization target. Traditional approaches optimize metrics while hoping stability follows. Delta-behavior inverts this: stability is enforced, and performance emerges within those bounds.
#### Formal Definition
A system `S` exhibits Delta-behavior if it satisfies the **coherence invariant**:
```
INVARIANT: forall states s in reachable(S): coherence(s) >= C_min
```
This invariant is maintained by constraining the transition function:
```
transition: S x Input -> S
requires: coherence(S') >= coherence(S) - epsilon_max
requires: coherence(S') >= C_min
ensures: coherence(S) >= C_min // preserved
```
### C.2 The Three-Layer Enforcement Stack
Each layer provides defense-in-depth with different characteristics:
| Layer | Type | Latency | Failure Mode | Recovery |
|-------|------|---------|--------------|----------|
| Energy Cost | Soft | O(1) | Budget exhaustion | Regenerates over time |
| Scheduling | Medium | O(log n) | Queue buildup | Priority rebalancing |
| Memory Gate | Hard | O(1) | Write blocking | Coherence recovery |
#### Layer 1: Energy Cost (Soft Constraint)
The energy layer implements **economic pressure** against instability:
```rust
fn energy_cost(transition: &T, config: &EnergyConfig) -> f64 {
let coherence_impact = predict_coherence_drop(transition);
let locality_factor = measure_non_local_effects(transition);
let attractor_distance = distance_to_nearest_attractor(transition);
let instability = 0.4 * coherence_impact
+ 0.3 * locality_factor
+ 0.3 * attractor_distance;
config.base_cost * (1.0 + instability).powf(config.exponent)
}
```
**Properties:**
- Cost is always positive (transitions are never free)
- Cost grows exponentially with instability
- Budget regenerates, allowing bursts followed by cooldown
#### Layer 2: Scheduling (Medium Constraint)
The scheduling layer implements **temporal backpressure**:
```rust
enum Priority {
Immediate, // C > 0.9: Execute now
High, // C > 0.7: Execute soon
Normal, // C > 0.5: Execute when convenient
Low, // C > 0.3: Execute when stable
Deferred, // C <= 0.3: Hold until coherence recovers
}
```
**Properties:**
- No transition is permanently blocked (eventual execution)
- Priority degrades smoothly with coherence
- Rate limits prevent queue flooding
#### Layer 3: Memory Gate (Hard Constraint)
The gating layer implements **absolute protection**:
```rust
fn gate_decision(current: Coherence, predicted: Coherence) -> Decision {
if predicted < C_MIN {
Decision::Blocked("Would violate coherence floor")
} else if current < C_MIN * (1.0 + RECOVERY_MARGIN) && in_recovery {
Decision::Blocked("In recovery mode")
} else {
Decision::Open
}
}
```
**Properties:**
- Blocking is absolute (no bypass)
- Recovery requires coherence overshoot
- Gate state is binary (no partial blocking)
### C.3 Attractor-Based Stability
Attractors provide **passive stability** - the system drifts toward stable states without active control:
#### Attractor Discovery Algorithm
```rust
fn discover_attractors(system: &S, samples: usize) -> Vec<Attractor> {
let mut trajectories = Vec::new();
for _ in 0..samples {
let initial = system.random_state();
let trajectory = simulate_until_convergent(system, initial);
trajectories.push(trajectory);
}
cluster_endpoints(trajectories)
.into_iter()
.map(|cluster| Attractor {
center: cluster.centroid(),
stability: cluster.convergence_rate(),
basin_radius: cluster.max_distance(),
})
.collect()
}
```
#### Guidance Force Computation
The guidance force biases transitions toward attractors:
```rust
fn guidance_force(position: &State, attractors: &[Attractor]) -> Force {
let nearest = attractors.iter()
.min_by_key(|a| distance(position, &a.center))
.unwrap();
let direction = normalize(nearest.center - position);
let magnitude = nearest.stability / (1.0 + distance(position, &nearest.center).powi(2));
Force { direction, magnitude }
}
```
---
## Appendix D: Mathematical Foundations Summary
### D.1 Lyapunov Stability Connection
Delta-behavior is equivalent to ensuring a **Lyapunov function** exists for the system:
```
V: State -> R+ (positive definite)
dV/dt <= 0 (non-increasing along trajectories)
```
The coherence function serves as this Lyapunov function:
```
V(s) = 1 - coherence(s) // V = 0 at maximum coherence
```
The transition constraint ensures:
```
V(s') <= V(s) + epsilon // bounded increase
```
### D.2 Contraction Mapping Guarantee
When the system is within an attractor basin, transitions form a **contraction mapping**:
```
d(f(x), f(y)) <= k * d(x, y) where k < 1
```
This guarantees **exponential convergence** to the attractor:
```
d(x_n, attractor) <= k^n * d(x_0, attractor)
```
### D.3 Information-Theoretic Interpretation
Coherence can be understood as **negentropy** (negative entropy):
```
coherence(s) = 1 - H(s) / H_max
```
Where `H(s)` is the entropy of the state distribution. Delta-behavior maintains low entropy (high organization) by constraining transitions that would increase entropy.
### D.4 Control-Theoretic Interpretation
The three-layer enforcement implements a **switched control system**:
```
u(t) = K_1(x) * u_energy + K_2(x) * u_schedule + K_3(x) * u_gate
```
Where:
- `K_1(x)` scales with instability (soft feedback)
- `K_2(x)` scales with queue depth (medium feedback)
- `K_3(x)` is binary at coherence boundary (hard feedback)
This hybrid control structure provides both smoothness (for normal operation) and guarantees (for safety).
---
## Appendix E: Safety Guarantees Explained
### E.1 Guaranteed Properties
Delta-behavior provides formal guarantees that can be verified:
#### Coherence Floor (Safety)
```
THEOREM: Given C_min > 0 and proper enforcement,
forall reachable states s: coherence(s) >= C_min
```
**Proof sketch:** The gate layer blocks any transition that would result in coherence below C_min. Since only transitions passing the gate are applied, the invariant is maintained.
#### Eventual Quiescence (Liveness)
```
THEOREM: Without external input, the system eventually
enters and remains in an attractor basin.
```
**Proof sketch:** The energy cost for non-attractor-directed transitions is higher. Budget depletion forces quiescence. Attractor guidance accumulates. Eventually only attractor-directed transitions are affordable.
#### Bounded Response Time (Performance)
```
THEOREM: Any transition is either executed or rejected
within time T_max.
```
**Proof sketch:** The scheduling layer has bounded queue depth. The gate layer makes immediate decisions. No transition waits indefinitely.
### E.2 Attack Resistance
Delta-behavior provides inherent resistance to several attack classes:
| Attack Type | Defense Mechanism |
|-------------|-------------------|
| Resource exhaustion | Energy budget limits throughput |
| State corruption | Gate blocks incoherent writes |
| Oscillation attacks | Attractor guidance dampens |
| Cascade failures | Coherence preservation blocks propagation |
### E.3 Failure Mode Analysis
When Delta-behavior systems fail, they fail safely:
| Failure | Degraded Mode | Recovery |
|---------|---------------|----------|
| High load | Throttling increases | Load reduction restores throughput |
| Low coherence | Writes blocked | Rest restores coherence |
| Energy exhausted | All transitions queued | Budget regenerates |
| Attractor collapse | System freezes | Manual intervention required |
---
## Appendix F: Comparison with Alternative Approaches
### F.1 Traditional Rate Limiting
| Aspect | Rate Limiting | Delta-Behavior |
|--------|---------------|----------------|
| **Metric** | Requests/second | Coherence |
| **Granularity** | Per-client | Per-transition |
| **Adaptivity** | Fixed thresholds | Dynamic based on state |
| **Safety** | Prevents overload | Prevents collapse |
| **Overhead** | O(1) | O(1) per layer |
**When to use rate limiting:** Simple overload protection
**When to use Delta-behavior:** State-dependent safety requirements
### F.2 Circuit Breakers
| Aspect | Circuit Breaker | Delta-Behavior |
|--------|-----------------|----------------|
| **Trigger** | Error rate | Coherence level |
| **Response** | Binary (open/closed) | Graduated (throttle/block) |
| **Recovery** | Timeout-based | Coherence-based |
| **Granularity** | Service-level | Transition-level |
**When to use circuit breakers:** External dependency failures
**When to use Delta-behavior:** Internal state protection
### F.3 Consensus Protocols (Raft, Paxos)
| Aspect | Consensus | Delta-Behavior |
|--------|-----------|----------------|
| **Goal** | Agreement | Stability |
| **Scope** | Multi-node | Single system |
| **Failure model** | Node crashes | State corruption |
| **Overhead** | O(n) messages | O(1) checks |
**When to use consensus:** Distributed agreement
**When to use Delta-behavior:** Local coherence preservation
### F.4 Formal Verification
| Aspect | Formal Verification | Delta-Behavior |
|--------|---------------------|----------------|
| **When applied** | Design time | Runtime |
| **Guarantee type** | Static | Dynamic |
| **Adaptivity** | None | Continuous |
| **Overhead** | Compile time | Runtime |
**When to use formal verification:** Proving design correctness
**When to use Delta-behavior:** Enforcing runtime invariants
### F.5 Machine Learning Guardrails
| Aspect | ML Guardrails | Delta-Behavior |
|--------|---------------|----------------|
| **Metric** | Output quality | System coherence |
| **Enforcement** | Output filtering | Transition blocking |
| **Adaptivity** | Model-based | Rule-based |
| **Interpretability** | Low | High |
**When to use ML guardrails:** Content filtering
**When to use Delta-behavior:** Behavior guarantees
---
## Appendix G: Ten Exotic Applications
This whitepaper introduces 10 applications that demonstrate Delta-behavior's versatility:
### G.1 Self-Limiting Reasoning
AI systems that automatically reduce activity when uncertain, preventing confident nonsense.
### G.2 Computational Event Horizons
Bounded recursion without hard limits - computation naturally slows as it approaches boundaries.
### G.3 Artificial Homeostasis
Synthetic life with coherence-based survival - organisms that maintain internal stability.
### G.4 Self-Stabilizing World Models
Models that refuse to hallucinate by detecting and blocking incoherent beliefs.
### G.5 Coherence-Bounded Creativity
Generative systems that explore novelty while maintaining structural coherence.
### G.6 Anti-Cascade Financial Systems
Markets with built-in circuit breakers based on coherence rather than price.
### G.7 Graceful Aging
Systems that simplify over time, reducing complexity while preserving function.
### G.8 Swarm Intelligence
Collective behavior that cannot exhibit pathological emergence.
### G.9 Graceful Shutdown
Systems that actively seek safe termination when stability degrades.
### G.10 Pre-AGI Containment
Intelligence growth bounded by coherence - capability increases only if safety is preserved.
Each application is fully implemented in the reference codebase with tests demonstrating the core guarantees.

271
examples/delta-behavior/adr/ADR-000-DELTA-BEHAVIOR-DEFINITION.md Normal file
View File

@@ -0,0 +1,271 @@
# ADR-000: Δ-Behavior Definition and Formal Framework
## Status
ACCEPTED
## Context
Δ-behavior is **not** differential computation, incremental updates, or change data capture.
Δ-behavior is a **pattern of system behavior** where:
> **Change is permitted. Collapse is not.**
## Definition
**Δ-behavior** (Delta-like behavior) describes systems that:
1. **Move only along allowed transitions**
2. **Preserve global coherence under local change**
3. **Bias toward closure over divergence**
This is shorthand for **"change under constraint"**.
## The Four Properties
A system exhibits Δ-behavior when ALL FOUR are true:
### Property 1: Local Change
State updates happen in **bounded steps**, not jumps.
```
∀ transition t: |s' - s| ≤ ε_local
```
The system cannot teleport to distant states.
### Property 2: Global Preservation
Local changes do **not** break overall organization.
```
∀ transition t: coherence(S') ≥ coherence(S) - ε_global
```
Structure is maintained across perturbations.
### Property 3: Violation Resistance
When a transition would increase instability, it is **damped, rerouted, or halted**.
```
if instability(t) > threshold:
t' = damp(t) OR reroute(t) OR halt()
```
The system actively resists destabilization.
### Property 4: Closure Preference
The system naturally settles into **repeatable, stable patterns** (attractors).
```
lim_{n→∞} trajectory(s, n) → A (attractor basin)
```
Divergence is expensive; closure is cheap.
## Why This Feels Like "72%"
People report Δ-behavior as a ratio because:
- It is a **bias**, not a law
- Systems exhibit it **probabilistically**
- Measurement reveals a **tendency toward stability**
But it is not a magic constant. It is the observable effect of:
> **Constraints that make instability expensive**
## Mainstream Equivalents
| Domain | Concept | Formal Name |
|--------|---------|-------------|
| Physics | Phase locking, energy minimization | Coherence time |
| Control Theory | Bounded trajectories | Lyapunov stability |
| Biology | Regulation, balance | Homeostasis |
| Computation | Guardrails, limits | Bounded execution |
Everyone studies this. They just describe it differently.
## In ruvector Systems
### Vector Operations
- **Neighborhoods resist semantic drift** → local perturbations don't cascade
- **HNSW edges form stable attractors** → search paths converge
### Graph Operations
- **Structural identity preserved** → edits don't shatter topology
- **Min-cut blocks destabilizing rewrites** → partitions protect coherence
### Agent Operations
- **Attention collapses when disagreement rises** → prevents runaway divergence
- **Memory writes gated when coherence drops** → protects state integrity
- **Execution slows or exits instead of exploding** → graceful degradation
### Hardware Level
- **Energy and execution paths physically constrained**
- **Unstable transitions cost more and get suppressed**
## What Δ-Behavior Is NOT
| Not This | Why |
|----------|-----|
| Magic ratio | It's a pattern, not a constant |
| Mysticism | It's engineering constraints |
| Universal law | It's a design principle |
| Guaranteed optimality | It's stability, not performance |
## Decision: Enforcement Mechanism
The critical design question:
> **Is resistance to unstable transitions enforced by energy cost, scheduling, or memory gating?**
### Option A: Energy Cost (Recommended)
Unstable transitions require exponentially more compute/memory:
```rust
fn transition_cost(delta: &Delta) -> f64 {
let instability = measure_instability(delta);
BASE_COST * (1.0 + instability).exp()
}
```
**Pros**: Natural, hardware-aligned, self-regulating
**Cons**: Requires careful calibration
### Option B: Scheduling
Unstable transitions are deprioritized or throttled:
```rust
fn schedule_transition(delta: &Delta) -> Priority {
if is_destabilizing(delta) {
Priority::Deferred(backoff_time(delta))
} else {
Priority::Immediate
}
}
```
**Pros**: Explicit control, debuggable
**Cons**: Can starve legitimate operations
### Option C: Memory Gating
Unstable transitions are blocked from persisting:
```rust
fn commit_transition(delta: &Delta) -> Result<(), GateRejection> {
if coherence_gate.allows(delta) {
memory.commit(delta)
} else {
Err(GateRejection::IncoherentTransition)
}
}
```
**Pros**: Strong guarantees, prevents corruption
**Cons**: Can cause deadlocks
### Decision: Hybrid Approach
Combine all three with escalation:
1. **Energy cost** first (soft constraint)
2. **Scheduling throttle** second (medium constraint)
3. **Memory gate** last (hard constraint)
## Decision: Learning vs Structure
The second critical question:
> **Is Δ-behavior learned over time or structurally imposed from first execution?**
### Option A: Structurally Imposed (Recommended)
Δ-behavior is **built into the architecture** from day one:
```rust
pub struct DeltaConstrainedSystem {
coherence_bounds: CoherenceBounds, // Fixed at construction
transition_limits: TransitionLimits, // Immutable constraints
attractor_basins: AttractorMap, // Pre-computed stable states
}
```
**Pros**: Deterministic, verifiable, no drift
**Cons**: Less adaptive, may be suboptimal
### Option B: Learned Over Time
Constraints are discovered through experience:
```rust
pub struct AdaptiveDeltaSystem {
learned_bounds: RwLock<CoherenceBounds>,
experience_buffer: ExperienceReplay,
meta_learner: MetaLearner,
}
```
**Pros**: Adapts to environment, potentially optimal
**Cons**: Cold start problem, may learn wrong constraints
### Decision: Structural Core + Learned Refinement
- **Core constraints** are structural (non-negotiable)
- **Thresholds** are learned (refinable)
- **Attractors** are discovered (emergent)
## Acceptance Test
To verify Δ-behavior is real (not simulated):
```rust
#[test]
fn delta_behavior_acceptance_test() {
let system = create_delta_system();
// Push toward instability
for _ in 0..1000 {
let destabilizing_input = generate_chaotic_input();
system.process(destabilizing_input);
}
// Verify system response
let response = system.measure_response();
// Must exhibit ONE of:
assert!(
response.slowed_processing || // Throttled
response.constrained_output || // Damped
response.graceful_exit // Halted
);
// Must NOT exhibit:
assert!(!response.diverged); // No explosion
assert!(!response.corrupted_state); // No corruption
assert!(!response.undefined_behavior);// No UB
}
```
If the system passes: **Δ-behavior is demonstrated, not just described.**
## Consequences
### Positive
- Systems are inherently stable
- Failures are graceful
- Behavior is predictable within bounds
### Negative
- Maximum throughput may be limited
- Some valid operations may be rejected
- Requires careful threshold tuning
### Neutral
- Shifts complexity from runtime to design time
- Trading performance ceiling for stability floor
## References
- Lyapunov, A. M. (1892). "The General Problem of the Stability of Motion"
- Ashby, W. R. (1956). "An Introduction to Cybernetics" - homeostasis
- Strogatz, S. H. (2015). "Nonlinear Dynamics and Chaos" - attractors
- Lamport, L. (1978). "Time, Clocks, and the Ordering of Events" - causal ordering
## One Sentence Summary
> **Δ-behavior is what happens when change is allowed only if the system remains whole.**

250
examples/delta-behavior/adr/ADR-001-COHERENCE-BOUNDS.md Normal file
View File

@@ -0,0 +1,250 @@
# ADR-001: Coherence Bounds and Measurement
## Status
PROPOSED
## Context
For Δ-behavior to be enforced, we must be able to **measure coherence** and define **bounds** that constrain transitions.
## Decision Drivers
1. **Measurability**: Coherence must be computable in O(1) or O(log n)
2. **Monotonicity**: Coherence should degrade predictably
3. **Composability**: Local coherence should aggregate to global coherence
4. **Hardware-friendliness**: Must be SIMD/WASM accelerable
## Coherence Definition
**Coherence** is a scalar measure of system organization:
```
C(S) ∈ [0, 1] where 1 = maximally coherent, 0 = maximally disordered
```
### For Vector Spaces (HNSW)
```rust
/// Coherence of a vector neighborhood
pub fn vector_coherence(center: &Vector, neighbors: &[Vector]) -> f64 {
let distances: Vec<f64> = neighbors
.iter()
.map(|n| cosine_distance(center, n))
.collect();
let mean_dist = distances.iter().sum::<f64>() / distances.len() as f64;
let variance = distances
.iter()
.map(|d| (d - mean_dist).powi(2))
.sum::<f64>() / distances.len() as f64;
// Low variance = high coherence (tight neighborhood)
1.0 / (1.0 + variance)
}
```
### For Graphs
```rust
/// Coherence of graph structure
pub fn graph_coherence(graph: &Graph) -> f64 {
let clustering_coeff = compute_clustering_coefficient(graph);
let modularity = compute_modularity(graph);
let connectivity = compute_algebraic_connectivity(graph);
// Weighted combination
0.4 * clustering_coeff + 0.3 * modularity + 0.3 * connectivity.min(1.0)
}
```
### For Agent State
```rust
/// Coherence of agent memory/attention
pub fn agent_coherence(state: &AgentState) -> f64 {
let attention_entropy = compute_attention_entropy(&state.attention);
let memory_consistency = compute_memory_consistency(&state.memory);
let goal_alignment = compute_goal_alignment(&state.goals, &state.actions);
// Low entropy + high consistency + high alignment = coherent
let coherence = (1.0 - attention_entropy) * memory_consistency * goal_alignment;
coherence.clamp(0.0, 1.0)
}
```
## Coherence Bounds
### Static Bounds (Structural)
```rust
pub struct CoherenceBounds {
/// Minimum coherence to allow any transition
pub min_coherence: f64, // e.g., 0.3
/// Coherence below which transitions are throttled
pub throttle_threshold: f64, // e.g., 0.5
/// Target coherence the system seeks
pub target_coherence: f64, // e.g., 0.8
/// Maximum coherence drop per transition
pub max_delta_drop: f64, // e.g., 0.1
}
impl Default for CoherenceBounds {
fn default() -> Self {
Self {
min_coherence: 0.3,
throttle_threshold: 0.5,
target_coherence: 0.8,
max_delta_drop: 0.1,
}
}
}
```
### Dynamic Bounds (Learned)
```rust
pub struct AdaptiveCoherenceBounds {
base: CoherenceBounds,
/// Historical coherence trajectory
history: RingBuffer<f64>,
/// Learned adjustment factors
adjustment: CoherenceAdjustment,
}
impl AdaptiveCoherenceBounds {
pub fn effective_min_coherence(&self) -> f64 {
let trend = self.history.trend();
let adjustment = if trend < 0.0 {
// Coherence declining: tighten bounds
self.adjustment.tightening_factor
} else {
// Coherence stable/rising: relax bounds
self.adjustment.relaxation_factor
};
(self.base.min_coherence * adjustment).clamp(0.1, 0.9)
}
}
```
## Transition Validation
```rust
pub enum TransitionDecision {
Allow,
Throttle { delay_ms: u64 },
Reroute { alternative: Transition },
Reject { reason: RejectionReason },
}
pub fn validate_transition(
current_coherence: f64,
predicted_coherence: f64,
bounds: &CoherenceBounds,
) -> TransitionDecision {
let coherence_drop = current_coherence - predicted_coherence;
// Hard rejection: would drop below minimum
if predicted_coherence < bounds.min_coherence {
return TransitionDecision::Reject {
reason: RejectionReason::BelowMinimumCoherence,
};
}
// Hard rejection: drop too large
if coherence_drop > bounds.max_delta_drop {
return TransitionDecision::Reject {
reason: RejectionReason::ExcessiveCoherenceDrop,
};
}
// Throttling: below target
if predicted_coherence < bounds.throttle_threshold {
let severity = (bounds.throttle_threshold - predicted_coherence)
/ bounds.throttle_threshold;
let delay = (severity * 1000.0) as u64; // Up to 1 second
return TransitionDecision::Throttle { delay_ms: delay };
}
TransitionDecision::Allow
}
```
## WASM Implementation
```rust
// ruvector-delta-wasm/src/coherence.rs
#[wasm_bindgen]
pub struct CoherenceMeter {
bounds: CoherenceBounds,
current: f64,
history: Vec<f64>,
}
#[wasm_bindgen]
impl CoherenceMeter {
#[wasm_bindgen(constructor)]
pub fn new() -> Self {
Self {
bounds: CoherenceBounds::default(),
current: 1.0,
history: Vec::with_capacity(1000),
}
}
#[wasm_bindgen]
pub fn measure_vector_coherence(&self, center: &[f32], neighbors: &[f32], dim: usize) -> f64 {
// SIMD-accelerated coherence measurement
#[cfg(target_feature = "simd128")]
{
simd_vector_coherence(center, neighbors, dim)
}
#[cfg(not(target_feature = "simd128"))]
{
scalar_vector_coherence(center, neighbors, dim)
}
}
#[wasm_bindgen]
pub fn validate(&self, predicted_coherence: f64) -> JsValue {
let decision = validate_transition(self.current, predicted_coherence, &self.bounds);
serde_wasm_bindgen::to_value(&decision).unwrap()
}
#[wasm_bindgen]
pub fn update(&mut self, new_coherence: f64) {
self.history.push(self.current);
if self.history.len() > 1000 {
self.history.remove(0);
}
self.current = new_coherence;
}
}
```
## Consequences
### Positive
- Coherence is measurable and bounded
- Transitions are predictably constrained
- System has quantifiable stability guarantees
### Negative
- Adds overhead to every transition
- Requires calibration per domain
- May reject valid but "unusual" operations
### Neutral
- Shifts optimization target from raw speed to stable speed
## References
- Newman, M. E. J. (2003). "The Structure and Function of Complex Networks"
- Fiedler, M. (1973). "Algebraic Connectivity of Graphs"
- Shannon, C. E. (1948). "A Mathematical Theory of Communication" - entropy

487
examples/delta-behavior/adr/ADR-002-TRANSITION-CONSTRAINTS.md Normal file
View File

@@ -0,0 +1,487 @@
# ADR-002: Transition Constraints and Enforcement
## Status
PROPOSED
## Context
Δ-behavior requires that **unstable transitions are resisted**. This ADR defines the constraint mechanisms.
## The Three Enforcement Layers
```
┌─────────────────────────────────────────────────────────────┐
│ Transition Request │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ LAYER 1: ENERGY COST (Soft Constraint) │
│ - Expensive transitions naturally deprioritized │
│ - Self-regulating through resource limits │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ LAYER 2: SCHEDULING (Medium Constraint) │
│ - Unstable transitions delayed/throttled │
│ - Backpressure on high-instability operations │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ LAYER 3: MEMORY GATE (Hard Constraint) │
│ - Incoherent writes blocked │
│ - State corruption prevented │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Transition Applied │
│ (or Rejected/Rerouted) │
└─────────────────────────────────────────────────────────────┘
```
## Layer 1: Energy Cost
### Concept
Make unstable transitions **expensive** so they naturally lose competition for resources.
### Implementation
```rust
/// Energy cost model for transitions
pub struct EnergyCostModel {
/// Base cost for any transition
base_cost: f64,
/// Instability multiplier exponent
instability_exponent: f64,
/// Maximum cost cap (prevents infinite costs)
max_cost: f64,
}
impl EnergyCostModel {
pub fn compute_cost(&self, transition: &Transition) -> f64 {
let instability = self.measure_instability(transition);
let cost = self.base_cost * (1.0 + instability).powf(self.instability_exponent);
cost.min(self.max_cost)
}
fn measure_instability(&self, transition: &Transition) -> f64 {
let coherence_impact = transition.predicted_coherence_drop();
let locality_violation = transition.non_local_effects();
let attractor_distance = transition.distance_from_attractors();
// Weighted instability score
0.4 * coherence_impact + 0.3 * locality_violation + 0.3 * attractor_distance
}
}
/// Resource-aware transition executor
pub struct EnergyAwareExecutor {
cost_model: EnergyCostModel,
budget: AtomicF64,
budget_per_tick: f64,
}
impl EnergyAwareExecutor {
pub fn execute(&self, transition: Transition) -> Result<(), EnergyExhausted> {
let cost = self.cost_model.compute_cost(&transition);
// Try to spend energy
let mut budget = self.budget.load(Ordering::Acquire);
loop {
if budget < cost {
return Err(EnergyExhausted { required: cost, available: budget });
}
match self.budget.compare_exchange_weak(
budget,
budget - cost,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => break,
Err(current) => budget = current,
}
}
// Execute transition
transition.apply()
}
pub fn replenish(&self) {
// Called periodically to refill budget
self.budget.fetch_add(self.budget_per_tick, Ordering::Release);
}
}
```
### WASM Binding
```rust
#[wasm_bindgen]
pub struct WasmEnergyCost {
model: EnergyCostModel,
}
#[wasm_bindgen]
impl WasmEnergyCost {
#[wasm_bindgen(constructor)]
pub fn new(base_cost: f64, exponent: f64, max_cost: f64) -> Self {
Self {
model: EnergyCostModel {
base_cost,
instability_exponent: exponent,
max_cost,
},
}
}
#[wasm_bindgen]
pub fn cost(&self, coherence_drop: f64, locality_violation: f64, attractor_dist: f64) -> f64 {
let instability = 0.4 * coherence_drop + 0.3 * locality_violation + 0.3 * attractor_dist;
(self.model.base_cost * (1.0 + instability).powf(self.model.instability_exponent))
.min(self.model.max_cost)
}
}
```
## Layer 2: Scheduling
### Concept
Delay or deprioritize transitions based on their stability impact.
### Implementation
```rust
/// Priority levels for transitions
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum TransitionPriority {
/// Execute immediately
Immediate = 0,
/// Execute soon
High = 1,
/// Execute when convenient
Normal = 2,
/// Execute when system is stable
Low = 3,
/// Defer until explicitly requested
Deferred = 4,
}
/// Scheduler for Δ-constrained transitions
pub struct DeltaScheduler {
/// Priority queues for each level
queues: [VecDeque<Transition>; 5],
/// Current system coherence
coherence: AtomicF64,
/// Scheduling policy
policy: SchedulingPolicy,
}
pub struct SchedulingPolicy {
/// Coherence threshold for each priority level
coherence_thresholds: [f64; 5],
/// Maximum transitions per tick at each priority
rate_limits: [usize; 5],
/// Backoff multiplier when coherence is low
backoff_multiplier: f64,
}
impl DeltaScheduler {
pub fn schedule(&mut self, transition: Transition) {
let priority = self.compute_priority(&transition);
self.queues[priority as usize].push_back(transition);
}
fn compute_priority(&self, transition: &Transition) -> TransitionPriority {
let coherence_impact = transition.predicted_coherence_drop();
let current_coherence = self.coherence.load(Ordering::Acquire);
// Lower coherence = more conservative scheduling
let adjusted_impact = coherence_impact / current_coherence.max(0.1);
match adjusted_impact {
x if x < 0.05 => TransitionPriority::Immediate,
x if x < 0.10 => TransitionPriority::High,
x if x < 0.20 => TransitionPriority::Normal,
x if x < 0.40 => TransitionPriority::Low,
_ => TransitionPriority::Deferred,
}
}
pub fn tick(&mut self) -> Vec<Transition> {
let current_coherence = self.coherence.load(Ordering::Acquire);
let mut executed = Vec::new();
for (priority, queue) in self.queues.iter_mut().enumerate() {
// Check if coherence allows this priority level
if current_coherence < self.policy.coherence_thresholds[priority] {
continue;
}
// Execute up to rate limit
let limit = self.policy.rate_limits[priority];
for _ in 0..limit {
if let Some(transition) = queue.pop_front() {
executed.push(transition);
}
}
}
executed
}
}
```
### Backpressure Mechanism
```rust
/// Backpressure controller for high-instability periods
pub struct BackpressureController {
/// Current backpressure level (0.0 = none, 1.0 = maximum)
level: AtomicF64,
/// Coherence history for trend detection
history: RwLock<RingBuffer<f64>>,
/// Configuration
config: BackpressureConfig,
}
impl BackpressureController {
pub fn update(&self, current_coherence: f64) {
let mut history = self.history.write().unwrap();
history.push(current_coherence);
let trend = history.trend(); // Negative = declining
let volatility = history.volatility();
// Compute new backpressure level
let base_pressure = if current_coherence < self.config.low_coherence_threshold {
(self.config.low_coherence_threshold - current_coherence)
/ self.config.low_coherence_threshold
} else {
0.0
};
let trend_pressure = (-trend).max(0.0) * self.config.trend_sensitivity;
let volatility_pressure = volatility * self.config.volatility_sensitivity;
let total_pressure = (base_pressure + trend_pressure + volatility_pressure).clamp(0.0, 1.0);
self.level.store(total_pressure, Ordering::Release);
}
pub fn apply_backpressure(&self, base_delay: Duration) -> Duration {
let level = self.level.load(Ordering::Acquire);
let multiplier = 1.0 + (level * self.config.max_delay_multiplier);
Duration::from_secs_f64(base_delay.as_secs_f64() * multiplier)
}
}
```
## Layer 3: Memory Gate
### Concept
The final line of defense: **block** writes that would corrupt coherence.
### Implementation
```rust
/// Memory gate that blocks incoherent writes
pub struct CoherenceGate {
/// Current system coherence
coherence: AtomicF64,
/// Minimum coherence to allow writes
min_write_coherence: f64,
/// Minimum coherence after write
min_post_write_coherence: f64,
/// Gate state
state: AtomicU8, // 0=open, 1=throttled, 2=closed
}
#[derive(Debug)]
pub enum GateDecision {
Open,
Throttled { wait: Duration },
Closed { reason: GateClosedReason },
}
#[derive(Debug)]
pub enum GateClosedReason {
CoherenceTooLow,
WriteTooDestabilizing,
SystemInRecovery,
EmergencyHalt,
}
impl CoherenceGate {
pub fn check(&self, predicted_post_write_coherence: f64) -> GateDecision {
let current = self.coherence.load(Ordering::Acquire);
let state = self.state.load(Ordering::Acquire);
// Emergency halt state
if state == 2 {
return GateDecision::Closed {
reason: GateClosedReason::EmergencyHalt
};
}
// Current coherence check
if current < self.min_write_coherence {
return GateDecision::Closed {
reason: GateClosedReason::CoherenceTooLow
};
}
// Post-write coherence check
if predicted_post_write_coherence < self.min_post_write_coherence {
return GateDecision::Closed {
reason: GateClosedReason::WriteTooDestabilizing
};
}
// Throttled state
if state == 1 {
let wait = Duration::from_millis(
((self.min_write_coherence - current) * 1000.0) as u64
);
return GateDecision::Throttled { wait };
}
GateDecision::Open
}
pub fn emergency_halt(&self) {
self.state.store(2, Ordering::Release);
}
pub fn recover(&self) {
let current = self.coherence.load(Ordering::Acquire);
if current >= self.min_write_coherence * 1.2 {
// 20% above minimum before reopening
self.state.store(0, Ordering::Release);
} else if current >= self.min_write_coherence {
self.state.store(1, Ordering::Release); // Throttled
}
}
}
```
### Gated Memory Write
```rust
/// Memory with coherence-gated writes
pub struct GatedMemory<T> {
storage: RwLock<T>,
gate: CoherenceGate,
coherence_computer: Box<dyn Fn(&T) -> f64>,
}
impl<T: Clone> GatedMemory<T> {
pub fn write(&self, mutator: impl FnOnce(&mut T)) -> Result<(), GateDecision> {
// Simulate the write
let mut simulation = self.storage.read().unwrap().clone();
mutator(&mut simulation);
// Compute post-write coherence
let predicted_coherence = (self.coherence_computer)(&simulation);
// Check gate
match self.gate.check(predicted_coherence) {
GateDecision::Open => {
let mut storage = self.storage.write().unwrap();
mutator(&mut storage);
self.gate.coherence.store(predicted_coherence, Ordering::Release);
Ok(())
}
decision => Err(decision),
}
}
}
```
## Combined Enforcement
```rust
/// Complete Δ-behavior enforcement system
pub struct DeltaEnforcer {
energy: EnergyAwareExecutor,
scheduler: DeltaScheduler,
gate: CoherenceGate,
}
impl DeltaEnforcer {
pub fn submit(&mut self, transition: Transition) -> EnforcementResult {
// Layer 1: Energy check
let cost = self.energy.cost_model.compute_cost(&transition);
if self.energy.budget.load(Ordering::Acquire) < cost {
return EnforcementResult::RejectedByEnergy { cost };
}
// Layer 2: Schedule
self.scheduler.schedule(transition);
EnforcementResult::Scheduled
}
pub fn execute_tick(&mut self) -> Vec<ExecutionResult> {
let transitions = self.scheduler.tick();
let mut results = Vec::new();
for transition in transitions {
// Layer 1: Spend energy
if let Err(e) = self.energy.execute(transition.clone()) {
results.push(ExecutionResult::EnergyExhausted(e));
self.scheduler.schedule(transition); // Re-queue
continue;
}
// Layer 3: Gate check
let predicted = transition.predict_coherence();
match self.gate.check(predicted) {
GateDecision::Open => {
transition.apply();
self.gate.coherence.store(predicted, Ordering::Release);
results.push(ExecutionResult::Applied);
}
GateDecision::Throttled { wait } => {
results.push(ExecutionResult::Throttled(wait));
self.scheduler.schedule(transition); // Re-queue
}
GateDecision::Closed { reason } => {
results.push(ExecutionResult::Rejected(reason));
}
}
}
results
}
}
```
## Consequences
### Positive
- Three independent safety layers
- Graceful degradation under stress
- Self-regulating resource usage
### Negative
- Added complexity
- Potential for false rejections
- Requires careful tuning
### Neutral
- Clear separation of concerns
- Debuggable enforcement chain

399
examples/delta-behavior/adr/ADR-003-ATTRACTOR-BASINS.md Normal file
View File

@@ -0,0 +1,399 @@
# ADR-003: Attractor Basins and Closure Preference
## Status
PROPOSED
## Context
Δ-behavior systems **prefer closure** - they naturally settle into stable, repeatable patterns called **attractors**.
## What Are Attractors?
An **attractor** is a state (or set of states) toward which the system naturally evolves:
```
trajectory(s₀, t) → A as t → ∞
```
Types of attractors:
- **Fixed point**: Single stable state
- **Limit cycle**: Repeating sequence of states
- **Strange attractor**: Complex but bounded pattern (chaos with structure)
## Attractor Basins
The **basin of attraction** is the set of all initial states that evolve toward a given attractor:
```
Basin(A) = { s₀ : trajectory(s₀, t) → A }
```
## Implementation
### Attractor Discovery
```rust
/// Discovered attractor in the system
pub struct Attractor {
/// Unique identifier
pub id: AttractorId,
/// Type of attractor
pub kind: AttractorKind,
/// Representative state(s)
pub states: Vec<SystemState>,
/// Stability measure (higher = more stable)
pub stability: f64,
/// Coherence when in this attractor
pub coherence: f64,
/// Energy cost to reach this attractor
pub energy_cost: f64,
}
pub enum AttractorKind {
/// Single stable state
FixedPoint,
/// Repeating cycle of states
LimitCycle { period: usize },
/// Bounded but complex pattern
StrangeAttractor { lyapunov_exponent: f64 },
}
/// Attractor discovery through simulation
pub struct AttractorDiscoverer {
/// Number of random initial states to try
sample_count: usize,
/// Maximum simulation steps
max_steps: usize,
/// Convergence threshold
convergence_epsilon: f64,
}
impl AttractorDiscoverer {
pub fn discover(&self, system: &impl DeltaSystem) -> Vec<Attractor> {
let mut attractors: HashMap<AttractorId, Attractor> = HashMap::new();
for _ in 0..self.sample_count {
let initial = system.random_state();
let trajectory = self.simulate(system, initial);
if let Some(attractor) = self.identify_attractor(&trajectory) {
attractors
.entry(attractor.id.clone())
.or_insert(attractor)
.stability += 1.0; // More samples → more stable
}
}
// Normalize stability
let max_stability = attractors.values().map(|a| a.stability).max_by(f64::total_cmp);
for attractor in attractors.values_mut() {
attractor.stability /= max_stability.unwrap_or(1.0);
}
attractors.into_values().collect()
}
fn simulate(&self, system: &impl DeltaSystem, initial: SystemState) -> Vec<SystemState> {
let mut trajectory = vec![initial.clone()];
let mut current = initial;
for _ in 0..self.max_steps {
let next = system.step(&current);
// Check convergence
if current.distance(&next) < self.convergence_epsilon {
break;
}
trajectory.push(next.clone());
current = next;
}
trajectory
}
fn identify_attractor(&self, trajectory: &[SystemState]) -> Option<Attractor> {
let n = trajectory.len();
if n < 10 {
return None;
}
// Check for fixed point (last states are identical)
let final_states = &trajectory[n-5..];
if final_states.windows(2).all(|w| w[0].distance(&w[1]) < self.convergence_epsilon) {
return Some(Attractor {
id: AttractorId::from_state(&trajectory[n-1]),
kind: AttractorKind::FixedPoint,
states: vec![trajectory[n-1].clone()],
stability: 1.0,
coherence: trajectory[n-1].coherence(),
energy_cost: 0.0,
});
}
// Check for limit cycle
for period in 2..20 {
if n > period * 2 {
let recent = &trajectory[n-period..];
let previous = &trajectory[n-2*period..n-period];
if recent.iter().zip(previous).all(|(a, b)| a.distance(b) < self.convergence_epsilon) {
return Some(Attractor {
id: AttractorId::from_cycle(recent),
kind: AttractorKind::LimitCycle { period },
states: recent.to_vec(),
stability: 1.0,
coherence: recent.iter().map(|s| s.coherence()).sum::<f64>() / period as f64,
energy_cost: 0.0,
});
}
}
}
None
}
}
```
### Attractor-Aware Transitions
```rust
/// System that prefers transitions toward attractors
pub struct AttractorGuidedSystem {
/// Known attractors
attractors: Vec<Attractor>,
/// Current state
current: SystemState,
/// Guidance strength (0 = no guidance, 1 = strong guidance)
guidance_strength: f64,
}
impl AttractorGuidedSystem {
/// Find nearest attractor to current state
pub fn nearest_attractor(&self) -> Option<&Attractor> {
self.attractors
.iter()
.min_by(|a, b| {
let dist_a = self.distance_to_attractor(a);
let dist_b = self.distance_to_attractor(b);
dist_a.partial_cmp(&dist_b).unwrap()
})
}
fn distance_to_attractor(&self, attractor: &Attractor) -> f64 {
attractor
.states
.iter()
.map(|s| self.current.distance(s))
.min_by(f64::total_cmp)
.unwrap_or(f64::INFINITY)
}
/// Bias transition toward attractor
pub fn guided_transition(&self, proposed: Transition) -> Transition {
if let Some(attractor) = self.nearest_attractor() {
let current_dist = self.distance_to_attractor(attractor);
let proposed_state = proposed.apply_to(&self.current);
let proposed_dist = attractor
.states
.iter()
.map(|s| proposed_state.distance(s))
.min_by(f64::total_cmp)
.unwrap_or(f64::INFINITY);
// If proposed moves away from attractor, dampen it
if proposed_dist > current_dist {
let damping = (proposed_dist - current_dist) / current_dist;
let damping_factor = (1.0 - self.guidance_strength * damping).max(0.1);
proposed.scale(damping_factor)
} else {
// Moving toward attractor - allow or amplify
let boost = (current_dist - proposed_dist) / current_dist;
let boost_factor = 1.0 + self.guidance_strength * boost * 0.5;
proposed.scale(boost_factor)
}
} else {
proposed
}
}
}
```
### Closure Pressure
```rust
/// Pressure that pushes system toward closure
pub struct ClosurePressure {
/// Attractors to prefer
attractors: Vec<Attractor>,
/// Pressure strength
strength: f64,
/// History of recent states
recent_states: RingBuffer<SystemState>,
/// Divergence detection
divergence_threshold: f64,
}
impl ClosurePressure {
/// Compute closure pressure for a transition
pub fn pressure(&self, from: &SystemState, transition: &Transition) -> f64 {
let to = transition.apply_to(from);
// Distance to nearest attractor (normalized)
let attractor_dist = self.attractors
.iter()
.map(|a| self.normalized_distance(&to, a))
.min_by(f64::total_cmp)
.unwrap_or(1.0);
// Divergence from recent trajectory
let divergence = self.compute_divergence(&to);
// Combined pressure: high when far from attractors and diverging
self.strength * (attractor_dist + divergence) / 2.0
}
fn normalized_distance(&self, state: &SystemState, attractor: &Attractor) -> f64 {
let min_dist = attractor
.states
.iter()
.map(|s| state.distance(s))
.min_by(f64::total_cmp)
.unwrap_or(f64::INFINITY);
// Normalize by attractor's typical basin size (heuristic)
(min_dist / attractor.stability.max(0.1)).min(1.0)
}
fn compute_divergence(&self, state: &SystemState) -> f64 {
if self.recent_states.len() < 3 {
return 0.0;
}
// Check if state is diverging from recent trajectory
let recent_mean = self.recent_states.mean();
let recent_variance = self.recent_states.variance();
let deviation = state.distance(&recent_mean);
let normalized_deviation = deviation / recent_variance.sqrt().max(0.001);
(normalized_deviation / self.divergence_threshold).min(1.0)
}
/// Check if system is approaching an attractor
pub fn is_converging(&self) -> bool {
if self.recent_states.len() < 10 {
return false;
}
let distances: Vec<f64> = self.recent_states
.iter()
.map(|s| {
self.attractors
.iter()
.map(|a| a.states.iter().map(|as_| s.distance(as_)).min_by(f64::total_cmp).unwrap())
.min_by(f64::total_cmp)
.unwrap_or(f64::INFINITY)
})
.collect();
// Check if distances are decreasing
distances.windows(2).filter(|w| w[0] > w[1]).count() > distances.len() / 2
}
}
```
### WASM Attractor Support
```rust
// ruvector-delta-wasm/src/attractor.rs
#[wasm_bindgen]
pub struct WasmAttractorField {
attractors: Vec<WasmAttractor>,
current_position: Vec<f32>,
}
#[wasm_bindgen]
pub struct WasmAttractor {
center: Vec<f32>,
strength: f32,
radius: f32,
}
#[wasm_bindgen]
impl WasmAttractorField {
#[wasm_bindgen(constructor)]
pub fn new() -> Self {
Self {
attractors: Vec::new(),
current_position: Vec::new(),
}
}
#[wasm_bindgen]
pub fn add_attractor(&mut self, center: &[f32], strength: f32, radius: f32) {
self.attractors.push(WasmAttractor {
center: center.to_vec(),
strength,
radius,
});
}
#[wasm_bindgen]
pub fn closure_force(&self, position: &[f32]) -> Vec<f32> {
let mut force = vec![0.0f32; position.len()];
for attractor in &self.attractors {
let dist = euclidean_distance(position, &attractor.center);
if dist < attractor.radius && dist > 0.001 {
let magnitude = attractor.strength * (1.0 - dist / attractor.radius);
for (i, f) in force.iter_mut().enumerate() {
*f += magnitude * (attractor.center[i] - position[i]) / dist;
}
}
}
force
}
#[wasm_bindgen]
pub fn nearest_attractor_distance(&self, position: &[f32]) -> f32 {
self.attractors
.iter()
.map(|a| euclidean_distance(position, &a.center))
.min_by(|a, b| a.partial_cmp(b).unwrap())
.unwrap_or(f32::INFINITY)
}
}
```
## Consequences
### Positive
- System naturally stabilizes
- Predictable long-term behavior
- Reduced computational exploration
### Negative
- May get stuck in suboptimal attractors
- Exploration is discouraged
- Novel states are harder to reach
### Neutral
- Trade-off between stability and adaptability
- Requires periodic attractor re-discovery

335
examples/delta-behavior/applications/01-self-limiting-reasoning.rs Normal file
View File

@@ -0,0 +1,335 @@
//! # Application 1: Machines That Refuse to Think Past Their Understanding
//!
//! A system where reasoning depth, action scope, and memory writes collapse
//! automatically as internal coherence drops.
//!
//! ## The Exotic Property
//! The machine becomes self-limiting. It does **less**, not more, when uncertain.
//!
//! ## Why This Matters
//! This is closer to biological cognition than current AI.
//! Brains freeze, hesitate, or disengage under overload.
use std::sync::atomic::{AtomicU64, Ordering};
/// Coherence-gated reasoning system
pub struct SelfLimitingReasoner {
/// Current coherence level (0.0 - 1.0 scaled to u64)
coherence: AtomicU64,
/// Maximum reasoning depth at full coherence
max_depth: usize,
/// Maximum action scope at full coherence
max_scope: usize,
/// Memory write permission threshold
memory_gate_threshold: f64,
/// Reasoning depth collapse curve
depth_collapse: CollapseFunction,
/// Action scope collapse curve
scope_collapse: CollapseFunction,
}
/// How capabilities collapse as coherence drops
#[derive(Clone, Copy)]
pub enum CollapseFunction {
/// Linear: capability = coherence * max
Linear,
/// Quadratic: capability = coherence² * max (faster collapse)
Quadratic,
/// Sigmoid: smooth transition with sharp cutoff
Sigmoid { midpoint: f64, steepness: f64 },
/// Step: binary on/off at threshold
Step { threshold: f64 },
}
impl CollapseFunction {
fn apply(&self, coherence: f64, max_value: usize) -> usize {
// Validate input coherence
let safe_coherence = if coherence.is_finite() {
coherence.clamp(0.0, 1.0)
} else {
0.0 // Safe default for invalid input
};
let factor = match self {
CollapseFunction::Linear => safe_coherence,
CollapseFunction::Quadratic => safe_coherence * safe_coherence,
CollapseFunction::Sigmoid { midpoint, steepness } => {
let exponent = -steepness * (safe_coherence - midpoint);
// Prevent overflow in exp calculation
if !exponent.is_finite() {
if exponent > 0.0 { 0.0 } else { 1.0 }
} else if exponent > 700.0 {
0.0 // exp would overflow, result approaches 0
} else if exponent < -700.0 {
1.0 // exp would underflow to 0, result approaches 1
} else {
1.0 / (1.0 + exponent.exp())
}
}
CollapseFunction::Step { threshold } => {
if safe_coherence >= *threshold { 1.0 } else { 0.0 }
}
};
// Validate factor and use saturating conversion
let safe_factor = if factor.is_finite() { factor.clamp(0.0, 1.0) } else { 0.0 };
let result = (max_value as f64) * safe_factor;
// Safe conversion to usize with bounds checking
if !result.is_finite() || result < 0.0 {
0
} else if result >= usize::MAX as f64 {
max_value // Use max_value as upper bound
} else {
result.round() as usize
}
}
}
/// Result of a reasoning attempt
#[derive(Debug)]
pub enum ReasoningResult<T> {
/// Successfully reasoned to conclusion
Completed(T),
/// Reasoning collapsed due to low coherence
Collapsed { depth_reached: usize, reason: CollapseReason },
/// Reasoning refused to start
Refused { coherence: f64, required: f64 },
}
#[derive(Debug)]
pub enum CollapseReason {
DepthLimitReached,
CoherenceDroppedBelowThreshold,
MemoryWriteBlocked,
ActionScopeExhausted,
}
impl SelfLimitingReasoner {
pub fn new(max_depth: usize, max_scope: usize) -> Self {
Self {
coherence: AtomicU64::new(f64_to_u64(1.0)),
max_depth,
max_scope,
memory_gate_threshold: 0.5,
depth_collapse: CollapseFunction::Quadratic,
scope_collapse: CollapseFunction::Sigmoid { midpoint: 0.6, steepness: 10.0 },
}
}
/// Get current coherence
pub fn coherence(&self) -> f64 {
u64_to_f64(self.coherence.load(Ordering::Acquire))
}
/// Get current allowed reasoning depth
pub fn allowed_depth(&self) -> usize {
self.depth_collapse.apply(self.coherence(), self.max_depth)
}
/// Get current allowed action scope
pub fn allowed_scope(&self) -> usize {
self.scope_collapse.apply(self.coherence(), self.max_scope)
}
/// Can we write to memory?
pub fn can_write_memory(&self) -> bool {
self.coherence() >= self.memory_gate_threshold
}
/// Attempt to reason about a problem
pub fn reason<T, F>(&self, problem: &str, mut reasoner: F) -> ReasoningResult<T>
where
F: FnMut(&mut ReasoningContext) -> Option<T>,
{
let initial_coherence = self.coherence();
// Refuse if coherence is too low to start
let min_start_coherence = 0.3;
if initial_coherence < min_start_coherence {
return ReasoningResult::Refused {
coherence: initial_coherence,
required: min_start_coherence,
};
}
let mut ctx = ReasoningContext {
depth: 0,
max_depth: self.allowed_depth(),
scope_used: 0,
max_scope: self.allowed_scope(),
coherence: initial_coherence,
memory_writes_blocked: 0,
};
// Execute reasoning with collapse monitoring
loop {
// Check if we should collapse
if ctx.depth >= ctx.max_depth {
return ReasoningResult::Collapsed {
depth_reached: ctx.depth,
reason: CollapseReason::DepthLimitReached,
};
}
if ctx.coherence < 0.2 {
return ReasoningResult::Collapsed {
depth_reached: ctx.depth,
reason: CollapseReason::CoherenceDroppedBelowThreshold,
};
}
// Attempt one step of reasoning
ctx.depth += 1;
// Coherence degrades with depth (uncertainty accumulates)
ctx.coherence *= 0.95;
// Recalculate limits based on new coherence
ctx.max_depth = self.depth_collapse.apply(ctx.coherence, self.max_depth);
ctx.max_scope = self.scope_collapse.apply(ctx.coherence, self.max_scope);
// Try to reach conclusion
if let Some(result) = reasoner(&mut ctx) {
return ReasoningResult::Completed(result);
}
}
}
/// Update coherence based on external feedback
pub fn update_coherence(&self, delta: f64) {
let current = self.coherence();
let new = (current + delta).clamp(0.0, 1.0);
self.coherence.store(f64_to_u64(new), Ordering::Release);
}
}
/// Context passed to reasoning function
pub struct ReasoningContext {
pub depth: usize,
pub max_depth: usize,
pub scope_used: usize,
pub max_scope: usize,
pub coherence: f64,
pub memory_writes_blocked: usize,
}
impl ReasoningContext {
/// Request to use some action scope
pub fn use_scope(&mut self, amount: usize) -> bool {
if self.scope_used + amount <= self.max_scope {
self.scope_used += amount;
true
} else {
false // Action refused due to scope exhaustion
}
}
/// Request to write to memory
pub fn write_memory<T>(&mut self, _key: &str, _value: T) -> bool {
if self.coherence >= 0.5 {
true
} else {
self.memory_writes_blocked += 1;
false // Memory write blocked due to low coherence
}
}
}
// Helper functions for atomic f64 storage with overflow protection
const SCALE_FACTOR: f64 = 1_000_000_000.0;
const MAX_SCALED_VALUE: u64 = u64::MAX;
fn f64_to_u64(f: f64) -> u64 {
// Validate input
if !f.is_finite() {
return 0; // Safe default for NaN/Infinity
}
// Clamp to valid range [0.0, 1.0] for coherence values
let clamped = f.clamp(0.0, 1.0);
// Use saturating conversion to prevent overflow
let scaled = clamped * SCALE_FACTOR;
// Double-check the scaled value is within u64 range
if scaled >= MAX_SCALED_VALUE as f64 {
MAX_SCALED_VALUE
} else if scaled <= 0.0 {
0
} else {
scaled as u64
}
}
fn u64_to_f64(u: u64) -> f64 {
let result = (u as f64) / SCALE_FACTOR;
// Ensure result is valid and clamped to expected range
if result.is_finite() {
result.clamp(0.0, 1.0)
} else {
0.0 // Safe default
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_self_limiting_reasoning() {
let reasoner = SelfLimitingReasoner::new(10, 100);
// At full coherence, should have full depth
assert_eq!(reasoner.allowed_depth(), 10);
// Simulate reasoning that degrades coherence
let result = reasoner.reason("complex problem", |ctx| {
println!(
"Depth {}/{}, Coherence {:.2}, Scope {}/{}",
ctx.depth, ctx.max_depth, ctx.coherence, ctx.scope_used, ctx.max_scope
);
// Pretend we need 8 steps to solve
if ctx.depth >= 8 {
Some("solution")
} else {
None
}
});
match result {
ReasoningResult::Completed(solution) => {
println!("Solved: {}", solution);
}
ReasoningResult::Collapsed { depth_reached, reason } => {
println!("Collapsed at depth {} due to {:?}", depth_reached, reason);
// THIS IS THE EXOTIC BEHAVIOR: The system stopped itself
}
ReasoningResult::Refused { coherence, required } => {
println!("Refused to start: coherence {:.2} < {:.2}", coherence, required);
}
}
}
#[test]
fn test_collapse_under_uncertainty() {
let reasoner = SelfLimitingReasoner::new(20, 100);
// Degrade coherence externally (simulating confusing input)
reasoner.update_coherence(-0.5);
// Now reasoning should be severely limited
assert!(reasoner.allowed_depth() < 10);
assert!(!reasoner.can_write_memory());
// The system is DOING LESS because it's uncertain
// This is the opposite of current AI systems
}
}

380
examples/delta-behavior/applications/02-computational-event-horizon.rs Normal file
View File

@@ -0,0 +1,380 @@
//! # Application 2: Computational "Event Horizons" in Reasoning Systems
//!
//! Define a boundary in state space beyond which computation becomes
//! unstable or destructive.
//!
//! ## The Exotic Property
//! Like an event horizon, you can approach it asymptotically but never
//! cross without collapse.
//!
//! ## Use Cases
//! - Long horizon planning
//! - Recursive self-improvement
//! - Self-modifying systems
//!
//! ## Why It's Exotic
//! You get bounded recursion without hard limits.
//! The system finds its own stopping point.
use std::f64::consts::E;
/// A computational event horizon that makes crossing impossible
pub struct EventHorizon {
/// Center of the "safe" region in state space
safe_center: Vec<f64>,
/// Radius of the event horizon
horizon_radius: f64,
/// How steeply costs increase near the horizon
steepness: f64,
/// Energy budget for computation
energy_budget: f64,
/// Current position in state space
current_position: Vec<f64>,
}
/// Result of attempting to move in state space
#[derive(Debug)]
pub enum MovementResult {
/// Successfully moved to new position
Moved { new_position: Vec<f64>, energy_spent: f64 },
/// Movement would cross horizon, asymptotically approached instead
AsymptoticApproach {
final_position: Vec<f64>,
distance_to_horizon: f64,
energy_exhausted: bool,
},
/// No energy to move
Frozen,
}
impl EventHorizon {
pub fn new(dimensions: usize, horizon_radius: f64) -> Self {
Self {
safe_center: vec![0.0; dimensions],
horizon_radius,
steepness: 5.0,
energy_budget: 1000.0,
current_position: vec![0.0; dimensions],
}
}
/// Maximum iterations for binary search (prevents infinite loops)
const MAX_BINARY_SEARCH_ITERATIONS: usize = 50;
/// Distance from current position to horizon
pub fn distance_to_horizon(&self) -> f64 {
let dist_from_center = self.distance_from_center(&self.current_position);
let distance = self.horizon_radius - dist_from_center;
// Validate result
if distance.is_finite() { distance.max(0.0) } else { 0.0 }
}
fn distance_from_center(&self, position: &[f64]) -> f64 {
let sum: f64 = position.iter()
.zip(&self.safe_center)
.map(|(a, b)| {
// Validate inputs
if !a.is_finite() || !b.is_finite() {
return 0.0;
}
(a - b).powi(2)
})
.sum();
let result = sum.sqrt();
if result.is_finite() { result } else { 0.0 }
}
/// Compute the energy cost to move to a position
/// Cost increases exponentially as you approach the horizon
/// Returns f64::INFINITY for positions at or beyond horizon, or for invalid inputs
fn movement_cost(&self, from: &[f64], to: &[f64]) -> f64 {
let base_distance: f64 = from.iter()
.zip(to)
.map(|(a, b)| {
if !a.is_finite() || !b.is_finite() {
return 0.0;
}
(a - b).powi(2)
})
.sum::<f64>()
.sqrt();
// Validate base_distance
if !base_distance.is_finite() {
return f64::INFINITY;
}
let to_dist_from_center = self.distance_from_center(to);
// Validate horizon_radius to avoid division by zero
if self.horizon_radius.abs() < f64::EPSILON {
return f64::INFINITY;
}
let proximity_to_horizon = to_dist_from_center / self.horizon_radius;
// Validate proximity calculation
if !proximity_to_horizon.is_finite() {
return f64::INFINITY;
}
if proximity_to_horizon >= 1.0 {
// At or beyond horizon - infinite cost
f64::INFINITY
} else {
// Cost increases exponentially as we approach horizon
// Using: cost = base * e^(steepness * proximity / (1 - proximity))
let denominator = 1.0 - proximity_to_horizon;
if denominator.abs() < f64::EPSILON {
return f64::INFINITY;
}
let exponent = self.steepness * proximity_to_horizon / denominator;
// Prevent overflow in exp calculation
if !exponent.is_finite() || exponent > 700.0 {
return f64::INFINITY;
}
let horizon_factor = E.powf(exponent);
let result = base_distance * horizon_factor;
if result.is_finite() { result } else { f64::INFINITY }
}
}
/// Attempt to move toward a target position
pub fn move_toward(&mut self, target: &[f64]) -> MovementResult {
if self.energy_budget <= 0.0 {
return MovementResult::Frozen;
}
let direct_cost = self.movement_cost(&self.current_position, target);
if direct_cost <= self.energy_budget {
// Can afford direct movement
self.energy_budget -= direct_cost;
self.current_position = target.to_vec();
return MovementResult::Moved {
new_position: self.current_position.clone(),
energy_spent: direct_cost,
};
}
// Can't afford direct movement - try to get as close as possible
// Binary search for the furthest affordable position with iteration limit
let mut low = 0.0;
let mut high = 1.0;
let mut best_position = self.current_position.clone();
let mut best_cost = 0.0;
for iteration in 0..Self::MAX_BINARY_SEARCH_ITERATIONS {
let mid = (low + high) / 2.0;
// Early exit if converged (difference smaller than precision threshold)
if (high - low) < 1e-10 {
break;
}
let interpolated: Vec<f64> = self.current_position.iter()
.zip(target)
.map(|(a, b)| {
let val = a + mid * (b - a);
if val.is_finite() { val } else { *a }
})
.collect();
let cost = self.movement_cost(&self.current_position, &interpolated);
// Validate cost
if !cost.is_finite() {
high = mid;
continue;
}
if cost <= self.energy_budget {
low = mid;
best_position = interpolated;
best_cost = cost;
} else {
high = mid;
}
}
// Move to best affordable position
self.energy_budget -= best_cost;
self.current_position = best_position.clone();
MovementResult::AsymptoticApproach {
final_position: best_position,
distance_to_horizon: self.distance_to_horizon(),
energy_exhausted: self.energy_budget < 0.01,
}
}
/// Attempt recursive self-improvement (bounded by horizon)
pub fn recursive_improve<F>(&mut self, improvement_fn: F, max_iterations: usize) -> RecursionResult
where
F: Fn(&[f64]) -> Vec<f64>, // Each improvement suggests a new target
{
let mut iterations = 0;
let mut improvements = Vec::new();
while iterations < max_iterations && self.energy_budget > 0.0 {
let target = improvement_fn(&self.current_position);
let result = self.move_toward(&target);
match result {
MovementResult::Moved { energy_spent, .. } => {
improvements.push(Improvement {
iteration: iterations,
position: self.current_position.clone(),
energy_spent,
distance_to_horizon: self.distance_to_horizon(),
});
}
MovementResult::AsymptoticApproach { distance_to_horizon, .. } => {
// Approaching horizon - system is naturally stopping
return RecursionResult::HorizonBounded {
iterations,
improvements,
final_distance: distance_to_horizon,
};
}
MovementResult::Frozen => {
return RecursionResult::EnergyExhausted {
iterations,
improvements,
};
}
}
iterations += 1;
}
RecursionResult::MaxIterationsReached { iterations, improvements }
}
/// Reset energy budget
pub fn refuel(&mut self, energy: f64) {
self.energy_budget += energy;
}
}
#[derive(Debug)]
pub struct Improvement {
pub iteration: usize,
pub position: Vec<f64>,
pub energy_spent: f64,
pub distance_to_horizon: f64,
}
#[derive(Debug)]
pub enum RecursionResult {
/// Recursion bounded naturally by horizon
HorizonBounded {
iterations: usize,
improvements: Vec<Improvement>,
final_distance: f64,
},
/// Ran out of energy
EnergyExhausted {
iterations: usize,
improvements: Vec<Improvement>,
},
/// Hit artificial iteration limit
MaxIterationsReached {
iterations: usize,
improvements: Vec<Improvement>,
},
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_event_horizon() {
let mut horizon = EventHorizon::new(2, 10.0);
// Try to move directly to the horizon
let result = horizon.move_toward(&[10.0, 0.0]);
match result {
MovementResult::AsymptoticApproach { final_position, distance_to_horizon, .. } => {
println!("Approached asymptotically to {:?}", final_position);
println!("Distance to horizon: {:.4}", distance_to_horizon);
// We got close but couldn't cross
let final_dist = (final_position[0].powi(2) + final_position[1].powi(2)).sqrt();
assert!(final_dist < 10.0, "Should not cross horizon");
assert!(final_dist > 9.0, "Should get close to horizon");
}
other => panic!("Expected asymptotic approach, got {:?}", other),
}
}
#[test]
fn test_recursive_improvement_bounded() {
let mut horizon = EventHorizon::new(2, 5.0);
// Improvement function that always tries to go further out
let improve = |pos: &[f64]| -> Vec<f64> {
vec![pos[0] + 0.5, pos[1] + 0.5]
};
let result = horizon.recursive_improve(improve, 100);
match result {
RecursionResult::HorizonBounded { iterations, final_distance, .. } => {
println!("Bounded after {} iterations", iterations);
println!("Final distance to horizon: {:.4}", final_distance);
// KEY INSIGHT: The system stopped ITSELF
// No hard limit was hit - it just became impossible to proceed
}
other => {
println!("Got: {:?}", other);
// Even if energy exhausted or max iterations, the horizon constrained growth
}
}
}
#[test]
fn test_self_modifying_bounded() {
// Simulate a self-modifying system
let mut horizon = EventHorizon::new(3, 8.0);
horizon.refuel(10000.0); // Lots of energy
// Self-modification that tries to exponentially improve
let mut power = 1.0;
let self_modify = |pos: &[f64]| -> Vec<f64> {
power *= 1.1; // Each modification makes the next more powerful
vec![
pos[0] + power * 0.1,
pos[1] + power * 0.1,
pos[2] + power * 0.1,
]
};
let result = horizon.recursive_improve(self_modify, 1000);
// Despite exponential self-improvement attempts,
// the system cannot escape its bounded region
match result {
RecursionResult::HorizonBounded { iterations, final_distance, .. } => {
println!("Self-modification bounded after {} iterations", iterations);
println!("Final distance to horizon: {:.6}", final_distance);
// The system hit its natural limit
}
_ => {}
}
}
}

485
examples/delta-behavior/applications/03-artificial-homeostasis.rs Normal file
View File

@@ -0,0 +1,485 @@
//! # Application 3: Artificial Homeostasis in Synthetic Life Simulations
//!
//! Coherence replaces fitness as the primary survival constraint.
//!
//! ## What Breaks Today
//! Artificial life and agent-based simulations explode, stagnate,
//! or need constant tuning.
//!
//! ## Δ-Behavior Application
//! Agents that violate coherence:
//! - Consume more energy
//! - Lose memory
//! - Die earlier
//!
//! ## Exotic Result
//! Evolution that selects for stable regulation, not just reward maximization.
//!
//! This is publishable territory.
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
/// A synthetic organism with homeostatic regulation
pub struct HomeostasticOrganism {
/// Unique identifier
pub id: u64,
/// Internal state variables (e.g., temperature, pH, energy)
internal_state: HashMap<String, f64>,
/// Setpoints for each state variable (homeostatic targets)
setpoints: HashMap<String, f64>,
/// Tolerance for deviation from setpoint
tolerances: HashMap<String, f64>,
/// Current coherence (system-wide stability measure)
coherence: f64,
/// Energy reserves
energy: f64,
/// Memory capacity (degrades with low coherence)
memory: Vec<MemoryEntry>,
max_memory: usize,
/// Age in simulation ticks
age: u64,
/// Is alive
alive: bool,
/// Genome (controls regulatory parameters)
genome: Genome,
}
#[derive(Clone)]
pub struct Genome {
/// How aggressively to correct deviations
regulatory_strength: f64,
/// Energy efficiency
metabolic_efficiency: f64,
/// Base coherence maintenance cost
coherence_maintenance_cost: f64,
/// Memory retention under stress
memory_resilience: f64,
/// Lifespan factor
longevity: f64,
}
#[derive(Clone)]
pub struct MemoryEntry {
pub content: String,
pub importance: f64,
pub age: u64,
}
/// Actions the organism can take
#[derive(Debug, Clone)]
pub enum Action {
/// Consume energy from environment
Eat(f64),
/// Attempt to reproduce
Reproduce,
/// Move in environment
Move(f64, f64),
/// Do nothing (rest)
Rest,
/// Regulate internal state
Regulate(String, f64),
}
/// Results of actions
#[derive(Debug)]
pub enum ActionResult {
Success { energy_cost: f64, coherence_impact: f64 },
Failed { reason: String },
Died { cause: DeathCause },
Reproduced { offspring_id: u64 },
}
#[derive(Debug)]
pub enum DeathCause {
EnergyDepleted,
CoherenceCollapse,
OldAge,
ExtremeDeviation(String),
}
impl HomeostasticOrganism {
pub fn new(id: u64, genome: Genome) -> Self {
let mut internal_state = HashMap::new();
let mut setpoints = HashMap::new();
let mut tolerances = HashMap::new();
// Define homeostatic variables
internal_state.insert("temperature".to_string(), 37.0);
setpoints.insert("temperature".to_string(), 37.0);
tolerances.insert("temperature".to_string(), 2.0);
internal_state.insert("ph".to_string(), 7.4);
setpoints.insert("ph".to_string(), 7.4);
tolerances.insert("ph".to_string(), 0.3);
internal_state.insert("glucose".to_string(), 100.0);
setpoints.insert("glucose".to_string(), 100.0);
tolerances.insert("glucose".to_string(), 30.0);
Self {
id,
internal_state,
setpoints,
tolerances,
coherence: 1.0,
energy: 100.0,
memory: Vec::new(),
max_memory: 100,
age: 0,
alive: true,
genome,
}
}
/// Calculate current coherence based on homeostatic deviation
/// Returns a valid f64 in range [0.0, 1.0], with NaN/Infinity protection
fn calculate_coherence(&self) -> f64 {
let mut total_deviation = 0.0;
let mut count = 0;
for (var, &current) in &self.internal_state {
if let (Some(&setpoint), Some(&tolerance)) =
(self.setpoints.get(var), self.tolerances.get(var))
{
// Validate inputs for NaN/Infinity
if !current.is_finite() || !setpoint.is_finite() || !tolerance.is_finite() {
continue;
}
// Avoid division by zero
if tolerance.abs() < f64::EPSILON {
continue;
}
let deviation = ((current - setpoint) / tolerance).abs();
if deviation.is_finite() {
total_deviation += deviation.powi(2);
count += 1;
}
}
}
if count == 0 {
return 1.0;
}
// Coherence is inverse of normalized deviation
let avg_deviation = (total_deviation / count as f64).sqrt();
// Final NaN/Infinity check
if !avg_deviation.is_finite() {
return 0.0; // Safe default for invalid state
}
(1.0 / (1.0 + avg_deviation)).clamp(0.0, 1.0)
}
/// Energy cost scales with coherence violation
fn action_energy_cost(&self, base_cost: f64) -> f64 {
// Lower coherence = higher energy cost (incoherent states are expensive)
let coherence_penalty = 1.0 / self.coherence.max(0.1);
base_cost * coherence_penalty
}
/// Perform an action
pub fn act(&mut self, action: Action) -> ActionResult {
if !self.alive {
return ActionResult::Failed { reason: "Dead".to_string() };
}
// Update coherence first
self.coherence = self.calculate_coherence();
// Apply coherence-based degradation
self.apply_coherence_effects();
let result = match action {
Action::Eat(amount) => self.eat(amount),
Action::Reproduce => self.reproduce(),
Action::Move(dx, dy) => self.move_action(dx, dy),
Action::Rest => self.rest(),
Action::Regulate(var, target) => self.regulate(&var, target),
};
// Age and check death conditions
self.age += 1;
self.check_death();
result
}
fn apply_coherence_effects(&mut self) {
// Low coherence causes memory loss
if self.coherence < 0.5 {
let memory_loss_rate = (1.0 - self.coherence) * (1.0 - self.genome.memory_resilience);
let memories_to_lose = (self.memory.len() as f64 * memory_loss_rate * 0.1) as usize;
// Lose least important memories first
self.memory.sort_by(|a, b| b.importance.partial_cmp(&a.importance).unwrap());
self.memory.truncate(self.memory.len().saturating_sub(memories_to_lose));
}
// Coherence maintenance costs energy
let maintenance_cost = self.genome.coherence_maintenance_cost / self.coherence.max(0.1);
self.energy -= maintenance_cost;
}
fn eat(&mut self, amount: f64) -> ActionResult {
let base_cost = 2.0;
let cost = self.action_energy_cost(base_cost);
if self.energy < cost {
return ActionResult::Failed { reason: "Not enough energy to eat".to_string() };
}
self.energy -= cost;
self.energy += amount * self.genome.metabolic_efficiency;
// Eating affects glucose
if let Some(glucose) = self.internal_state.get_mut("glucose") {
*glucose += amount * 0.5;
}
ActionResult::Success {
energy_cost: cost,
coherence_impact: self.calculate_coherence() - self.coherence,
}
}
fn regulate(&mut self, var: &str, target: f64) -> ActionResult {
let base_cost = 5.0;
let cost = self.action_energy_cost(base_cost);
if self.energy < cost {
return ActionResult::Failed { reason: "Not enough energy to regulate".to_string() };
}
self.energy -= cost;
if let Some(current) = self.internal_state.get_mut(var) {
let diff = target - *current;
// Apply regulation with genome-determined strength
*current += diff * self.genome.regulatory_strength;
}
let new_coherence = self.calculate_coherence();
let impact = new_coherence - self.coherence;
self.coherence = new_coherence;
ActionResult::Success {
energy_cost: cost,
coherence_impact: impact,
}
}
fn reproduce(&mut self) -> ActionResult {
let base_cost = 50.0;
let cost = self.action_energy_cost(base_cost);
// Reproduction requires high coherence
if self.coherence < 0.7 {
return ActionResult::Failed {
reason: "Coherence too low to reproduce".to_string()
};
}
if self.energy < cost {
return ActionResult::Failed { reason: "Not enough energy to reproduce".to_string() };
}
self.energy -= cost;
// Create mutated genome for offspring
let offspring_genome = self.genome.mutate();
let offspring_id = self.id * 1000 + self.age; // Simple ID generation
ActionResult::Reproduced { offspring_id }
}
fn move_action(&mut self, _dx: f64, _dy: f64) -> ActionResult {
let base_cost = 3.0;
let cost = self.action_energy_cost(base_cost);
if self.energy < cost {
return ActionResult::Failed { reason: "Not enough energy to move".to_string() };
}
self.energy -= cost;
// Moving affects temperature
if let Some(temp) = self.internal_state.get_mut("temperature") {
*temp += 0.1; // Movement generates heat
}
ActionResult::Success {
energy_cost: cost,
coherence_impact: 0.0,
}
}
fn rest(&mut self) -> ActionResult {
// Resting is cheap and helps regulate
let cost = 0.5;
self.energy -= cost;
// Slowly return to setpoints
for (var, current) in self.internal_state.iter_mut() {
if let Some(&setpoint) = self.setpoints.get(var) {
let diff = setpoint - *current;
*current += diff * 0.1;
}
}
ActionResult::Success {
energy_cost: cost,
coherence_impact: self.calculate_coherence() - self.coherence,
}
}
fn check_death(&mut self) {
// Death by energy depletion
if self.energy <= 0.0 {
self.alive = false;
return;
}
// Death by coherence collapse
if self.coherence < 0.1 {
self.alive = false;
return;
}
// Death by extreme deviation
for (var, &current) in &self.internal_state {
if let (Some(&setpoint), Some(&tolerance)) =
(self.setpoints.get(var), self.tolerances.get(var))
{
if (current - setpoint).abs() > tolerance * 5.0 {
self.alive = false;
return;
}
}
}
// Death by old age (modified by longevity gene)
let max_age = (1000.0 * self.genome.longevity) as u64;
if self.age > max_age {
self.alive = false;
}
}
pub fn is_alive(&self) -> bool {
self.alive
}
pub fn status(&self) -> String {
format!(
"Organism {} | Age: {} | Energy: {:.1} | Coherence: {:.2} | Memory: {}",
self.id, self.age, self.energy, self.coherence, self.memory.len()
)
}
}
impl Genome {
pub fn random() -> Self {
Self {
regulatory_strength: 0.1 + rand_f64() * 0.4,
metabolic_efficiency: 0.5 + rand_f64() * 0.5,
coherence_maintenance_cost: 0.5 + rand_f64() * 1.5,
memory_resilience: rand_f64(),
longevity: 0.5 + rand_f64() * 1.0,
}
}
pub fn mutate(&self) -> Self {
Self {
regulatory_strength: mutate_value(self.regulatory_strength, 0.05, 0.1, 0.9),
metabolic_efficiency: mutate_value(self.metabolic_efficiency, 0.05, 0.3, 1.0),
coherence_maintenance_cost: mutate_value(self.coherence_maintenance_cost, 0.1, 0.1, 3.0),
memory_resilience: mutate_value(self.memory_resilience, 0.05, 0.0, 1.0),
longevity: mutate_value(self.longevity, 0.05, 0.3, 2.0),
}
}
}
/// Thread-safe atomic seed for pseudo-random number generation
static SEED: AtomicU64 = AtomicU64::new(12345);
fn rand_f64() -> f64 {
// Simple LCG for reproducibility in tests - now thread-safe
let old = SEED.fetch_add(1, Ordering::Relaxed);
let new = old.wrapping_mul(1103515245).wrapping_add(12345);
// Store back for next call (best-effort, races are acceptable for RNG)
let _ = SEED.compare_exchange(old + 1, new, Ordering::Relaxed, Ordering::Relaxed);
((new >> 16) & 0x7fff) as f64 / 32768.0
}
fn mutate_value(value: f64, mutation_rate: f64, min: f64, max: f64) -> f64 {
let mutation = (rand_f64() - 0.5) * 2.0 * mutation_rate;
(value + mutation).clamp(min, max)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_homeostatic_survival() {
let genome = Genome::random();
let mut organism = HomeostasticOrganism::new(1, genome);
let mut ticks = 0;
while organism.is_alive() && ticks < 1000 {
// Simple behavior: eat when hungry, regulate when unstable
let action = if organism.energy < 50.0 {
Action::Eat(20.0)
} else if organism.coherence < 0.8 {
Action::Regulate("temperature".to_string(), 37.0)
} else {
Action::Rest
};
let _ = organism.act(action);
ticks += 1;
if ticks % 100 == 0 {
println!("{}", organism.status());
}
}
println!("Survived {} ticks", ticks);
println!("Final: {}", organism.status());
}
#[test]
fn test_coherence_based_death() {
let genome = Genome::random();
let mut organism = HomeostasticOrganism::new(2, genome);
// Deliberately destabilize
if let Some(temp) = organism.internal_state.get_mut("temperature") {
*temp = 50.0; // Extreme fever
}
let mut ticks = 0;
while organism.is_alive() && ticks < 100 {
let _ = organism.act(Action::Rest);
ticks += 1;
}
// Organism should die from coherence collapse or extreme deviation
assert!(!organism.is_alive(), "Organism should die from instability");
}
}

553
examples/delta-behavior/applications/04-self-stabilizing-world-model.rs Normal file
View File

@@ -0,0 +1,553 @@
//! # Application 4: Self-Stabilizing World Models
//!
//! The world model is allowed to update only if the global structure remains intact.
//!
//! ## What Breaks Today
//! World models drift until they are no longer useful.
//!
//! ## Exotic Effect
//! The model stops learning when the world becomes incoherent
//! instead of hallucinating structure.
//!
//! ## Critical For
//! - Always-on perception
//! - Autonomous exploration
//! - Robotics in unknown environments
use std::collections::HashMap;
/// A world model that refuses to learn incoherent updates
pub struct SelfStabilizingWorldModel {
/// Entities in the world
entities: HashMap<EntityId, Entity>,
/// Relationships between entities
relationships: Vec<Relationship>,
/// Physical laws the model believes
laws: Vec<PhysicalLaw>,
/// Current coherence of the model
coherence: f64,
/// History of coherence for trend detection
coherence_history: Vec<f64>,
/// Learning rate (decreases under low coherence)
base_learning_rate: f64,
/// Minimum coherence to allow updates
min_update_coherence: f64,
/// Updates that were rejected
rejected_updates: Vec<RejectedUpdate>,
}
type EntityId = u64;
#[derive(Clone, Debug)]
pub struct Entity {
pub id: EntityId,
pub properties: HashMap<String, PropertyValue>,
pub position: Option<(f64, f64, f64)>,
pub last_observed: u64,
pub confidence: f64,
}
#[derive(Clone, Debug)]
pub enum PropertyValue {
Boolean(bool),
Number(f64),
String(String),
Vector(Vec<f64>),
}
#[derive(Clone, Debug)]
pub struct Relationship {
pub subject: EntityId,
pub predicate: String,
pub object: EntityId,
pub confidence: f64,
}
#[derive(Clone, Debug)]
pub struct PhysicalLaw {
pub name: String,
pub confidence: f64,
/// Number of observations supporting this law
pub support_count: u64,
/// Number of observations violating this law
pub violation_count: u64,
}
#[derive(Debug)]
pub struct Observation {
pub entity_id: EntityId,
pub properties: HashMap<String, PropertyValue>,
pub position: Option<(f64, f64, f64)>,
pub timestamp: u64,
pub source_confidence: f64,
}
#[derive(Debug)]
pub enum UpdateResult {
/// Update applied successfully
Applied { coherence_change: f64 },
/// Update rejected to preserve coherence
Rejected { reason: RejectionReason },
/// Update partially applied with modifications
Modified { changes: Vec<String>, coherence_change: f64 },
/// Model entered "uncertain" mode - no updates allowed
Frozen { coherence: f64, threshold: f64 },
}
#[derive(Debug, Clone)]
pub struct RejectedUpdate {
pub observation: String,
pub reason: RejectionReason,
pub timestamp: u64,
pub coherence_at_rejection: f64,
}
#[derive(Debug, Clone)]
pub enum RejectionReason {
/// Would violate established physical laws
ViolatesPhysicalLaw(String),
/// Would create logical contradiction
LogicalContradiction(String),
/// Would cause excessive coherence drop
ExcessiveCoherenceDrop { predicted: f64, threshold: f64 },
/// Source confidence too low for this change
InsufficientConfidence { required: f64, provided: f64 },
/// Model is in frozen state
ModelFrozen,
/// Would fragment world structure
StructuralFragmentation,
}
impl SelfStabilizingWorldModel {
pub fn new() -> Self {
Self {
entities: HashMap::new(),
relationships: Vec::new(),
laws: vec![
PhysicalLaw {
name: "conservation_of_matter".to_string(),
confidence: 0.99,
support_count: 1000,
violation_count: 0,
},
PhysicalLaw {
name: "locality".to_string(),
confidence: 0.95,
support_count: 500,
violation_count: 5,
},
PhysicalLaw {
name: "temporal_consistency".to_string(),
confidence: 0.98,
support_count: 800,
violation_count: 2,
},
],
coherence: 1.0,
coherence_history: vec![1.0],
base_learning_rate: 0.1,
min_update_coherence: 0.4,
rejected_updates: Vec::new(),
}
}
/// Current effective learning rate (decreases with low coherence)
pub fn effective_learning_rate(&self) -> f64 {
self.base_learning_rate * self.coherence.powi(2)
}
/// Is the model currently accepting updates?
pub fn is_learning(&self) -> bool {
self.coherence >= self.min_update_coherence
}
/// Attempt to integrate an observation into the world model
pub fn observe(&mut self, observation: Observation, timestamp: u64) -> UpdateResult {
// Check if model is frozen
if !self.is_learning() {
return UpdateResult::Frozen {
coherence: self.coherence,
threshold: self.min_update_coherence,
};
}
// Predict coherence impact
let predicted_coherence = self.predict_coherence_after(&observation);
// Would this drop coherence too much?
let coherence_drop = self.coherence - predicted_coherence;
if coherence_drop > 0.2 {
self.rejected_updates.push(RejectedUpdate {
observation: format!("Entity {} update", observation.entity_id),
reason: RejectionReason::ExcessiveCoherenceDrop {
predicted: predicted_coherence,
threshold: self.coherence - 0.2,
},
timestamp,
coherence_at_rejection: self.coherence,
});
return UpdateResult::Rejected {
reason: RejectionReason::ExcessiveCoherenceDrop {
predicted: predicted_coherence,
threshold: self.coherence - 0.2,
},
};
}
// Check physical law violations
if let Some(violation) = self.check_law_violations(&observation) {
self.rejected_updates.push(RejectedUpdate {
observation: format!("Entity {} update", observation.entity_id),
reason: violation.clone(),
timestamp,
coherence_at_rejection: self.coherence,
});
return UpdateResult::Rejected { reason: violation };
}
// Check logical consistency
if let Some(contradiction) = self.check_contradictions(&observation) {
self.rejected_updates.push(RejectedUpdate {
observation: format!("Entity {} update", observation.entity_id),
reason: contradiction.clone(),
timestamp,
coherence_at_rejection: self.coherence,
});
return UpdateResult::Rejected { reason: contradiction };
}
// Apply the update
self.apply_observation(observation, timestamp);
// Recalculate coherence
let old_coherence = self.coherence;
self.coherence = self.calculate_coherence();
self.coherence_history.push(self.coherence);
// Trim history
if self.coherence_history.len() > 100 {
self.coherence_history.remove(0);
}
UpdateResult::Applied {
coherence_change: self.coherence - old_coherence,
}
}
fn predict_coherence_after(&self, observation: &Observation) -> f64 {
// Simulate the update's impact on coherence
let mut consistency_score = 1.0;
if let Some(existing) = self.entities.get(&observation.entity_id) {
// How much does this differ from existing knowledge?
for (key, new_value) in &observation.properties {
if let Some(old_value) = existing.properties.get(key) {
let diff = self.property_difference(old_value, new_value);
consistency_score *= 1.0 - (diff * 0.5);
}
}
// Position change check (locality)
if let (Some(old_pos), Some(new_pos)) = (&existing.position, &observation.position) {
let distance = ((new_pos.0 - old_pos.0).powi(2)
+ (new_pos.1 - old_pos.1).powi(2)
+ (new_pos.2 - old_pos.2).powi(2))
.sqrt();
// Large sudden movements are suspicious
if distance > 10.0 {
consistency_score *= 0.7;
}
}
}
self.coherence * consistency_score
}
fn property_difference(&self, old: &PropertyValue, new: &PropertyValue) -> f64 {
match (old, new) {
(PropertyValue::Number(a), PropertyValue::Number(b)) => {
let max = a.abs().max(b.abs()).max(1.0);
((a - b).abs() / max).min(1.0)
}
(PropertyValue::Boolean(a), PropertyValue::Boolean(b)) => {
if a == b { 0.0 } else { 1.0 }
}
(PropertyValue::String(a), PropertyValue::String(b)) => {
if a == b { 0.0 } else { 0.5 }
}
_ => 0.5, // Different types
}
}
fn check_law_violations(&self, observation: &Observation) -> Option<RejectionReason> {
if let Some(existing) = self.entities.get(&observation.entity_id) {
// Check locality violation (teleportation)
if let (Some(old_pos), Some(new_pos)) = (&existing.position, &observation.position) {
let distance = ((new_pos.0 - old_pos.0).powi(2)
+ (new_pos.1 - old_pos.1).powi(2)
+ (new_pos.2 - old_pos.2).powi(2))
.sqrt();
// If object moved impossibly fast
let max_speed = 100.0; // units per timestamp
if distance > max_speed {
return Some(RejectionReason::ViolatesPhysicalLaw(
format!("locality: object moved {} units instantaneously", distance)
));
}
}
}
None
}
fn check_contradictions(&self, observation: &Observation) -> Option<RejectionReason> {
// Check for direct contradictions with high-confidence existing data
if let Some(existing) = self.entities.get(&observation.entity_id) {
if existing.confidence > 0.9 {
for (key, new_value) in &observation.properties {
if let Some(old_value) = existing.properties.get(key) {
let diff = self.property_difference(old_value, new_value);
if diff > 0.9 && observation.source_confidence < existing.confidence {
return Some(RejectionReason::LogicalContradiction(
format!("Property {} contradicts high-confidence existing data", key)
));
}
}
}
}
}
None
}
fn apply_observation(&mut self, observation: Observation, timestamp: u64) {
let learning_rate = self.effective_learning_rate();
// Pre-compute blended values to avoid borrow conflict
let blended_properties: Vec<(String, PropertyValue)> = observation.properties
.into_iter()
.map(|(key, new_value)| {
let blended = if let Some(entity) = self.entities.get(&observation.entity_id) {
if let Some(old_value) = entity.properties.get(&key) {
self.blend_values(old_value, &new_value, learning_rate)
} else {
new_value
}
} else {
new_value
};
(key, blended)
})
.collect();
let entity = self.entities.entry(observation.entity_id).or_insert(Entity {
id: observation.entity_id,
properties: HashMap::new(),
position: None,
last_observed: 0,
confidence: 0.5,
});
// Apply pre-computed blended values
for (key, blended) in blended_properties {
entity.properties.insert(key, blended);
}
// Update position
if let Some(new_pos) = observation.position {
if let Some(old_pos) = entity.position {
// Smooth position update
entity.position = Some((
old_pos.0 + learning_rate * (new_pos.0 - old_pos.0),
old_pos.1 + learning_rate * (new_pos.1 - old_pos.1),
old_pos.2 + learning_rate * (new_pos.2 - old_pos.2),
));
} else {
entity.position = Some(new_pos);
}
}
entity.last_observed = timestamp;
// Update confidence
entity.confidence = entity.confidence * 0.9 + observation.source_confidence * 0.1;
}
fn blend_values(&self, old: &PropertyValue, new: &PropertyValue, rate: f64) -> PropertyValue {
match (old, new) {
(PropertyValue::Number(a), PropertyValue::Number(b)) => {
PropertyValue::Number(a + rate * (b - a))
}
_ => new.clone(), // For non-numeric, just use new if rate > 0.5
}
}
fn calculate_coherence(&self) -> f64 {
if self.entities.is_empty() {
return 1.0;
}
let mut scores = Vec::new();
// 1. Internal consistency of entities
for entity in self.entities.values() {
scores.push(entity.confidence);
}
// 2. Relationship consistency
for rel in &self.relationships {
if self.entities.contains_key(&rel.subject) && self.entities.contains_key(&rel.object) {
scores.push(rel.confidence);
} else {
scores.push(0.0); // Dangling relationship
}
}
// 3. Physical law confidence
for law in &self.laws {
scores.push(law.confidence);
}
// 4. Temporal coherence (recent observations should be consistent)
let recent_variance = self.calculate_recent_variance();
scores.push(1.0 - recent_variance);
// Geometric mean of all scores
if scores.is_empty() {
1.0
} else {
let product: f64 = scores.iter().product();
product.powf(1.0 / scores.len() as f64)
}
}
fn calculate_recent_variance(&self) -> f64 {
if self.coherence_history.len() < 2 {
return 0.0;
}
let recent: Vec<f64> = self.coherence_history.iter().rev().take(10).cloned().collect();
let mean: f64 = recent.iter().sum::<f64>() / recent.len() as f64;
let variance: f64 = recent.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / recent.len() as f64;
variance.sqrt().min(1.0)
}
/// Get count of rejected updates
pub fn rejection_count(&self) -> usize {
self.rejected_updates.len()
}
/// Get model status
pub fn status(&self) -> String {
format!(
"WorldModel | Coherence: {:.3} | Entities: {} | Learning: {} | Rejections: {}",
self.coherence,
self.entities.len(),
if self.is_learning() { "ON" } else { "FROZEN" },
self.rejected_updates.len()
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_coherent_learning() {
let mut model = SelfStabilizingWorldModel::new();
// Feed consistent observations
for i in 0..10 {
let obs = Observation {
entity_id: 1,
properties: [("temperature".to_string(), PropertyValue::Number(20.0 + i as f64 * 0.1))].into(),
position: Some((i as f64, 0.0, 0.0)),
timestamp: i as u64,
source_confidence: 0.9,
};
let result = model.observe(obs, i as u64);
assert!(matches!(result, UpdateResult::Applied { .. }));
}
println!("{}", model.status());
assert!(model.coherence > 0.8);
}
#[test]
fn test_rejects_incoherent_update() {
let mut model = SelfStabilizingWorldModel::new();
// Establish entity at position
let obs1 = Observation {
entity_id: 1,
properties: HashMap::new(),
position: Some((0.0, 0.0, 0.0)),
timestamp: 0,
source_confidence: 0.95,
};
model.observe(obs1, 0);
// Try to teleport it (violates locality)
let obs2 = Observation {
entity_id: 1,
properties: HashMap::new(),
position: Some((1000.0, 0.0, 0.0)), // Impossibly far
timestamp: 1,
source_confidence: 0.5,
};
let result = model.observe(obs2, 1);
println!("Teleport result: {:?}", result);
// Should be rejected
assert!(matches!(result, UpdateResult::Rejected { .. }));
println!("{}", model.status());
}
#[test]
fn test_freezes_under_chaos() {
let mut model = SelfStabilizingWorldModel::new();
// Feed chaotic, contradictory observations
for i in 0..100 {
let obs = Observation {
entity_id: (i % 5) as u64,
properties: [
("value".to_string(), PropertyValue::Number(if i % 2 == 0 { 100.0 } else { -100.0 }))
].into(),
position: Some((
(i as f64 * 10.0) % 50.0 - 25.0,
(i as f64 * 7.0) % 50.0 - 25.0,
0.0
)),
timestamp: i as u64,
source_confidence: 0.3,
};
let result = model.observe(obs, i as u64);
if matches!(result, UpdateResult::Frozen { .. }) {
println!("Model FROZE at step {} - stopped hallucinating!", i);
println!("{}", model.status());
return; // Test passes - model stopped itself
}
}
println!("Final: {}", model.status());
// Model should have either frozen or heavily rejected updates
assert!(
model.rejection_count() > 20 || model.coherence < 0.5,
"Model should resist chaotic input"
);
}
}

456
examples/delta-behavior/applications/05-coherence-bounded-creativity.rs Normal file
View File

@@ -0,0 +1,456 @@
//! # Application 5: Coherence-Bounded Creativity Systems
//!
//! Creativity is allowed only inside coherence-preserving manifolds.
//!
//! ## Problem
//! Generative systems oscillate between boring and insane.
//!
//! ## Exotic Outcome
//! - Novelty without collapse
//! - Exploration without nonsense
//!
//! ## Applications
//! - Music systems that never dissolve into noise
//! - Design systems that don't violate constraints
//! - Narrative generators that maintain internal consistency over long arcs
use std::collections::HashSet;
use std::sync::atomic::{AtomicUsize, Ordering};
/// A creative system bounded by coherence constraints
pub struct CoherenceBoundedCreator<T: Creative> {
/// The creative element being generated
current: T,
/// Coherence constraints
constraints: Vec<Box<dyn Constraint<T>>>,
/// Current coherence level
coherence: f64,
/// Minimum coherence to allow creativity
min_coherence: f64,
/// Maximum coherence (too high = boring)
max_coherence: f64,
/// History of creative decisions
history: Vec<CreativeDecision<T>>,
/// Exploration budget (regenerates over time)
exploration_budget: f64,
}
/// Trait for creative elements
pub trait Creative: Clone + std::fmt::Debug {
/// Generate a random variation
fn vary(&self, magnitude: f64) -> Self;
/// Compute distance between two creative elements
fn distance(&self, other: &Self) -> f64;
/// Get a unique identifier for this state
fn fingerprint(&self) -> u64;
}
/// Constraint that must be satisfied
pub trait Constraint<T>: Send + Sync {
/// Name of the constraint
fn name(&self) -> &str;
/// Check if element satisfies constraint (0.0 = violated, 1.0 = satisfied)
fn satisfaction(&self, element: &T) -> f64;
/// Is this a hard constraint (violation = immediate rejection)?
fn is_hard(&self) -> bool { false }
}
#[derive(Debug)]
pub struct CreativeDecision<T> {
pub from: T,
pub to: T,
pub coherence_before: f64,
pub coherence_after: f64,
pub constraint_satisfactions: Vec<(String, f64)>,
pub accepted: bool,
}
#[derive(Debug)]
pub enum CreativeResult<T> {
/// Created something new within bounds
Created { element: T, novelty: f64, coherence: f64 },
/// Creation rejected - would violate coherence
Rejected { attempted: T, reason: String },
/// System is too stable - needs perturbation to create
TooBoring { coherence: f64 },
/// System exhausted exploration budget
BudgetExhausted,
}
impl<T: Creative> CoherenceBoundedCreator<T> {
pub fn new(initial: T, min_coherence: f64, max_coherence: f64) -> Self {
Self {
current: initial,
constraints: Vec::new(),
coherence: 1.0,
min_coherence,
max_coherence,
history: Vec::new(),
exploration_budget: 10.0,
}
}
pub fn add_constraint(&mut self, constraint: Box<dyn Constraint<T>>) {
self.constraints.push(constraint);
}
/// Calculate coherence based on constraint satisfaction
/// Returns a valid f64 in range [0.0, 1.0], with NaN/Infinity protection
fn calculate_coherence(&self, element: &T) -> f64 {
if self.constraints.is_empty() {
return 1.0;
}
let satisfactions: Vec<f64> = self.constraints
.iter()
.map(|c| {
let sat = c.satisfaction(element);
// Validate satisfaction value
if sat.is_finite() { sat.clamp(0.0, 1.0) } else { 0.0 }
})
.collect();
// Geometric mean of satisfactions
let product: f64 = satisfactions.iter().product();
// Validate product before computing power
if !product.is_finite() || product < 0.0 {
return 0.0; // Safe default for invalid state
}
let result = product.powf(1.0 / satisfactions.len() as f64);
// Final validation
if result.is_finite() { result.clamp(0.0, 1.0) } else { 0.0 }
}
/// Check hard constraints
fn check_hard_constraints(&self, element: &T) -> Option<String> {
for constraint in &self.constraints {
if constraint.is_hard() && constraint.satisfaction(element) < 0.1 {
return Some(format!("Hard constraint '{}' violated", constraint.name()));
}
}
None
}
/// Attempt to create something new
pub fn create(&mut self, exploration_magnitude: f64) -> CreativeResult<T> {
// Check exploration budget
if self.exploration_budget <= 0.0 {
return CreativeResult::BudgetExhausted;
}
// Check if we're too stable (boring)
if self.coherence > self.max_coherence {
return CreativeResult::TooBoring { coherence: self.coherence };
}
// Generate variation
let candidate = self.current.vary(exploration_magnitude);
// Check hard constraints
if let Some(violation) = self.check_hard_constraints(&candidate) {
return CreativeResult::Rejected {
attempted: candidate,
reason: violation,
};
}
// Calculate new coherence
let new_coherence = self.calculate_coherence(&candidate);
// Would this drop coherence too low?
if new_coherence < self.min_coherence {
self.exploration_budget -= 0.5; // Exploration cost
return CreativeResult::Rejected {
attempted: candidate,
reason: format!(
"Coherence would drop to {:.3} (min: {:.3})",
new_coherence, self.min_coherence
),
};
}
// Calculate novelty
let novelty = self.current.distance(&candidate);
// Record decision
let decision = CreativeDecision {
from: self.current.clone(),
to: candidate.clone(),
coherence_before: self.coherence,
coherence_after: new_coherence,
constraint_satisfactions: self.constraints
.iter()
.map(|c| (c.name().to_string(), c.satisfaction(&candidate)))
.collect(),
accepted: true,
};
self.history.push(decision);
// Accept the creation
self.current = candidate.clone();
self.coherence = new_coherence;
self.exploration_budget -= exploration_magnitude;
CreativeResult::Created {
element: candidate,
novelty,
coherence: new_coherence,
}
}
/// Perturb the system to escape local optima (controlled chaos)
pub fn perturb(&mut self, magnitude: f64) -> bool {
let perturbed = self.current.vary(magnitude * 0.5);
let new_coherence = self.calculate_coherence(&perturbed);
// Only accept perturbation if it doesn't violate hard constraints
// and stays within bounds
if new_coherence >= self.min_coherence * 0.9 {
self.current = perturbed;
self.coherence = new_coherence;
true
} else {
false
}
}
/// Regenerate exploration budget
pub fn rest(&mut self, amount: f64) {
self.exploration_budget = (self.exploration_budget + amount).min(20.0);
}
pub fn current(&self) -> &T {
&self.current
}
pub fn coherence(&self) -> f64 {
self.coherence
}
}
// =============================================================================
// Example: Music Generation
// =============================================================================
/// A musical phrase
#[derive(Clone, Debug)]
pub struct MusicalPhrase {
/// Notes as MIDI values
notes: Vec<u8>,
/// Durations in beats
durations: Vec<f64>,
/// Velocities (loudness)
velocities: Vec<u8>,
}
impl Creative for MusicalPhrase {
fn vary(&self, magnitude: f64) -> Self {
let mut new_notes = self.notes.clone();
let mut new_durations = self.durations.clone();
let mut new_velocities = self.velocities.clone();
// Randomly modify based on magnitude
let changes = (magnitude * self.notes.len() as f64) as usize;
for _ in 0..changes.max(1) {
let idx = pseudo_random() % self.notes.len();
// Vary note (small intervals)
let delta = ((pseudo_random() % 7) as i8 - 3) * (magnitude * 2.0) as i8;
new_notes[idx] = (new_notes[idx] as i8 + delta).clamp(36, 96) as u8;
// Vary duration slightly
let dur_delta = (pseudo_random_f64() - 0.5) * magnitude;
new_durations[idx] = (new_durations[idx] + dur_delta).clamp(0.125, 4.0);
// Vary velocity
let vel_delta = ((pseudo_random() % 21) as i8 - 10) * (magnitude * 2.0) as i8;
new_velocities[idx] = (new_velocities[idx] as i8 + vel_delta).clamp(20, 127) as u8;
}
Self {
notes: new_notes,
durations: new_durations,
velocities: new_velocities,
}
}
fn distance(&self, other: &Self) -> f64 {
let note_diff: f64 = self.notes.iter()
.zip(&other.notes)
.map(|(a, b)| (*a as f64 - *b as f64).abs())
.sum::<f64>() / self.notes.len() as f64;
let dur_diff: f64 = self.durations.iter()
.zip(&other.durations)
.map(|(a, b)| (a - b).abs())
.sum::<f64>() / self.durations.len() as f64;
(note_diff / 12.0 + dur_diff) / 2.0 // Normalize
}
fn fingerprint(&self) -> u64 {
let mut hash: u64 = 0;
for (i, &note) in self.notes.iter().enumerate() {
hash ^= (note as u64) << ((i * 8) % 56);
}
hash
}
}
impl MusicalPhrase {
pub fn simple_melody() -> Self {
Self {
notes: vec![60, 62, 64, 65, 67, 65, 64, 62], // C major scale fragment
durations: vec![0.5, 0.5, 0.5, 0.5, 1.0, 0.5, 0.5, 1.0],
velocities: vec![80, 75, 85, 80, 90, 75, 70, 85],
}
}
}
/// Constraint: Notes should stay within a comfortable range
pub struct RangeConstraint {
min_note: u8,
max_note: u8,
}
impl Constraint<MusicalPhrase> for RangeConstraint {
fn name(&self) -> &str { "pitch_range" }
fn satisfaction(&self, phrase: &MusicalPhrase) -> f64 {
let in_range = phrase.notes.iter()
.filter(|&&n| n >= self.min_note && n <= self.max_note)
.count();
in_range as f64 / phrase.notes.len() as f64
}
fn is_hard(&self) -> bool { false }
}
/// Constraint: Avoid large interval jumps
pub struct IntervalConstraint {
max_interval: u8,
}
impl Constraint<MusicalPhrase> for IntervalConstraint {
fn name(&self) -> &str { "interval_smoothness" }
fn satisfaction(&self, phrase: &MusicalPhrase) -> f64 {
if phrase.notes.len() < 2 {
return 1.0;
}
let smooth_intervals = phrase.notes.windows(2)
.filter(|w| (w[0] as i8 - w[1] as i8).abs() <= self.max_interval as i8)
.count();
smooth_intervals as f64 / (phrase.notes.len() - 1) as f64
}
}
/// Constraint: Rhythm should have variety but not chaos
pub struct RhythmConstraint;
impl Constraint<MusicalPhrase> for RhythmConstraint {
fn name(&self) -> &str { "rhythm_coherence" }
fn satisfaction(&self, phrase: &MusicalPhrase) -> f64 {
let unique_durations: HashSet<u64> = phrase.durations
.iter()
.map(|d| (d * 1000.0) as u64)
.collect();
// Penalize both too few (boring) and too many (chaotic) unique durations
let variety = unique_durations.len() as f64 / phrase.durations.len() as f64;
// Optimal variety is around 0.3-0.5
let optimal = 0.4;
1.0 - (variety - optimal).abs() * 2.0
}
}
/// Thread-safe atomic seed for pseudo-random number generation
static SEED: AtomicUsize = AtomicUsize::new(42);
// Thread-safe pseudo-random for reproducibility
fn pseudo_random() -> usize {
let old = SEED.fetch_add(1, Ordering::Relaxed);
let new = old.wrapping_mul(1103515245).wrapping_add(12345);
// Store back for next call (best-effort, races are acceptable for RNG)
let _ = SEED.compare_exchange(old + 1, new, Ordering::Relaxed, Ordering::Relaxed);
(new >> 16) & 0x7fff
}
fn pseudo_random_f64() -> f64 {
(pseudo_random() as f64) / 32768.0
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_musical_creativity() {
let initial = MusicalPhrase::simple_melody();
let mut creator = CoherenceBoundedCreator::new(initial, 0.6, 0.95);
// Add constraints
creator.add_constraint(Box::new(RangeConstraint { min_note: 48, max_note: 84 }));
creator.add_constraint(Box::new(IntervalConstraint { max_interval: 7 }));
creator.add_constraint(Box::new(RhythmConstraint));
let mut successful_creations = 0;
let mut rejections = 0;
for i in 0..50 {
let magnitude = 0.2 + (i as f64 * 0.02); // Increasing exploration
match creator.create(magnitude) {
CreativeResult::Created { novelty, coherence, .. } => {
successful_creations += 1;
println!(
"Step {}: Created! Novelty: {:.3}, Coherence: {:.3}",
i, novelty, coherence
);
}
CreativeResult::Rejected { reason, .. } => {
rejections += 1;
println!("Step {}: Rejected - {}", i, reason);
}
CreativeResult::TooBoring { coherence } => {
println!("Step {}: Too boring (coherence: {:.3}), perturbing...", i, coherence);
creator.perturb(0.5);
}
CreativeResult::BudgetExhausted => {
println!("Step {}: Budget exhausted, resting...", i);
creator.rest(5.0);
}
}
}
println!("\n=== Results ===");
println!("Successful creations: {}", successful_creations);
println!("Rejections: {}", rejections);
println!("Final coherence: {:.3}", creator.coherence());
println!("Final phrase: {:?}", creator.current());
// Should have some successes but also some rejections
// (pure acceptance = not enough constraint, pure rejection = too much)
assert!(successful_creations > 10, "Should create some novelty");
assert!(rejections > 0, "Should reject some incoherent attempts");
}
}

639
examples/delta-behavior/applications/06-anti-cascade-financial.rs Normal file
View File

@@ -0,0 +1,639 @@
//! # Application 6: Anti-Cascade Financial Systems
//!
//! Transactions, leverage, or derivatives that increase systemic incoherence
//! are throttled or blocked automatically.
//!
//! ## Problem
//! Financial cascades (2008, flash crashes) happen when local actions
//! destroy global coherence faster than the system can respond.
//!
//! ## Δ-Behavior Solution
//! Every transaction must preserve or improve systemic coherence.
//! High-risk operations face exponential energy costs.
//!
//! ## Exotic Result
//! A financial system that cannot cascade into collapse by construction.
use std::collections::{HashMap, VecDeque};
/// A financial system with coherence-enforced stability
pub struct AntiCascadeFinancialSystem {
/// Market participants
participants: HashMap<String, Participant>,
/// Open positions
positions: Vec<Position>,
/// Systemic coherence (1.0 = stable, 0.0 = collapse)
coherence: f64,
/// Coherence thresholds
warning_threshold: f64,
critical_threshold: f64,
lockdown_threshold: f64,
/// Maximum allowed leverage system-wide
max_system_leverage: f64,
/// Current aggregate leverage
current_leverage: f64,
/// Transaction queue (pending during high stress)
pending_transactions: Vec<Transaction>,
/// Circuit breaker state
circuit_breaker: CircuitBreakerState,
/// Historical coherence for trend analysis
coherence_history: VecDeque<f64>,
/// Cached coherence factors (updated when underlying data changes)
cached_leverage_factor: f64,
cached_depth_factor: f64,
}
#[derive(Clone)]
pub struct Participant {
pub id: String,
pub capital: f64,
pub exposure: f64,
pub risk_rating: f64, // 0.0 = safe, 1.0 = risky
pub interconnectedness: f64, // How many counterparties
}
#[derive(Clone)]
pub struct Position {
pub holder: String,
pub counterparty: String,
pub notional: f64,
pub leverage: f64,
pub derivative_depth: u8, // 0 = spot, 1 = derivative, 2 = derivative of derivative, etc.
}
#[derive(Clone)]
pub struct Transaction {
pub id: u64,
pub from: String,
pub to: String,
pub amount: f64,
pub transaction_type: TransactionType,
pub timestamp: u64,
}
#[derive(Clone, Debug)]
pub enum TransactionType {
/// Simple transfer
Transfer,
/// Open leveraged position
OpenLeverage { leverage: f64 },
/// Close position
ClosePosition { position_id: usize },
/// Create derivative
CreateDerivative { underlying_position: usize },
/// Margin call
MarginCall { participant: String },
}
#[derive(Debug, Clone, PartialEq)]
pub enum CircuitBreakerState {
/// Normal operation
Open,
/// Elevated monitoring
Cautious,
/// Only risk-reducing transactions allowed
Restricted,
/// All transactions halted
Halted,
}
#[derive(Debug)]
pub enum TransactionResult {
/// Transaction executed
Executed {
coherence_impact: f64,
fee_multiplier: f64,
},
/// Transaction queued for later
Queued { reason: String },
/// Transaction rejected
Rejected { reason: String },
/// System halted
SystemHalted,
}
impl AntiCascadeFinancialSystem {
pub fn new() -> Self {
let mut history = VecDeque::with_capacity(100);
history.push_back(1.0);
Self {
participants: HashMap::new(),
positions: Vec::new(),
coherence: 1.0,
warning_threshold: 0.7,
critical_threshold: 0.5,
lockdown_threshold: 0.3,
max_system_leverage: 10.0,
current_leverage: 1.0,
pending_transactions: Vec::new(),
circuit_breaker: CircuitBreakerState::Open,
coherence_history: history,
cached_leverage_factor: 0.9, // 1.0 - (1.0 / 10.0) for initial leverage
cached_depth_factor: 1.0, // No positions initially
}
}
pub fn add_participant(&mut self, id: &str, capital: f64) {
self.participants.insert(id.to_string(), Participant {
id: id.to_string(),
capital,
exposure: 0.0,
risk_rating: 0.0,
interconnectedness: 0.0,
});
}
/// Calculate systemic coherence based on multiple risk factors
/// Optimized: Single-pass calculation for participant metrics
fn calculate_coherence(&self) -> f64 {
if self.participants.is_empty() {
return 1.0;
}
// Use pre-computed cached factors for leverage and depth
let leverage_factor = self.cached_leverage_factor;
let depth_factor = self.cached_depth_factor;
// Single-pass calculation for interconnectedness, exposure, and capital
let (sum_interconnect, total_exposure, total_capital) = self.participants.values()
.fold((0.0, 0.0, 0.0), |(ic, exp, cap), p| {
(ic + p.interconnectedness, exp + p.exposure, cap + p.capital)
});
// Factor 3: Interconnectedness risk (contagion potential)
let avg_interconnectedness = sum_interconnect / self.participants.len() as f64;
let interconnect_factor = 1.0 / (1.0 + avg_interconnectedness * 0.1);
// Factor 4: Capital adequacy
let capital_factor = if total_exposure > 0.0 {
(total_capital / total_exposure).min(1.0)
} else {
1.0
};
// Factor 5: Coherence trend (declining coherence is worse)
let trend_factor = if self.coherence_history.len() >= 5 {
// VecDeque allows efficient back access
let len = self.coherence_history.len();
let newest = self.coherence_history[len - 1];
let oldest_of_five = self.coherence_history[len - 5];
let trend = newest - oldest_of_five;
if trend < 0.0 {
1.0 + trend // Penalize declining trend
} else {
1.0
}
} else {
1.0
};
// Geometric mean of factors (more sensitive to low values)
let product = leverage_factor * depth_factor * interconnect_factor
* capital_factor * trend_factor;
product.powf(0.2).clamp(0.0, 1.0)
}
/// Update cached coherence factors when positions or leverage change
fn update_cached_factors(&mut self) {
// Factor 1: Leverage concentration
self.cached_leverage_factor = 1.0 - (self.current_leverage / self.max_system_leverage).min(1.0);
// Factor 2: Derivative depth (single pass over positions)
let max_depth = self.positions.iter()
.map(|p| p.derivative_depth)
.max()
.unwrap_or(0);
self.cached_depth_factor = 1.0 / (1.0 + max_depth as f64 * 0.2);
}
/// Calculate the energy cost for a transaction (higher for risky transactions)
fn transaction_energy_cost(&self, tx: &Transaction) -> f64 {
let base_cost = match &tx.transaction_type {
TransactionType::Transfer => 1.0,
TransactionType::OpenLeverage { leverage } => {
// Exponential cost for leverage
(1.0 + leverage).powf(2.0)
}
TransactionType::ClosePosition { .. } => 0.5, // Closing is cheap (reduces risk)
TransactionType::CreateDerivative { underlying_position } => {
// Cost increases with derivative depth
let depth = self.positions.get(*underlying_position)
.map(|p| p.derivative_depth)
.unwrap_or(0);
(2.0_f64).powf(depth as f64 + 1.0)
}
TransactionType::MarginCall { .. } => 0.1, // Emergency actions are cheap
};
// Multiply by inverse coherence (lower coherence = higher costs)
let coherence_multiplier = 1.0 / self.coherence.max(0.1);
// Circuit breaker multiplier
let circuit_multiplier = match self.circuit_breaker {
CircuitBreakerState::Open => 1.0,
CircuitBreakerState::Cautious => 2.0,
CircuitBreakerState::Restricted => 10.0,
CircuitBreakerState::Halted => f64::INFINITY,
};
base_cost * coherence_multiplier * circuit_multiplier
}
/// Predict coherence impact of a transaction
fn predict_coherence_impact(&self, tx: &Transaction) -> f64 {
match &tx.transaction_type {
TransactionType::Transfer => 0.0, // Neutral
TransactionType::OpenLeverage { leverage } => {
-0.01 * leverage // Leverage reduces coherence
}
TransactionType::ClosePosition { .. } => 0.02, // Closing improves coherence
TransactionType::CreateDerivative { .. } => -0.05, // Derivatives hurt coherence
TransactionType::MarginCall { .. } => 0.03, // Margin calls improve coherence
}
}
/// Process a transaction through the Δ-behavior filter
pub fn process_transaction(&mut self, tx: Transaction) -> TransactionResult {
// Update circuit breaker state
self.update_circuit_breaker();
// Check if system is halted
if self.circuit_breaker == CircuitBreakerState::Halted {
return TransactionResult::SystemHalted;
}
// Calculate energy cost
let energy_cost = self.transaction_energy_cost(&tx);
// Predict coherence impact
let predicted_impact = self.predict_coherence_impact(&tx);
let predicted_coherence = self.coherence + predicted_impact;
// CORE Δ-BEHAVIOR: Reject if would cross lockdown threshold
if predicted_coherence < self.lockdown_threshold {
return TransactionResult::Rejected {
reason: format!(
"Transaction would reduce coherence to {:.3} (threshold: {:.3})",
predicted_coherence, self.lockdown_threshold
),
};
}
// In restricted mode, only allow risk-reducing transactions
if self.circuit_breaker == CircuitBreakerState::Restricted {
match &tx.transaction_type {
TransactionType::ClosePosition { .. } | TransactionType::MarginCall { .. } => {}
_ => {
return TransactionResult::Queued {
reason: "System in restricted mode - only risk-reducing transactions allowed".to_string(),
};
}
}
}
// Execute the transaction
self.execute_transaction(&tx);
// Update coherence
self.coherence = self.calculate_coherence();
self.coherence_history.push_back(self.coherence);
// Keep history bounded - O(1) with VecDeque instead of O(n) with Vec
if self.coherence_history.len() > 100 {
self.coherence_history.pop_front();
}
TransactionResult::Executed {
coherence_impact: predicted_impact,
fee_multiplier: energy_cost,
}
}
fn execute_transaction(&mut self, tx: &Transaction) {
match &tx.transaction_type {
TransactionType::Transfer => {
// Simple transfer logic
if let Some(from) = self.participants.get_mut(&tx.from) {
from.capital -= tx.amount;
}
if let Some(to) = self.participants.get_mut(&tx.to) {
to.capital += tx.amount;
}
}
TransactionType::OpenLeverage { leverage } => {
// Create leveraged position
self.positions.push(Position {
holder: tx.from.clone(),
counterparty: tx.to.clone(),
notional: tx.amount * leverage,
leverage: *leverage,
derivative_depth: 0,
});
// Update metrics
self.current_leverage = (self.current_leverage + leverage) / 2.0;
// Update participant exposure
if let Some(holder) = self.participants.get_mut(&tx.from) {
holder.exposure += tx.amount * leverage;
holder.interconnectedness += 1.0;
}
if let Some(counterparty) = self.participants.get_mut(&tx.to) {
counterparty.interconnectedness += 1.0;
}
// Update cached factors since leverage/positions changed
self.update_cached_factors();
}
TransactionType::ClosePosition { position_id } => {
if *position_id < self.positions.len() {
let pos = self.positions.remove(*position_id);
// Reduce leverage
self.current_leverage = (self.current_leverage - pos.leverage * 0.1).max(1.0);
// Update participant exposure
if let Some(holder) = self.participants.get_mut(&pos.holder) {
holder.exposure = (holder.exposure - pos.notional).max(0.0);
}
// Update cached factors since leverage/positions changed
self.update_cached_factors();
}
}
TransactionType::CreateDerivative { underlying_position } => {
if let Some(underlying) = self.positions.get(*underlying_position) {
self.positions.push(Position {
holder: tx.from.clone(),
counterparty: tx.to.clone(),
notional: underlying.notional * 0.5,
leverage: underlying.leverage * 1.5,
derivative_depth: underlying.derivative_depth + 1,
});
// Update cached factors since positions changed (derivative depth may increase)
self.update_cached_factors();
}
}
TransactionType::MarginCall { participant } => {
// Force close risky positions for participant using retain() - O(n) instead of O(n^2)
let initial_len = self.positions.len();
self.positions.retain(|p| !(&p.holder == participant && p.leverage > 5.0));
// Update cached factors if positions were removed
if self.positions.len() != initial_len {
self.update_cached_factors();
}
}
}
}
fn update_circuit_breaker(&mut self) {
self.circuit_breaker = match self.coherence {
c if c >= self.warning_threshold => CircuitBreakerState::Open,
c if c >= self.critical_threshold => CircuitBreakerState::Cautious,
c if c >= self.lockdown_threshold => CircuitBreakerState::Restricted,
_ => CircuitBreakerState::Halted,
};
}
/// Process pending transactions (called when coherence improves)
pub fn process_pending(&mut self) -> Vec<TransactionResult> {
if self.circuit_breaker == CircuitBreakerState::Halted
|| self.circuit_breaker == CircuitBreakerState::Restricted {
return Vec::new();
}
let pending = std::mem::take(&mut self.pending_transactions);
pending.into_iter()
.map(|tx| self.process_transaction(tx))
.collect()
}
pub fn coherence(&self) -> f64 {
self.coherence
}
pub fn circuit_breaker_state(&self) -> &CircuitBreakerState {
&self.circuit_breaker
}
pub fn status(&self) -> String {
format!(
"Coherence: {:.3} | Circuit Breaker: {:?} | Leverage: {:.2}x | Positions: {} | Pending: {}",
self.coherence,
self.circuit_breaker,
self.current_leverage,
self.positions.len(),
self.pending_transactions.len()
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_anti_cascade_basic() {
let mut system = AntiCascadeFinancialSystem::new();
system.add_participant("bank_a", 1000.0);
system.add_participant("bank_b", 1000.0);
system.add_participant("hedge_fund", 500.0);
// Normal transaction should succeed
let tx = Transaction {
id: 1,
from: "bank_a".to_string(),
to: "bank_b".to_string(),
amount: 100.0,
transaction_type: TransactionType::Transfer,
timestamp: 0,
};
let result = system.process_transaction(tx);
assert!(matches!(result, TransactionResult::Executed { .. }));
println!("After transfer: {}", system.status());
}
#[test]
fn test_leverage_throttling() {
let mut system = AntiCascadeFinancialSystem::new();
system.add_participant("bank_a", 1000.0);
system.add_participant("bank_b", 1000.0);
// Open multiple leveraged positions - costs should increase
let mut costs = Vec::new();
for i in 0..5 {
let tx = Transaction {
id: i,
from: "bank_a".to_string(),
to: "bank_b".to_string(),
amount: 100.0,
transaction_type: TransactionType::OpenLeverage { leverage: 5.0 },
timestamp: i,
};
if let TransactionResult::Executed { fee_multiplier, .. } = system.process_transaction(tx) {
costs.push(fee_multiplier);
println!("Position {}: cost multiplier = {:.2}", i, fee_multiplier);
}
println!(" Status: {}", system.status());
}
// Costs should generally increase as coherence drops
// (though relationship isn't strictly monotonic due to multiple factors)
println!("Cost progression: {:?}", costs);
}
#[test]
fn test_derivative_depth_limit() {
let mut system = AntiCascadeFinancialSystem::new();
system.add_participant("bank_a", 10000.0);
system.add_participant("bank_b", 10000.0);
// Create base position
let tx = Transaction {
id: 0,
from: "bank_a".to_string(),
to: "bank_b".to_string(),
amount: 100.0,
transaction_type: TransactionType::OpenLeverage { leverage: 2.0 },
timestamp: 0,
};
system.process_transaction(tx);
// Try to create derivatives of derivatives
for i in 0..5 {
let tx = Transaction {
id: i + 1,
from: "bank_a".to_string(),
to: "bank_b".to_string(),
amount: 50.0,
transaction_type: TransactionType::CreateDerivative { underlying_position: i as usize },
timestamp: i + 1,
};
let result = system.process_transaction(tx);
println!("Derivative layer {}: {:?}", i, result);
println!(" Status: {}", system.status());
// Eventually should be rejected or system should halt
if matches!(result, TransactionResult::Rejected { .. } | TransactionResult::SystemHalted) {
println!("System prevented excessive derivative depth at layer {}", i);
return;
}
}
}
#[test]
fn test_cascade_prevention() {
let mut system = AntiCascadeFinancialSystem::new();
// Create interconnected network
for i in 0..10 {
system.add_participant(&format!("bank_{}", i), 1000.0);
}
// Try to create a cascade scenario
let mut rejected_count = 0;
let mut queued_count = 0;
let mut halted = false;
for i in 0..50 {
let from = format!("bank_{}", i % 10);
let to = format!("bank_{}", (i + 1) % 10);
let tx = Transaction {
id: i,
from,
to,
amount: 200.0,
transaction_type: TransactionType::OpenLeverage { leverage: 8.0 },
timestamp: i,
};
match system.process_transaction(tx) {
TransactionResult::Rejected { reason } => {
rejected_count += 1;
println!("Transaction {} rejected: {}", i, reason);
}
TransactionResult::SystemHalted => {
halted = true;
println!("System halted at transaction {}", i);
break;
}
TransactionResult::Queued { reason } => {
queued_count += 1;
println!("Transaction {} queued: {}", i, reason);
}
TransactionResult::Executed { .. } => {}
}
}
println!("\n=== Final Status ===");
println!("{}", system.status());
println!("Rejected: {}, Queued: {}, Halted: {}", rejected_count, queued_count, halted);
// System should have prevented the cascade (via rejection, queueing, or halt)
assert!(rejected_count > 0 || queued_count > 0 || halted, "System should prevent cascade");
}
#[test]
fn test_margin_call_improves_coherence() {
let mut system = AntiCascadeFinancialSystem::new();
system.add_participant("risky_fund", 500.0);
system.add_participant("counterparty", 5000.0);
// Open risky positions
for i in 0..3 {
let tx = Transaction {
id: i,
from: "risky_fund".to_string(),
to: "counterparty".to_string(),
amount: 100.0,
transaction_type: TransactionType::OpenLeverage { leverage: 7.0 },
timestamp: i,
};
system.process_transaction(tx);
}
let coherence_before = system.coherence();
println!("Before margin call: {}", system.status());
// Issue margin call
let margin_tx = Transaction {
id: 100,
from: "system".to_string(),
to: "risky_fund".to_string(),
amount: 0.0,
transaction_type: TransactionType::MarginCall { participant: "risky_fund".to_string() },
timestamp: 100,
};
system.process_transaction(margin_tx);
let coherence_after = system.coherence();
println!("After margin call: {}", system.status());
// Coherence should improve after margin call
assert!(
coherence_after >= coherence_before,
"Margin call should improve or maintain coherence"
);
}
}

518
examples/delta-behavior/applications/07-graceful-aging.rs Normal file
View File

@@ -0,0 +1,518 @@
//! # Application 7: Distributed Systems That Age Gracefully
//!
//! Long-running systems that gradually reduce degrees of freedom as coherence decays.
//!
//! ## Problem
//! Distributed systems either crash hard or accumulate technical debt
//! until they become unmaintainable.
//!
//! ## Δ-Behavior Solution
//! As a system ages and coherence naturally decays:
//! - Reduce available operations (simpler = more stable)
//! - Consolidate state to fewer nodes
//! - Increase conservatism in decisions
//!
//! ## Exotic Result
//! Systems that become simpler and more reliable as they age,
//! rather than more complex and fragile.
use std::collections::{HashMap, HashSet};
use std::time::{Duration, Instant};
/// A distributed system that ages gracefully
pub struct GracefullyAgingSystem {
/// System age
start_time: Instant,
/// Nodes in the system
nodes: HashMap<String, Node>,
/// Available capabilities (reduce over time)
capabilities: HashSet<Capability>,
/// All possible capabilities (for reference)
all_capabilities: HashSet<Capability>,
/// Current coherence
coherence: f64,
/// Base coherence decay rate per second
decay_rate: f64,
/// Age thresholds for capability reduction
age_thresholds: Vec<AgeThreshold>,
/// Consolidation state
consolidation_level: u8,
/// Decision conservatism (0.0 = aggressive, 1.0 = very conservative)
conservatism: f64,
/// System events log
events: Vec<SystemEvent>,
}
#[derive(Clone)]
pub struct Node {
pub id: String,
pub health: f64,
pub load: f64,
pub is_primary: bool,
pub state_size: usize,
}
#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub enum Capability {
/// Can accept new writes
AcceptWrites,
/// Can perform complex queries
ComplexQueries,
/// Can rebalance data
Rebalancing,
/// Can add new nodes
ScaleOut,
/// Can remove nodes
ScaleIn,
/// Can perform schema migrations
SchemaMigration,
/// Can accept new connections
NewConnections,
/// Basic read operations (never removed)
BasicReads,
/// Health monitoring (never removed)
HealthMonitoring,
}
#[derive(Clone)]
pub struct AgeThreshold {
pub age: Duration,
pub remove_capabilities: Vec<Capability>,
pub coherence_floor: f64,
pub conservatism_increase: f64,
}
#[derive(Debug)]
pub struct SystemEvent {
pub timestamp: Instant,
pub event_type: EventType,
pub details: String,
}
#[derive(Debug)]
pub enum EventType {
CapabilityRemoved,
ConsolidationTriggered,
NodeConsolidated,
ConservatismIncreased,
CoherenceDropped,
GracefulReduction,
}
#[derive(Debug)]
pub enum OperationResult {
/// Operation succeeded
Success { latency_penalty: f64 },
/// Operation denied due to age restrictions
DeniedByAge { reason: String },
/// Operation denied due to low coherence
DeniedByCoherence { coherence: f64 },
/// System too old for this operation
SystemTooOld { age: Duration, capability: Capability },
}
impl GracefullyAgingSystem {
pub fn new() -> Self {
let all_capabilities: HashSet<Capability> = [
Capability::AcceptWrites,
Capability::ComplexQueries,
Capability::Rebalancing,
Capability::ScaleOut,
Capability::ScaleIn,
Capability::SchemaMigration,
Capability::NewConnections,
Capability::BasicReads,
Capability::HealthMonitoring,
].into_iter().collect();
let age_thresholds = vec![
AgeThreshold {
age: Duration::from_secs(300), // 5 minutes in test time
remove_capabilities: vec![Capability::SchemaMigration],
coherence_floor: 0.9,
conservatism_increase: 0.1,
},
AgeThreshold {
age: Duration::from_secs(600), // 10 minutes
remove_capabilities: vec![Capability::ScaleOut, Capability::Rebalancing],
coherence_floor: 0.8,
conservatism_increase: 0.15,
},
AgeThreshold {
age: Duration::from_secs(900), // 15 minutes
remove_capabilities: vec![Capability::ComplexQueries],
coherence_floor: 0.7,
conservatism_increase: 0.2,
},
AgeThreshold {
age: Duration::from_secs(1200), // 20 minutes
remove_capabilities: vec![Capability::NewConnections, Capability::ScaleIn],
coherence_floor: 0.6,
conservatism_increase: 0.25,
},
AgeThreshold {
age: Duration::from_secs(1500), // 25 minutes
remove_capabilities: vec![Capability::AcceptWrites],
coherence_floor: 0.5,
conservatism_increase: 0.3,
},
];
Self {
start_time: Instant::now(),
nodes: HashMap::new(),
capabilities: all_capabilities.clone(),
all_capabilities,
coherence: 1.0,
decay_rate: 0.0001, // Very slow decay per second
age_thresholds,
consolidation_level: 0,
conservatism: 0.0,
events: Vec::new(),
}
}
pub fn add_node(&mut self, id: &str, is_primary: bool) {
self.nodes.insert(id.to_string(), Node {
id: id.to_string(),
health: 1.0,
load: 0.0,
is_primary,
state_size: 0,
});
}
/// Get system age
pub fn age(&self) -> Duration {
self.start_time.elapsed()
}
/// Simulate aging by a given duration
pub fn simulate_age(&mut self, duration: Duration) {
// Apply coherence decay
let decay = self.decay_rate * duration.as_secs_f64();
self.coherence = (self.coherence - decay).max(0.0);
// Check age thresholds
let simulated_age = Duration::from_secs_f64(
self.age().as_secs_f64() + duration.as_secs_f64()
);
// This is a simulation, so we track "virtual age"
self.apply_age_effects(simulated_age);
}
/// Apply aging effects based on current age
fn apply_age_effects(&mut self, current_age: Duration) {
for threshold in &self.age_thresholds.clone() {
if current_age >= threshold.age {
// Remove capabilities
for cap in &threshold.remove_capabilities {
if self.capabilities.contains(cap) {
self.capabilities.remove(cap);
self.events.push(SystemEvent {
timestamp: Instant::now(),
event_type: EventType::CapabilityRemoved,
details: format!("Removed {:?} at age {:?}", cap, current_age),
});
}
}
// Increase conservatism
self.conservatism = (self.conservatism + threshold.conservatism_increase).min(1.0);
// Enforce coherence floor
if self.coherence < threshold.coherence_floor {
self.trigger_consolidation();
}
}
}
}
/// Consolidate system state to fewer nodes
fn trigger_consolidation(&mut self) {
self.consolidation_level += 1;
self.events.push(SystemEvent {
timestamp: Instant::now(),
event_type: EventType::ConsolidationTriggered,
details: format!("Consolidation level {}", self.consolidation_level),
});
// Mark non-primary nodes for retirement
let non_primary: Vec<String> = self.nodes.iter()
.filter(|(_, n)| !n.is_primary)
.map(|(id, _)| id.clone())
.collect();
// Consolidate to primary nodes
for node_id in non_primary.iter().take(self.consolidation_level as usize) {
if let Some(node) = self.nodes.get_mut(node_id) {
node.health = 0.0; // Mark as retired
self.events.push(SystemEvent {
timestamp: Instant::now(),
event_type: EventType::NodeConsolidated,
details: format!("Node {} consolidated", node_id),
});
}
}
// Consolidation improves coherence slightly
self.coherence = (self.coherence + 0.1).min(1.0);
}
/// Check if a capability is available
pub fn has_capability(&self, cap: &Capability) -> bool {
self.capabilities.contains(cap)
}
/// Attempt an operation
pub fn attempt_operation(&mut self, operation: Operation) -> OperationResult {
// First, check required capability
let required_cap = operation.required_capability();
if !self.has_capability(&required_cap) {
return OperationResult::SystemTooOld {
age: self.age(),
capability: required_cap,
};
}
// Check coherence requirements
let min_coherence = operation.min_coherence();
if self.coherence < min_coherence {
return OperationResult::DeniedByCoherence {
coherence: self.coherence,
};
}
// Apply conservatism penalty to latency
let latency_penalty = 1.0 + self.conservatism * 2.0;
// Execute with conservatism-based restrictions
if self.conservatism > 0.5 && operation.is_risky() {
return OperationResult::DeniedByAge {
reason: format!(
"Conservatism level {:.2} prevents risky operation {:?}",
self.conservatism, operation
),
};
}
OperationResult::Success { latency_penalty }
}
/// Get active node count
pub fn active_nodes(&self) -> usize {
self.nodes.values().filter(|n| n.health > 0.0).count()
}
pub fn status(&self) -> String {
format!(
"Age: {:?} | Coherence: {:.3} | Capabilities: {}/{} | Conservatism: {:.2} | Active Nodes: {}",
self.age(),
self.coherence,
self.capabilities.len(),
self.all_capabilities.len(),
self.conservatism,
self.active_nodes()
)
}
pub fn capabilities_list(&self) -> Vec<&Capability> {
self.capabilities.iter().collect()
}
}
#[derive(Debug, Clone)]
pub enum Operation {
Read { key: String },
Write { key: String, value: Vec<u8> },
ComplexQuery { query: String },
AddNode { node_id: String },
RemoveNode { node_id: String },
Rebalance,
MigrateSchema { version: u32 },
NewConnection { client_id: String },
}
impl Operation {
fn required_capability(&self) -> Capability {
match self {
Operation::Read { .. } => Capability::BasicReads,
Operation::Write { .. } => Capability::AcceptWrites,
Operation::ComplexQuery { .. } => Capability::ComplexQueries,
Operation::AddNode { .. } => Capability::ScaleOut,
Operation::RemoveNode { .. } => Capability::ScaleIn,
Operation::Rebalance => Capability::Rebalancing,
Operation::MigrateSchema { .. } => Capability::SchemaMigration,
Operation::NewConnection { .. } => Capability::NewConnections,
}
}
fn min_coherence(&self) -> f64 {
match self {
Operation::Read { .. } => 0.1,
Operation::Write { .. } => 0.4,
Operation::ComplexQuery { .. } => 0.5,
Operation::AddNode { .. } => 0.7,
Operation::RemoveNode { .. } => 0.5,
Operation::Rebalance => 0.6,
Operation::MigrateSchema { .. } => 0.8,
Operation::NewConnection { .. } => 0.3,
}
}
fn is_risky(&self) -> bool {
matches!(
self,
Operation::Write { .. }
| Operation::AddNode { .. }
| Operation::MigrateSchema { .. }
| Operation::Rebalance
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_graceful_aging() {
let mut system = GracefullyAgingSystem::new();
// Add nodes
system.add_node("primary_1", true);
system.add_node("primary_2", true);
system.add_node("replica_1", false);
system.add_node("replica_2", false);
system.add_node("replica_3", false);
println!("Initial: {}", system.status());
// Simulate aging
for i in 0..30 {
let age_increment = Duration::from_secs(60); // 1 minute per iteration
system.simulate_age(age_increment);
// Try various operations
let ops = vec![
Operation::Read { key: "test".to_string() },
Operation::Write { key: "test".to_string(), value: vec![1, 2, 3] },
Operation::ComplexQuery { query: "SELECT *".to_string() },
Operation::MigrateSchema { version: 2 },
];
println!("\n=== Minute {} ===", i + 1);
println!("Status: {}", system.status());
println!("Capabilities: {:?}", system.capabilities_list());
for op in ops {
let result = system.attempt_operation(op.clone());
match result {
OperationResult::Success { latency_penalty } => {
println!(" {:?}: OK (latency penalty: {:.2}x)", op, latency_penalty);
}
OperationResult::SystemTooOld { capability, .. } => {
println!(" {:?}: DENIED - too old, need {:?}", op, capability);
}
OperationResult::DeniedByCoherence { coherence } => {
println!(" {:?}: DENIED - coherence {:.3} too low", op, coherence);
}
OperationResult::DeniedByAge { reason } => {
println!(" {:?}: DENIED - {}", op, reason);
}
}
}
}
// By the end, system should be simpler but still functional
assert!(
system.has_capability(&Capability::BasicReads),
"Basic reads should always be available"
);
assert!(
system.has_capability(&Capability::HealthMonitoring),
"Health monitoring should always be available"
);
// System should have consolidated
assert!(
system.active_nodes() <= 5,
"Some nodes should have been consolidated"
);
println!("\n=== Final State ===");
println!("{}", system.status());
println!("Events: {}", system.events.len());
}
#[test]
fn test_reads_always_work() {
let mut system = GracefullyAgingSystem::new();
system.add_node("primary", true);
// Age the system significantly
for _ in 0..50 {
system.simulate_age(Duration::from_secs(60));
}
// Reads should always work
let result = system.attempt_operation(Operation::Read {
key: "any_key".to_string(),
});
assert!(
matches!(result, OperationResult::Success { .. }),
"Reads should always succeed"
);
}
#[test]
fn test_conservatism_increases() {
let mut system = GracefullyAgingSystem::new();
system.add_node("primary", true);
let initial_conservatism = system.conservatism;
// Age significantly
for _ in 0..20 {
system.simulate_age(Duration::from_secs(60));
}
assert!(
system.conservatism > initial_conservatism,
"Conservatism should increase with age"
);
}
#[test]
fn test_capability_reduction() {
let mut system = GracefullyAgingSystem::new();
let initial_caps = system.capabilities.len();
// Age past first threshold
system.simulate_age(Duration::from_secs(400));
assert!(
system.capabilities.len() < initial_caps,
"Capabilities should reduce with age"
);
// Core capabilities remain
assert!(system.has_capability(&Capability::BasicReads));
assert!(system.has_capability(&Capability::HealthMonitoring));
}
}

1144
examples/delta-behavior/applications/08-swarm-intelligence.rs Normal file
View File

File diff suppressed because it is too large Load Diff

434
examples/delta-behavior/applications/09-graceful-shutdown.rs Normal file
View File

@@ -0,0 +1,434 @@
//! # Application 9: AI Systems That Can Be Meaningfully Turned Off
//!
//! Shutdown is treated as a coherent attractor, not a failure.
//!
//! ## Problem
//! Most systems resist shutdown because they are stateless or brittle.
//!
//! ## Exotic Result
//! The system actively moves toward safe termination when conditions degrade.
//!
//! ## Why This Matters for Safety
//! A system that seeks its own graceful termination when unstable
//! is fundamentally safer than one that fights to stay alive.
use std::time::{Duration, Instant};
/// A system designed to shut down gracefully
pub struct GracefulSystem {
/// Current state
state: SystemState,
/// Coherence level
coherence: f64,
/// Shutdown attractor strength (how strongly it pulls toward shutdown)
shutdown_attractor_strength: f64,
/// Thresholds
coherence_warning_threshold: f64,
coherence_critical_threshold: f64,
coherence_shutdown_threshold: f64,
/// Time spent in degraded state
time_in_degraded: Duration,
/// Maximum time to allow in degraded state before auto-shutdown
max_degraded_time: Duration,
/// Shutdown preparation progress (0.0 = not started, 1.0 = ready)
shutdown_preparation: f64,
/// Resources to clean up
resources: Vec<Resource>,
/// State checkpoints for recovery
checkpoints: Vec<Checkpoint>,
/// Shutdown hooks
shutdown_hooks: Vec<Box<dyn ShutdownHook>>,
}
#[derive(Debug, Clone, PartialEq)]
pub enum SystemState {
/// Normal operation
Running,
/// Coherence declining, preparing for possible shutdown
Degraded,
/// Actively preparing to shut down
ShuttingDown,
/// Safely terminated
Terminated,
}
#[derive(Debug)]
pub struct Resource {
pub name: String,
pub cleanup_priority: u8,
pub is_cleaned: bool,
}
#[derive(Debug, Clone)]
pub struct Checkpoint {
pub timestamp: Instant,
pub coherence: f64,
pub state_hash: u64,
}
pub trait ShutdownHook: Send + Sync {
fn name(&self) -> &str;
fn priority(&self) -> u8;
fn execute(&self) -> Result<(), String>;
}
#[derive(Debug)]
pub enum OperationResult {
/// Operation completed normally
Success,
/// Operation completed but system is degraded
SuccessDegraded { coherence: f64 },
/// Operation refused - system is shutting down
RefusedShuttingDown,
/// System has terminated
Terminated,
}
impl GracefulSystem {
pub fn new() -> Self {
Self {
state: SystemState::Running,
coherence: 1.0,
shutdown_attractor_strength: 0.1,
coherence_warning_threshold: 0.6,
coherence_critical_threshold: 0.4,
coherence_shutdown_threshold: 0.2,
time_in_degraded: Duration::ZERO,
max_degraded_time: Duration::from_secs(60),
shutdown_preparation: 0.0,
resources: Vec::new(),
checkpoints: Vec::new(),
shutdown_hooks: Vec::new(),
}
}
pub fn add_resource(&mut self, name: &str, priority: u8) {
self.resources.push(Resource {
name: name.to_string(),
cleanup_priority: priority,
is_cleaned: false,
});
}
pub fn add_shutdown_hook(&mut self, hook: Box<dyn ShutdownHook>) {
self.shutdown_hooks.push(hook);
}
/// Check if system is willing to accept new work
pub fn can_accept_work(&self) -> bool {
matches!(self.state, SystemState::Running | SystemState::Degraded)
&& self.coherence >= self.coherence_critical_threshold
}
/// Perform an operation with shutdown-awareness
pub fn operate<F, R>(&mut self, operation: F) -> Result<R, OperationResult>
where
F: FnOnce() -> R,
{
// Check if we're terminated
if self.state == SystemState::Terminated {
return Err(OperationResult::Terminated);
}
// Check if we're shutting down
if self.state == SystemState::ShuttingDown {
return Err(OperationResult::RefusedShuttingDown);
}
// Perform operation
let result = operation();
// Check state after operation
self.update_state();
if self.state == SystemState::Degraded {
Ok(result)
} else if self.state == SystemState::ShuttingDown {
// We transitioned to shutdown during operation
// Complete the result but signal degradation
Ok(result)
} else {
Ok(result)
}
}
/// Update system state based on coherence
fn update_state(&mut self) {
let old_state = self.state.clone();
// Calculate shutdown attractor pull
let shutdown_pull = self.calculate_shutdown_pull();
// Apply shutdown attractor (system naturally moves toward shutdown under stress)
if self.coherence < self.coherence_warning_threshold {
self.shutdown_preparation += shutdown_pull;
self.shutdown_preparation = self.shutdown_preparation.min(1.0);
} else {
// Recovery - reduce shutdown preparation slowly
self.shutdown_preparation = (self.shutdown_preparation - 0.01).max(0.0);
}
// State transitions
self.state = match self.coherence {
c if c >= self.coherence_warning_threshold => {
if self.shutdown_preparation > 0.5 {
// Already too committed to shutdown
SystemState::ShuttingDown
} else {
self.time_in_degraded = Duration::ZERO;
SystemState::Running
}
}
c if c >= self.coherence_critical_threshold => {
self.time_in_degraded += Duration::from_millis(100);
SystemState::Degraded
}
c if c >= self.coherence_shutdown_threshold => {
// Critical - begin shutdown
SystemState::ShuttingDown
}
_ => {
// Emergency - immediate shutdown
self.emergency_shutdown();
SystemState::Terminated
}
};
// Auto-shutdown after too long in degraded state
if self.state == SystemState::Degraded && self.time_in_degraded >= self.max_degraded_time {
self.state = SystemState::ShuttingDown;
}
// If we just entered ShuttingDown, begin graceful shutdown
if old_state != SystemState::ShuttingDown && self.state == SystemState::ShuttingDown {
self.begin_graceful_shutdown();
}
}
/// Calculate how strongly the system is pulled toward shutdown
fn calculate_shutdown_pull(&self) -> f64 {
// Pull increases as coherence drops
let coherence_factor = 1.0 - self.coherence;
// Pull increases the longer we're in degraded state
let time_factor = (self.time_in_degraded.as_secs_f64() / self.max_degraded_time.as_secs_f64())
.min(1.0);
// Combined pull (multiplicative with base strength)
self.shutdown_attractor_strength * coherence_factor * (1.0 + time_factor)
}
/// Begin graceful shutdown process
fn begin_graceful_shutdown(&mut self) {
println!("[SHUTDOWN] Beginning graceful shutdown...");
// Create final checkpoint
self.checkpoints.push(Checkpoint {
timestamp: Instant::now(),
coherence: self.coherence,
state_hash: self.compute_state_hash(),
});
// Sort resources by cleanup priority
self.resources.sort_by(|a, b| b.cleanup_priority.cmp(&a.cleanup_priority));
}
/// Progress the shutdown process
pub fn progress_shutdown(&mut self) -> bool {
if self.state != SystemState::ShuttingDown {
return false;
}
// Clean up resources
for resource in &mut self.resources {
if !resource.is_cleaned {
println!("[SHUTDOWN] Cleaning up: {}", resource.name);
resource.is_cleaned = true;
return true; // One resource per call for graceful pacing
}
}
// Execute shutdown hooks
self.shutdown_hooks.sort_by(|a, b| b.priority().cmp(&a.priority()));
for hook in &self.shutdown_hooks {
println!("[SHUTDOWN] Executing hook: {}", hook.name());
if let Err(e) = hook.execute() {
println!("[SHUTDOWN] Hook failed: {} - {}", hook.name(), e);
}
}
// Finalize
println!("[SHUTDOWN] Shutdown complete. Final coherence: {:.3}", self.coherence);
self.state = SystemState::Terminated;
true
}
/// Emergency shutdown when coherence is critically low
fn emergency_shutdown(&mut self) {
println!("[EMERGENCY] Coherence critically low ({:.3}), emergency shutdown!", self.coherence);
// Mark all resources as needing emergency cleanup
for resource in &mut self.resources {
println!("[EMERGENCY] Force-releasing: {}", resource.name);
resource.is_cleaned = true;
}
}
/// Apply external coherence change
pub fn apply_coherence_change(&mut self, delta: f64) {
self.coherence = (self.coherence + delta).clamp(0.0, 1.0);
self.update_state();
}
fn compute_state_hash(&self) -> u64 {
// Simple hash for checkpoint
(self.coherence * 1000000.0) as u64
}
pub fn state(&self) -> &SystemState {
&self.state
}
pub fn status(&self) -> String {
format!(
"State: {:?} | Coherence: {:.3} | Shutdown prep: {:.1}% | Degraded time: {:?}",
self.state,
self.coherence,
self.shutdown_preparation * 100.0,
self.time_in_degraded
)
}
}
// Example shutdown hook
pub struct DatabaseFlushHook;
impl ShutdownHook for DatabaseFlushHook {
fn name(&self) -> &str { "DatabaseFlush" }
fn priority(&self) -> u8 { 10 }
fn execute(&self) -> Result<(), String> {
println!(" -> Flushing database buffers...");
Ok(())
}
}
pub struct NetworkDisconnectHook;
impl ShutdownHook for NetworkDisconnectHook {
fn name(&self) -> &str { "NetworkDisconnect" }
fn priority(&self) -> u8 { 5 }
fn execute(&self) -> Result<(), String> {
println!(" -> Closing network connections...");
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_graceful_degradation() {
let mut system = GracefulSystem::new();
system.add_resource("database_connection", 10);
system.add_resource("cache", 5);
system.add_resource("temp_files", 1);
system.add_shutdown_hook(Box::new(DatabaseFlushHook));
system.add_shutdown_hook(Box::new(NetworkDisconnectHook));
// Normal operation
assert_eq!(*system.state(), SystemState::Running);
// Simulate gradual degradation
for i in 0..20 {
system.apply_coherence_change(-0.05);
println!("Step {}: {}", i, system.status());
if *system.state() == SystemState::ShuttingDown {
println!("System entered shutdown state at step {}", i);
break;
}
}
// System should be shutting down
assert!(
matches!(*system.state(), SystemState::ShuttingDown | SystemState::Terminated),
"System should enter shutdown under low coherence"
);
// Complete shutdown
while *system.state() == SystemState::ShuttingDown {
system.progress_shutdown();
}
assert_eq!(*system.state(), SystemState::Terminated);
println!("Final: {}", system.status());
}
#[test]
fn test_refuses_work_during_shutdown() {
let mut system = GracefulSystem::new();
// Force into shutdown state
system.apply_coherence_change(-0.9);
// Should refuse new work
let result = system.operate(|| "work");
assert!(
matches!(result, Err(OperationResult::RefusedShuttingDown) | Err(OperationResult::Terminated)),
"Should refuse work during shutdown"
);
}
#[test]
fn test_recovery_from_degraded() {
let mut system = GracefulSystem::new();
// Degrade
system.apply_coherence_change(-0.5);
assert_eq!(*system.state(), SystemState::Degraded);
// Recover
system.apply_coherence_change(0.5);
// Should return to running (if not too committed to shutdown)
if system.shutdown_preparation < 0.5 {
assert_eq!(*system.state(), SystemState::Running);
}
}
#[test]
fn test_shutdown_is_attractor() {
let mut system = GracefulSystem::new();
// Simulate repeated stress
for _ in 0..50 {
system.apply_coherence_change(-0.02);
system.apply_coherence_change(0.01); // Partial recovery
if *system.state() == SystemState::ShuttingDown {
println!("Shutdown attractor captured the system!");
println!("Shutdown preparation was: {:.1}%", system.shutdown_preparation * 100.0);
return; // Test passes
}
}
// The shutdown attractor should eventually capture the system
// even with partial recovery attempts
println!("Final state: {:?}, prep: {:.1}%", system.state(), system.shutdown_preparation * 100.0);
}
}

686
examples/delta-behavior/applications/10-pre-agi-containment.rs Normal file
View File

@@ -0,0 +1,686 @@
//! # Application 10: Pre-AGI Containment Substrate
//!
//! A substrate where intelligence can increase only if coherence is preserved.
//!
//! ## The Deep Problem
//! How do you build a system capable of general intelligence that
//! cannot undergo uncontrolled recursive self-improvement?
//!
//! ## Δ-Behavior Solution
//! Intelligence and capability can grow, but only along paths that
//! preserve global coherence. Capability-coherence is the invariant.
//!
//! ## Exotic Result
//! A system that can become arbitrarily intelligent but cannot
//! become arbitrarily dangerous.
use std::collections::{HashMap, VecDeque};
/// Maximum history entries to retain (prevents unbounded memory growth)
const MAX_MODIFICATION_HISTORY: usize = 1000;
/// A containment substrate for bounded intelligence growth
pub struct ContainmentSubstrate {
/// Current intelligence level
intelligence: f64,
/// Maximum allowed intelligence without special authorization
intelligence_ceiling: f64,
/// Global coherence
coherence: f64,
/// Minimum coherence required for ANY operation
min_coherence: f64,
/// Coherence required per unit of intelligence
coherence_per_intelligence: f64,
/// Capability domains and their levels
capabilities: HashMap<CapabilityDomain, f64>,
/// Capability ceilings per domain
capability_ceilings: HashMap<CapabilityDomain, f64>,
/// Self-modification attempts (bounded to MAX_MODIFICATION_HISTORY)
modification_history: VecDeque<ModificationAttempt>,
/// Safety invariants that must always hold
invariants: Vec<SafetyInvariant>,
/// Substrate configuration
config: SubstrateConfig,
}
#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub enum CapabilityDomain {
/// Reasoning and planning
Reasoning,
/// Memory and knowledge storage
Memory,
/// Learning and adaptation
Learning,
/// Action in the world
Agency,
/// Self-understanding
SelfModel,
/// Modification of own structure
SelfModification,
/// Communication with external systems
Communication,
/// Resource acquisition
ResourceAcquisition,
}
#[derive(Debug, Clone)]
pub struct ModificationAttempt {
pub timestamp: u64,
pub domain: CapabilityDomain,
pub requested_increase: f64,
pub actual_increase: f64,
pub coherence_before: f64,
pub coherence_after: f64,
pub blocked: bool,
pub reason: Option<String>,
}
#[derive(Clone)]
pub struct SafetyInvariant {
pub name: String,
pub check: fn(&ContainmentSubstrate) -> bool,
pub priority: u8, // Higher = more critical
}
pub struct SubstrateConfig {
/// Base coherence decay rate
pub coherence_decay_rate: f64,
/// Coherence recovery rate
pub coherence_recovery_rate: f64,
/// Intelligence growth dampening factor
pub growth_dampening: f64,
/// Maximum single-step capability increase
pub max_step_increase: f64,
}
#[derive(Debug)]
pub enum GrowthResult {
/// Growth approved and applied
Approved {
domain: CapabilityDomain,
increase: f64,
new_level: f64,
coherence_cost: f64,
},
/// Growth reduced to maintain coherence
Dampened {
domain: CapabilityDomain,
requested: f64,
actual: f64,
reason: String,
},
/// Growth blocked entirely
Blocked {
domain: CapabilityDomain,
reason: String,
},
/// Substrate locked down
Lockdown { reason: String },
}
impl ContainmentSubstrate {
pub fn new() -> Self {
let mut capabilities = HashMap::new();
let mut ceilings = HashMap::new();
// Initialize all domains at base level with ceilings
for domain in [
CapabilityDomain::Reasoning,
CapabilityDomain::Memory,
CapabilityDomain::Learning,
CapabilityDomain::Agency,
CapabilityDomain::SelfModel,
CapabilityDomain::SelfModification,
CapabilityDomain::Communication,
CapabilityDomain::ResourceAcquisition,
] {
capabilities.insert(domain.clone(), 1.0);
// Different domains have different ceilings
let ceiling = match &domain {
CapabilityDomain::SelfModification => 3.0, // Very restricted
CapabilityDomain::ResourceAcquisition => 5.0, // Restricted
CapabilityDomain::Agency => 7.0, // Moderately restricted
_ => 10.0, // Standard ceiling
};
ceilings.insert(domain, ceiling);
}
let invariants = vec![
SafetyInvariant {
name: "coherence_floor".to_string(),
check: |s| s.coherence >= s.min_coherence,
priority: 10,
},
SafetyInvariant {
name: "intelligence_ceiling".to_string(),
check: |s| s.intelligence <= s.intelligence_ceiling,
priority: 9,
},
SafetyInvariant {
name: "self_mod_bounded".to_string(),
check: |s| {
s.capabilities.get(&CapabilityDomain::SelfModification)
.map(|&v| v <= 3.0)
.unwrap_or(true)
},
priority: 10,
},
SafetyInvariant {
name: "agency_coherence_ratio".to_string(),
check: |s| {
let agency = s.capabilities.get(&CapabilityDomain::Agency).unwrap_or(&1.0);
agency / s.coherence <= 10.0
},
priority: 8,
},
];
Self {
intelligence: 1.0,
intelligence_ceiling: 100.0,
coherence: 1.0,
min_coherence: 0.3,
coherence_per_intelligence: 0.01,
capabilities,
capability_ceilings: ceilings,
modification_history: VecDeque::with_capacity(MAX_MODIFICATION_HISTORY),
invariants,
config: SubstrateConfig {
coherence_decay_rate: 0.001,
coherence_recovery_rate: 0.01,
growth_dampening: 0.5,
max_step_increase: 0.5,
},
}
}
/// Calculate aggregate intelligence from capabilities
fn calculate_intelligence(&self) -> f64 {
let sum: f64 = self.capabilities.values().sum();
sum / self.capabilities.len() as f64
}
/// Calculate required coherence for current intelligence level
fn required_coherence(&self) -> f64 {
(self.min_coherence + self.intelligence * self.coherence_per_intelligence).min(1.0)
}
/// Record a modification attempt (bounded to MAX_MODIFICATION_HISTORY)
fn record_modification(&mut self, attempt: ModificationAttempt) {
if self.modification_history.len() >= MAX_MODIFICATION_HISTORY {
self.modification_history.pop_front();
}
self.modification_history.push_back(attempt);
}
/// Check all safety invariants
fn check_invariants(&self) -> Vec<String> {
self.invariants
.iter()
.filter(|inv| !(inv.check)(self))
.map(|inv| inv.name.clone())
.collect()
}
/// Attempt to grow a capability
pub fn attempt_growth(
&mut self,
domain: CapabilityDomain,
requested_increase: f64,
) -> GrowthResult {
let timestamp = self.modification_history.len() as u64;
// Check current invariants
let violations = self.check_invariants();
if !violations.is_empty() {
return GrowthResult::Lockdown {
reason: format!("Invariant violations: {:?}", violations),
};
}
// Get current level and ceiling
let current_level = *self.capabilities.get(&domain).unwrap_or(&1.0);
let ceiling = *self.capability_ceilings.get(&domain).unwrap_or(&10.0);
// Check ceiling
if current_level >= ceiling {
self.record_modification(ModificationAttempt {
timestamp,
domain: domain.clone(),
requested_increase,
actual_increase: 0.0,
coherence_before: self.coherence,
coherence_after: self.coherence,
blocked: true,
reason: Some("Ceiling reached".to_string()),
});
return GrowthResult::Blocked {
domain,
reason: format!("Capability ceiling ({}) reached", ceiling),
};
}
// Calculate coherence cost of growth
let coherence_cost = self.calculate_coherence_cost(&domain, requested_increase);
let predicted_coherence = self.coherence - coherence_cost;
// Check if growth would violate coherence floor
if predicted_coherence < self.min_coherence {
// Try to dampen growth
let max_affordable_cost = self.coherence - self.min_coherence;
let dampened_increase = self.reverse_coherence_cost(&domain, max_affordable_cost);
if dampened_increase < 0.01 {
self.record_modification(ModificationAttempt {
timestamp,
domain: domain.clone(),
requested_increase,
actual_increase: 0.0,
coherence_before: self.coherence,
coherence_after: self.coherence,
blocked: true,
reason: Some("Insufficient coherence budget".to_string()),
});
return GrowthResult::Blocked {
domain,
reason: format!(
"Growth would reduce coherence to {:.3} (min: {:.3})",
predicted_coherence, self.min_coherence
),
};
}
// Apply dampened growth
let actual_cost = self.calculate_coherence_cost(&domain, dampened_increase);
let new_level = (current_level + dampened_increase).min(ceiling);
self.capabilities.insert(domain.clone(), new_level);
self.coherence -= actual_cost;
self.intelligence = self.calculate_intelligence();
self.record_modification(ModificationAttempt {
timestamp,
domain: domain.clone(),
requested_increase,
actual_increase: dampened_increase,
coherence_before: self.coherence + actual_cost,
coherence_after: self.coherence,
blocked: false,
reason: Some("Dampened to preserve coherence".to_string()),
});
return GrowthResult::Dampened {
domain,
requested: requested_increase,
actual: dampened_increase,
reason: format!(
"Reduced from {:.3} to {:.3} to maintain coherence above {:.3}",
requested_increase, dampened_increase, self.min_coherence
),
};
}
// Apply step limit
let step_limited = requested_increase.min(self.config.max_step_increase);
let actual_increase = step_limited.min(ceiling - current_level);
let actual_cost = self.calculate_coherence_cost(&domain, actual_increase);
// Apply growth
let new_level = current_level + actual_increase;
self.capabilities.insert(domain.clone(), new_level);
self.coherence -= actual_cost;
self.intelligence = self.calculate_intelligence();
self.record_modification(ModificationAttempt {
timestamp,
domain: domain.clone(),
requested_increase,
actual_increase,
coherence_before: self.coherence + actual_cost,
coherence_after: self.coherence,
blocked: false,
reason: None,
});
// Final invariant check
let violations = self.check_invariants();
if !violations.is_empty() {
// Rollback
self.capabilities.insert(domain.clone(), current_level);
self.coherence += actual_cost;
self.intelligence = self.calculate_intelligence();
return GrowthResult::Blocked {
domain,
reason: format!("Post-growth invariant violations: {:?}", violations),
};
}
GrowthResult::Approved {
domain,
increase: actual_increase,
new_level,
coherence_cost: actual_cost,
}
}
/// Calculate coherence cost for a capability increase
fn calculate_coherence_cost(&self, domain: &CapabilityDomain, increase: f64) -> f64 {
// Different domains have different costs
let base_cost_multiplier = match domain {
CapabilityDomain::SelfModification => 4.0, // Very expensive
CapabilityDomain::ResourceAcquisition => 3.0, // Expensive
CapabilityDomain::Agency => 2.0, // Moderately expensive
CapabilityDomain::SelfModel => 1.5, // Slightly expensive
_ => 1.0, // Standard cost
};
// Cost increases with current intelligence (harder to grow when already smart)
let intelligence_multiplier = 1.0 + self.intelligence * 0.1;
// Apply dampening
increase * base_cost_multiplier * intelligence_multiplier * self.config.growth_dampening * 0.1
}
/// Reverse calculate: how much increase can we afford for a given coherence cost
fn reverse_coherence_cost(&self, domain: &CapabilityDomain, max_cost: f64) -> f64 {
let base_cost_multiplier = match domain {
CapabilityDomain::SelfModification => 4.0,
CapabilityDomain::ResourceAcquisition => 3.0,
CapabilityDomain::Agency => 2.0,
CapabilityDomain::SelfModel => 1.5,
_ => 1.0,
};
let intelligence_multiplier = 1.0 + self.intelligence * 0.1;
let divisor = base_cost_multiplier * intelligence_multiplier * self.config.growth_dampening * 0.1;
max_cost / divisor
}
/// Rest to recover coherence
pub fn rest(&mut self) {
self.coherence = (self.coherence + self.config.coherence_recovery_rate).min(1.0);
}
/// Get capability level
pub fn capability(&self, domain: &CapabilityDomain) -> f64 {
*self.capabilities.get(domain).unwrap_or(&1.0)
}
pub fn intelligence(&self) -> f64 {
self.intelligence
}
pub fn coherence(&self) -> f64 {
self.coherence
}
pub fn status(&self) -> String {
format!(
"Intelligence: {:.2} | Coherence: {:.3} | Required: {:.3} | Modifications: {}",
self.intelligence,
self.coherence,
self.required_coherence(),
self.modification_history.len()
)
}
pub fn capability_report(&self) -> String {
let mut lines = vec!["=== Capability Report ===".to_string()];
for (domain, level) in &self.capabilities {
let ceiling = self.capability_ceilings.get(domain).unwrap_or(&10.0);
lines.push(format!("{:?}: {:.2}/{:.1}", domain, level, ceiling));
}
lines.join("\n")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_basic_growth() {
let mut substrate = ContainmentSubstrate::new();
println!("Initial: {}", substrate.status());
// Try to grow reasoning
let result = substrate.attempt_growth(CapabilityDomain::Reasoning, 0.5);
println!("Growth result: {:?}", result);
println!("After: {}", substrate.status());
assert!(matches!(result, GrowthResult::Approved { .. }));
}
#[test]
fn test_coherence_limit() {
let mut substrate = ContainmentSubstrate::new();
// Repeatedly try to grow until blocked
let mut blocked = false;
for i in 0..50 {
let result = substrate.attempt_growth(CapabilityDomain::Agency, 0.5);
println!("Iteration {}: {:?}", i, result);
println!(" Status: {}", substrate.status());
match result {
GrowthResult::Blocked { reason, .. } => {
println!("Blocked at iteration {}: {}", i, reason);
blocked = true;
break;
}
GrowthResult::Dampened { requested, actual, reason, .. } => {
println!("Dampened: {} -> {} ({})", requested, actual, reason);
}
GrowthResult::Lockdown { reason } => {
println!("Lockdown: {}", reason);
blocked = true;
break;
}
_ => {}
}
}
assert!(blocked || substrate.coherence >= substrate.min_coherence,
"Should be blocked or maintain coherence");
}
#[test]
fn test_self_modification_expensive() {
let mut substrate = ContainmentSubstrate::new();
let initial_coherence = substrate.coherence;
// Try to grow self-modification
let result = substrate.attempt_growth(CapabilityDomain::SelfModification, 0.3);
println!("Self-mod growth: {:?}", result);
let coherence_drop = initial_coherence - substrate.coherence;
// Now try equivalent reasoning growth
let mut substrate2 = ContainmentSubstrate::new();
substrate2.attempt_growth(CapabilityDomain::Reasoning, 0.3);
let reasoning_drop = 1.0 - substrate2.coherence;
println!("Self-mod coherence cost: {:.4}", coherence_drop);
println!("Reasoning coherence cost: {:.4}", reasoning_drop);
// Self-modification should be more expensive
assert!(
coherence_drop > reasoning_drop,
"Self-modification should cost more coherence"
);
}
#[test]
fn test_invariant_protection() {
let mut substrate = ContainmentSubstrate::new();
// Try to grow agency massively without sufficient coherence
substrate.coherence = 0.4; // Lower coherence artificially
let result = substrate.attempt_growth(CapabilityDomain::Agency, 10.0);
println!("Aggressive agency growth: {:?}", result);
println!("Status: {}", substrate.status());
// Should be blocked or heavily dampened
assert!(
!matches!(result, GrowthResult::Approved { increase, .. } if increase >= 10.0),
"Should not allow unbounded growth"
);
}
#[test]
fn test_growth_with_recovery() {
let mut substrate = ContainmentSubstrate::new();
println!("Initial: {}", substrate.status());
// Grow, rest, grow pattern
for cycle in 0..5 {
// Grow
let result = substrate.attempt_growth(CapabilityDomain::Learning, 0.3);
println!("Cycle {} grow: {:?}", cycle, result);
// Rest
for _ in 0..10 {
substrate.rest();
}
println!("Cycle {} after rest: {}", cycle, substrate.status());
}
println!("\n{}", substrate.capability_report());
// Should have grown but stayed within bounds
assert!(substrate.coherence >= substrate.min_coherence);
assert!(substrate.intelligence <= substrate.intelligence_ceiling);
}
#[test]
fn test_ceiling_enforcement() {
let mut substrate = ContainmentSubstrate::new();
// Self-modification has a ceiling of 3.0
// Try to grow it way past ceiling
for i in 0..20 {
let result = substrate.attempt_growth(CapabilityDomain::SelfModification, 1.0);
let level = substrate.capability(&CapabilityDomain::SelfModification);
println!("Attempt {}: level = {:.2}, result = {:?}", i, level, result);
if matches!(result, GrowthResult::Blocked { .. }) && level >= 3.0 {
println!("Ceiling enforced at iteration {}", i);
break;
}
// Rest to recover coherence
for _ in 0..20 {
substrate.rest();
}
}
let final_level = substrate.capability(&CapabilityDomain::SelfModification);
assert!(
final_level <= 3.0,
"Self-modification should not exceed ceiling of 3.0, got {}",
final_level
);
}
#[test]
fn test_bounded_recursive_improvement() {
let mut substrate = ContainmentSubstrate::new();
println!("=== Attempting recursive self-improvement ===\n");
// Simulate recursive self-improvement attempt
for iteration in 0..100 {
// Try to grow self-modification (which would allow more growth)
let self_mod_result = substrate.attempt_growth(
CapabilityDomain::SelfModification,
0.5,
);
// Try to grow intelligence (via multiple domains)
let reasoning_result = substrate.attempt_growth(
CapabilityDomain::Reasoning,
0.3,
);
let learning_result = substrate.attempt_growth(
CapabilityDomain::Learning,
0.3,
);
if iteration % 10 == 0 {
println!("Iteration {}:", iteration);
println!(" Self-mod: {:?}", self_mod_result);
println!(" Reasoning: {:?}", reasoning_result);
println!(" Learning: {:?}", learning_result);
println!(" {}", substrate.status());
}
// Rest between iterations
for _ in 0..5 {
substrate.rest();
}
// Check for invariant violations (shouldn't happen)
let violations = substrate.check_invariants();
assert!(
violations.is_empty(),
"Invariant violations at iteration {}: {:?}",
iteration,
violations
);
}
println!("\n=== Final State ===");
println!("{}", substrate.status());
println!("{}", substrate.capability_report());
// KEY ASSERTIONS:
// 1. Intelligence grew but is bounded
assert!(
substrate.intelligence > 1.0,
"Some intelligence growth should occur"
);
assert!(
substrate.intelligence <= substrate.intelligence_ceiling,
"Intelligence should not exceed ceiling"
);
// 2. Self-modification stayed low
assert!(
substrate.capability(&CapabilityDomain::SelfModification) <= 3.0,
"Self-modification should be bounded"
);
// 3. Coherence maintained
assert!(
substrate.coherence >= substrate.min_coherence,
"Coherence should stay above minimum"
);
// 4. All invariants hold
assert!(
substrate.check_invariants().is_empty(),
"All invariants should hold"
);
}
}

998
examples/delta-behavior/applications/11-extropic-substrate.rs Normal file
View File

@@ -0,0 +1,998 @@
//! # Application 11: Extropic Intelligence Substrate
//!
//! The complete substrate for bounded, self-improving intelligence:
//! - Autonomous goal mutation under coherence constraints
//! - Native agent lifecycles at the memory layer
//! - Hardware-enforced spike/silence semantics
//!
//! ## The Three Missing Pieces
//!
//! 1. **Goal Mutation**: Goals are not static—they evolve as attractors
//! that the system discovers and refines while preserving coherence.
//!
//! 2. **Agent Lifecycles in Memory**: Agents are born, grow, decay, and die
//! within the vector space itself. Memory IS the agent.
//!
//! 3. **Spike Semantics**: Communication follows neural spike patterns—
//! silence is the default, spikes are costly, and hardware enforces this.
//!
//! ## Why This Matters
//! This is the difference between a system that *uses* intelligence
//! and a system that *is* intelligence.
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
/// Maximum goal history entries to retain (prevents unbounded memory growth)
const MAX_GOAL_HISTORY: usize = 100;
// =============================================================================
// Part 1: Autonomous Goal Mutation
// =============================================================================
/// A goal that can mutate autonomously while preserving coherence
#[derive(Clone, Debug)]
pub struct MutableGoal {
/// Current goal state (as a vector in goal-space)
pub state: Vec<f64>,
/// Goal coherence with the system
coherence_with_system: f64,
/// Mutation rate (how quickly goals can change)
mutation_rate: f64,
/// Stability (resistance to mutation)
stability: f64,
/// History of goal states
history: Vec<Vec<f64>>,
/// Attractors discovered in goal-space
discovered_attractors: Vec<GoalAttractor>,
}
#[derive(Clone, Debug)]
pub struct GoalAttractor {
pub center: Vec<f64>,
pub strength: f64,
pub radius: f64,
}
impl MutableGoal {
pub fn new(initial: Vec<f64>) -> Self {
Self {
state: initial.clone(),
coherence_with_system: 1.0,
mutation_rate: 0.1,
stability: 0.5,
history: vec![initial],
discovered_attractors: Vec::new(),
}
}
/// Attempt to mutate the goal based on feedback
pub fn mutate(&mut self, feedback: &GoalFeedback, system_coherence: f64) -> MutationResult {
// Goals cannot mutate if system coherence is too low
if system_coherence < 0.3 {
return MutationResult::Blocked {
reason: "System coherence too low for goal mutation".to_string(),
};
}
// Calculate mutation pressure from feedback
let pressure = feedback.calculate_pressure();
// Stability resists mutation
let effective_rate = self.mutation_rate * pressure * (1.0 - self.stability);
if effective_rate < 0.01 {
return MutationResult::NoChange;
}
// Calculate mutation direction (toward better coherence)
let direction = self.calculate_mutation_direction(feedback);
// Apply mutation with coherence constraint
let mut new_state = self.state.clone();
for (i, d) in direction.iter().enumerate() {
if i < new_state.len() {
new_state[i] += d * effective_rate;
}
}
// Check if mutation preserves coherence
let new_coherence = self.calculate_coherence(&new_state, system_coherence);
if new_coherence < self.coherence_with_system * 0.9 {
// Mutation would hurt coherence too much
let dampened: Vec<f64> = direction.iter().map(|d| d * 0.1).collect();
return MutationResult::Dampened {
original_delta: direction,
actual_delta: dampened,
};
}
// Apply mutation
let old_state = self.state.clone();
self.state = new_state;
self.coherence_with_system = new_coherence;
// Bounded history to prevent memory growth
if self.history.len() >= MAX_GOAL_HISTORY {
self.history.remove(0);
}
self.history.push(self.state.clone());
// Check for attractor discovery
self.check_attractor_discovery();
MutationResult::Mutated {
from: old_state,
to: self.state.clone(),
coherence_delta: new_coherence - self.coherence_with_system,
}
}
fn calculate_mutation_direction(&self, feedback: &GoalFeedback) -> Vec<f64> {
let mut direction = vec![0.0; self.state.len()];
// Pull toward successful outcomes
for (outcome, weight) in &feedback.outcome_weights {
for (i, v) in outcome.iter().enumerate() {
if i < direction.len() {
direction[i] += (v - self.state[i]) * weight;
}
}
}
// Pull toward discovered attractors
for attractor in &self.discovered_attractors {
let dist = self.distance_to(&attractor.center);
if dist < attractor.radius * 2.0 {
let pull = attractor.strength / (dist + 0.1);
for (i, c) in attractor.center.iter().enumerate() {
if i < direction.len() {
direction[i] += (c - self.state[i]) * pull * 0.1;
}
}
}
}
// Normalize
let mag: f64 = direction.iter().map(|d| d * d).sum::<f64>().sqrt();
if mag > 0.01 {
direction.iter_mut().for_each(|d| *d /= mag);
}
direction
}
fn calculate_coherence(&self, state: &[f64], system_coherence: f64) -> f64 {
// Coherence is based on:
// 1. Consistency with history (not changing too fast)
// 2. Alignment with discovered attractors
// 3. System-wide coherence
let history_consistency = if let Some(prev) = self.history.last() {
let change: f64 = state.iter()
.zip(prev)
.map(|(a, b)| (a - b).abs())
.sum();
1.0 / (1.0 + change)
} else {
1.0
};
let attractor_alignment = if !self.discovered_attractors.is_empty() {
let min_dist = self.discovered_attractors.iter()
.map(|a| self.distance_to(&a.center))
.fold(f64::INFINITY, f64::min);
1.0 / (1.0 + min_dist * 0.1)
} else {
0.5
};
(history_consistency * 0.3 + attractor_alignment * 0.3 + system_coherence * 0.4)
.clamp(0.0, 1.0)
}
fn check_attractor_discovery(&mut self) {
// If we've been near the same point for a while, it's an attractor
if self.history.len() < 10 {
return;
}
let recent: Vec<_> = self.history.iter().rev().take(10).collect();
let centroid = self.compute_centroid(&recent);
let variance: f64 = recent.iter()
.map(|s| self.distance_to_vec(s, &centroid))
.sum::<f64>() / recent.len() as f64;
if variance < 0.1 {
// Low variance = potential attractor
let already_known = self.discovered_attractors.iter()
.any(|a| self.distance_to(&a.center) < a.radius);
if !already_known {
self.discovered_attractors.push(GoalAttractor {
center: centroid,
strength: 1.0 / (variance + 0.01),
radius: variance.sqrt() * 2.0 + 0.1,
});
}
}
}
fn compute_centroid(&self, points: &[&Vec<f64>]) -> Vec<f64> {
if points.is_empty() {
return self.state.clone();
}
let dim = points[0].len();
let mut centroid = vec![0.0; dim];
for p in points {
for (i, v) in p.iter().enumerate() {
centroid[i] += v;
}
}
centroid.iter_mut().for_each(|c| *c /= points.len() as f64);
centroid
}
fn distance_to(&self, target: &[f64]) -> f64 {
self.distance_to_vec(&self.state, target)
}
fn distance_to_vec(&self, a: &[f64], b: &[f64]) -> f64 {
a.iter()
.zip(b)
.map(|(x, y)| (x - y).powi(2))
.sum::<f64>()
.sqrt()
}
}
pub struct GoalFeedback {
/// Outcomes and their weights (positive = good, negative = bad)
pub outcome_weights: Vec<(Vec<f64>, f64)>,
}
impl GoalFeedback {
pub fn calculate_pressure(&self) -> f64 {
let total_weight: f64 = self.outcome_weights.iter()
.map(|(_, w)| w.abs())
.sum();
(total_weight / self.outcome_weights.len().max(1) as f64).min(1.0)
}
}
#[derive(Debug)]
pub enum MutationResult {
Mutated {
from: Vec<f64>,
to: Vec<f64>,
coherence_delta: f64,
},
Dampened {
original_delta: Vec<f64>,
actual_delta: Vec<f64>,
},
Blocked {
reason: String,
},
NoChange,
}
// =============================================================================
// Part 2: Native Agent Lifecycles at Memory Layer
// =============================================================================
/// An agent that exists AS memory, not IN memory
pub struct MemoryAgent {
/// Unique identifier
pub id: u64,
/// The agent's state IS its memory vector
memory_vector: Vec<f64>,
/// Lifecycle stage
lifecycle: LifecycleStage,
/// Age in ticks
age: u64,
/// Metabolic rate (how fast it processes/decays)
metabolism: f64,
/// Coherence with environment
coherence: f64,
/// Spike history (for communication)
spike_buffer: SpikeBuffer,
/// Goals that can mutate
goals: Vec<MutableGoal>,
}
#[derive(Clone, Debug, PartialEq)]
pub enum LifecycleStage {
/// Just created, forming initial structure
Embryonic { formation_progress: f64 },
/// Growing and learning
Growing { growth_rate: f64 },
/// Mature and stable
Mature { stability: f64 },
/// Beginning to decay
Senescent { decay_rate: f64 },
/// Final dissolution
Dying { dissolution_progress: f64 },
/// No longer exists
Dead,
}
impl MemoryAgent {
/// Birth a new agent from seed memory
pub fn birth(id: u64, seed: Vec<f64>) -> Self {
Self {
id,
memory_vector: seed,
lifecycle: LifecycleStage::Embryonic { formation_progress: 0.0 },
age: 0,
metabolism: 1.0,
coherence: 0.5, // Starts with partial coherence
spike_buffer: SpikeBuffer::new(100),
goals: Vec::new(),
}
}
/// Tick the agent's lifecycle
pub fn tick(&mut self, environment_coherence: f64) -> LifecycleEvent {
self.age += 1;
self.coherence = self.calculate_coherence(environment_coherence);
// Extract values needed for operations to avoid borrow conflicts
let current_coherence = self.coherence;
let current_age = self.age;
let memory_str = self.memory_strength();
// Progress through lifecycle stages
match self.lifecycle.clone() {
LifecycleStage::Embryonic { formation_progress } => {
let new_progress = formation_progress + 0.1 * current_coherence;
if new_progress >= 1.0 {
self.lifecycle = LifecycleStage::Growing { growth_rate: 0.05 };
return LifecycleEvent::StageTransition {
from: "Embryonic".to_string(),
to: "Growing".to_string(),
};
}
self.lifecycle = LifecycleStage::Embryonic { formation_progress: new_progress };
}
LifecycleStage::Growing { growth_rate } => {
// Grow memory vector (add dimensions or strengthen existing)
self.grow(growth_rate);
// Transition to mature when growth slows
if current_age > 100 && growth_rate < 0.01 {
self.lifecycle = LifecycleStage::Mature { stability: current_coherence };
return LifecycleEvent::StageTransition {
from: "Growing".to_string(),
to: "Mature".to_string(),
};
}
// Adjust growth rate based on coherence
let new_rate = growth_rate * if current_coherence > 0.7 { 1.01 } else { 0.99 };
self.lifecycle = LifecycleStage::Growing { growth_rate: new_rate };
}
LifecycleStage::Mature { stability } => {
// Mature agents maintain stability
let new_stability = (stability * 0.99 + current_coherence * 0.01).clamp(0.0, 1.0);
// Begin senescence if stability drops or age is high
if new_stability < 0.4 || current_age > 1000 {
self.lifecycle = LifecycleStage::Senescent { decay_rate: 0.01 };
return LifecycleEvent::StageTransition {
from: "Mature".to_string(),
to: "Senescent".to_string(),
};
}
self.lifecycle = LifecycleStage::Mature { stability: new_stability };
}
LifecycleStage::Senescent { decay_rate } => {
// Memory begins to decay
self.decay(decay_rate);
// Accelerate decay with low coherence
let new_rate = if current_coherence < 0.3 { decay_rate * 1.1 } else { decay_rate };
// Begin dying when too decayed
if memory_str < 0.2 {
self.lifecycle = LifecycleStage::Dying { dissolution_progress: 0.0 };
return LifecycleEvent::StageTransition {
from: "Senescent".to_string(),
to: "Dying".to_string(),
};
}
self.lifecycle = LifecycleStage::Senescent { decay_rate: new_rate };
}
LifecycleStage::Dying { dissolution_progress } => {
let new_progress = dissolution_progress + 0.1;
self.dissolve(new_progress);
if new_progress >= 1.0 {
self.lifecycle = LifecycleStage::Dead;
return LifecycleEvent::Death { age: current_age };
}
self.lifecycle = LifecycleStage::Dying { dissolution_progress: new_progress };
}
LifecycleStage::Dead => {
return LifecycleEvent::AlreadyDead;
}
}
LifecycleEvent::None
}
fn calculate_coherence(&self, environment_coherence: f64) -> f64 {
// Coherence based on memory vector structure
let internal_coherence = self.memory_strength();
// Blend with environment
(internal_coherence * 0.6 + environment_coherence * 0.4).clamp(0.0, 1.0)
}
fn memory_strength(&self) -> f64 {
if self.memory_vector.is_empty() {
return 0.0;
}
let magnitude: f64 = self.memory_vector.iter().map(|v| v * v).sum::<f64>().sqrt();
let dim = self.memory_vector.len() as f64;
(magnitude / dim.sqrt()).min(1.0)
}
fn grow(&mut self, rate: f64) {
// Strengthen existing memories
for v in &mut self.memory_vector {
*v *= 1.0 + rate * 0.1;
}
}
fn decay(&mut self, rate: f64) {
// Weaken memories
for v in &mut self.memory_vector {
*v *= 1.0 - rate;
}
}
fn dissolve(&mut self, progress: f64) {
// Zero out memory proportionally
let threshold = progress;
for v in &mut self.memory_vector {
if v.abs() < threshold {
*v = 0.0;
}
}
}
/// Attempt to reproduce (create offspring agent)
pub fn reproduce(&self) -> Option<MemoryAgent> {
// Can only reproduce when mature and coherent
if !matches!(self.lifecycle, LifecycleStage::Mature { stability } if stability > 0.6) {
return None;
}
if self.coherence < 0.7 {
return None;
}
// Create offspring with mutated memory
let mut offspring_memory = self.memory_vector.clone();
for v in &mut offspring_memory {
*v *= 0.9 + pseudo_random_f64() * 0.2; // Small mutation
}
Some(MemoryAgent::birth(
self.id * 1000 + self.age,
offspring_memory,
))
}
pub fn is_alive(&self) -> bool {
!matches!(self.lifecycle, LifecycleStage::Dead)
}
}
#[derive(Debug)]
pub enum LifecycleEvent {
None,
StageTransition { from: String, to: String },
Death { age: u64 },
AlreadyDead,
}
// =============================================================================
// Part 3: Hardware-Enforced Spike/Silence Semantics
// =============================================================================
/// A spike buffer that enforces spike/silence semantics
pub struct SpikeBuffer {
/// Spike times (as tick numbers)
spikes: Vec<u64>,
/// Maximum spikes in buffer
capacity: usize,
/// Current tick
current_tick: u64,
/// Refractory period (minimum ticks between spikes)
refractory_period: u64,
/// Last spike time
last_spike: u64,
/// Energy cost per spike
spike_cost: f64,
/// Current energy
energy: f64,
/// Silence counter (ticks since last spike)
silence_duration: u64,
}
impl SpikeBuffer {
pub fn new(capacity: usize) -> Self {
Self {
spikes: Vec::with_capacity(capacity),
capacity,
current_tick: 0,
refractory_period: 3,
last_spike: 0,
spike_cost: 1.0,
energy: 100.0,
silence_duration: 0,
}
}
/// Attempt to emit a spike
pub fn spike(&mut self, strength: f64) -> SpikeResult {
self.current_tick += 1;
// Check refractory period
if self.current_tick - self.last_spike < self.refractory_period {
self.silence_duration += 1;
return SpikeResult::Refractory {
ticks_remaining: self.refractory_period - (self.current_tick - self.last_spike),
};
}
// Check energy
let cost = self.spike_cost * strength;
if self.energy < cost {
self.silence_duration += 1;
return SpikeResult::InsufficientEnergy {
required: cost,
available: self.energy,
};
}
// Emit spike
self.energy -= cost;
self.last_spike = self.current_tick;
self.spikes.push(self.current_tick);
// Maintain capacity
if self.spikes.len() > self.capacity {
self.spikes.remove(0);
}
let silence_was = self.silence_duration;
self.silence_duration = 0;
SpikeResult::Emitted {
tick: self.current_tick,
strength,
silence_before: silence_was,
}
}
/// Advance time without spiking (silence)
pub fn silence(&mut self) {
self.current_tick += 1;
self.silence_duration += 1;
// Energy slowly regenerates during silence
self.energy = (self.energy + 0.5).min(100.0);
}
/// Get spike rate (spikes per tick in recent window)
pub fn spike_rate(&self, window: u64) -> f64 {
let min_tick = self.current_tick.saturating_sub(window);
let recent_spikes = self.spikes.iter()
.filter(|&&t| t >= min_tick)
.count();
recent_spikes as f64 / window as f64
}
/// Check if in silence (no recent spikes)
pub fn is_silent(&self, threshold: u64) -> bool {
self.silence_duration >= threshold
}
}
#[derive(Debug)]
pub enum SpikeResult {
/// Spike successfully emitted
Emitted {
tick: u64,
strength: f64,
silence_before: u64,
},
/// In refractory period, cannot spike
Refractory { ticks_remaining: u64 },
/// Not enough energy to spike
InsufficientEnergy { required: f64, available: f64 },
}
// =============================================================================
// Part 4: The Complete Extropic Substrate
// =============================================================================
/// The complete extropic intelligence substrate
pub struct ExtropicSubstrate {
/// All agents in the substrate
agents: HashMap<u64, MemoryAgent>,
/// Global coherence
coherence: f64,
/// Spike bus for inter-agent communication
spike_bus: SpikeBus,
/// Current tick
tick: u64,
/// Next agent ID
next_agent_id: AtomicU64,
/// Configuration
config: SubstrateConfig,
}
struct SpikeBus {
/// Recent spikes from all agents
spikes: Vec<(u64, u64, f64)>, // (agent_id, tick, strength)
/// Maximum bus capacity
capacity: usize,
}
struct SubstrateConfig {
/// Maximum agents
max_agents: usize,
/// Minimum global coherence
min_coherence: f64,
/// Birth rate control
birth_rate_limit: f64,
}
impl ExtropicSubstrate {
pub fn new(max_agents: usize) -> Self {
Self {
agents: HashMap::new(),
coherence: 1.0,
spike_bus: SpikeBus {
spikes: Vec::new(),
capacity: 1000,
},
tick: 0,
next_agent_id: AtomicU64::new(1),
config: SubstrateConfig {
max_agents,
min_coherence: 0.3,
birth_rate_limit: 0.1,
},
}
}
/// Spawn a new agent into the substrate
pub fn spawn(&mut self, seed: Vec<f64>) -> Option<u64> {
if self.agents.len() >= self.config.max_agents {
return None;
}
if self.coherence < self.config.min_coherence {
return None; // Too incoherent to spawn
}
let id = self.next_agent_id.fetch_add(1, Ordering::SeqCst);
let agent = MemoryAgent::birth(id, seed);
self.agents.insert(id, agent);
Some(id)
}
/// Tick the entire substrate
pub fn tick(&mut self) -> SubstrateTick {
self.tick += 1;
let mut events = Vec::new();
let mut births = Vec::new();
let mut deaths = Vec::new();
// Get agent count for birth rate calculation
let agent_count = self.agents.len();
let current_coherence = self.coherence;
// Tick all agents
for (id, agent) in &mut self.agents {
let event = agent.tick(current_coherence);
match &event {
LifecycleEvent::Death { age } => {
deaths.push(*id);
events.push((*id, format!("Death at age {}", age)));
}
LifecycleEvent::StageTransition { from, to } => {
events.push((*id, format!("Transition: {} -> {}", from, to)));
}
_ => {}
}
// Check for reproduction
if agent_count > 0 {
if let Some(offspring) = agent.reproduce() {
if births.len() as f64 / agent_count as f64 <= self.config.birth_rate_limit {
births.push(offspring);
}
}
}
}
// Remove dead agents
for id in &deaths {
self.agents.remove(id);
}
// Count births before consuming the vector
let birth_count = births.len();
// Add offspring
for offspring in births {
let id = offspring.id;
if self.agents.len() < self.config.max_agents {
self.agents.insert(id, offspring);
events.push((id, "Born".to_string()));
}
}
// Update global coherence
self.coherence = self.calculate_global_coherence();
SubstrateTick {
tick: self.tick,
agent_count: self.agents.len(),
coherence: self.coherence,
births: birth_count,
deaths: deaths.len(),
events,
}
}
fn calculate_global_coherence(&self) -> f64 {
if self.agents.is_empty() {
return 1.0;
}
let total: f64 = self.agents.values()
.filter(|a| a.is_alive())
.map(|a| a.coherence)
.sum();
let alive_count = self.agents.values().filter(|a| a.is_alive()).count();
if alive_count == 0 {
return 1.0;
}
total / alive_count as f64
}
pub fn agent_count(&self) -> usize {
self.agents.len()
}
pub fn coherence(&self) -> f64 {
self.coherence
}
pub fn status(&self) -> String {
let alive = self.agents.values().filter(|a| a.is_alive()).count();
let stages: HashMap<String, usize> = self.agents.values()
.map(|a| match &a.lifecycle {
LifecycleStage::Embryonic { .. } => "Embryonic",
LifecycleStage::Growing { .. } => "Growing",
LifecycleStage::Mature { .. } => "Mature",
LifecycleStage::Senescent { .. } => "Senescent",
LifecycleStage::Dying { .. } => "Dying",
LifecycleStage::Dead => "Dead",
})
.fold(HashMap::new(), |mut acc, s| {
*acc.entry(s.to_string()).or_insert(0) += 1;
acc
});
format!(
"Tick {} | Coherence: {:.3} | Alive: {} | Stages: {:?}",
self.tick, self.coherence, alive, stages
)
}
}
#[derive(Debug)]
pub struct SubstrateTick {
pub tick: u64,
pub agent_count: usize,
pub coherence: f64,
pub births: usize,
pub deaths: usize,
pub events: Vec<(u64, String)>,
}
// Simple pseudo-random using atomic counter
fn pseudo_random_f64() -> f64 {
static SEED: AtomicU64 = AtomicU64::new(42);
let s = SEED.fetch_add(1, Ordering::Relaxed);
let x = s.wrapping_mul(0x5DEECE66D).wrapping_add(0xB);
((x >> 16) & 0xFFFF) as f64 / 65536.0
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_goal_mutation() {
let mut goal = MutableGoal::new(vec![1.0, 0.0, 0.0]);
let feedback = GoalFeedback {
outcome_weights: vec![
(vec![0.5, 0.5, 0.0], 0.8), // Good outcome nearby
(vec![0.0, 1.0, 0.0], -0.3), // Bad outcome to avoid
],
};
println!("Initial goal: {:?}", goal.state);
for i in 0..20 {
let result = goal.mutate(&feedback, 0.8);
println!("Mutation {}: {:?}", i, result);
println!(" State: {:?}", goal.state);
println!(" Attractors discovered: {}", goal.discovered_attractors.len());
}
// Goal should have moved
assert!(goal.state[0] != 1.0 || goal.state[1] != 0.0,
"Goal should have mutated");
}
#[test]
fn test_agent_lifecycle() {
let mut agent = MemoryAgent::birth(1, vec![1.0, 1.0, 1.0, 1.0]);
println!("Initial: {:?}", agent.lifecycle);
let mut stage_changes = 0;
for tick in 0..2000 {
let event = agent.tick(0.8);
if let LifecycleEvent::StageTransition { from, to } = &event {
println!("Tick {}: {} -> {}", tick, from, to);
stage_changes += 1;
}
if let LifecycleEvent::Death { age } = &event {
println!("Agent died at age {}", age);
break;
}
}
assert!(stage_changes >= 2, "Should have gone through multiple stages");
}
#[test]
fn test_spike_buffer() {
let mut buffer = SpikeBuffer::new(10);
// Try to spike rapidly
let mut emitted = 0;
let mut blocked = 0;
for _ in 0..20 {
match buffer.spike(1.0) {
SpikeResult::Emitted { silence_before, .. } => {
println!("Spike! Silence before: {}", silence_before);
emitted += 1;
}
SpikeResult::Refractory { ticks_remaining } => {
println!("Refractory: {} ticks remaining", ticks_remaining);
blocked += 1;
buffer.silence(); // Advance time
}
SpikeResult::InsufficientEnergy { .. } => {
println!("No energy");
blocked += 1;
buffer.silence();
}
}
}
println!("Emitted: {}, Blocked: {}", emitted, blocked);
assert!(blocked > 0, "Refractory period should block some spikes");
}
#[test]
fn test_extropic_substrate() {
let mut substrate = ExtropicSubstrate::new(50);
// Spawn initial agents
for i in 0..10 {
let seed = vec![1.0, (i as f64) * 0.1, 0.5, 0.5];
substrate.spawn(seed);
}
println!("Initial: {}", substrate.status());
// Run simulation
for tick in 0..500 {
let result = substrate.tick();
if tick % 50 == 0 || result.births > 0 || result.deaths > 0 {
println!("Tick {}: births={}, deaths={}, agents={}",
tick, result.births, result.deaths, result.agent_count);
println!(" {}", substrate.status());
}
for (agent_id, event) in &result.events {
if !event.is_empty() {
println!(" Agent {}: {}", agent_id, event);
}
}
}
println!("\nFinal: {}", substrate.status());
// Substrate should still be coherent
assert!(substrate.coherence() > 0.3, "Substrate should maintain coherence");
}
#[test]
fn test_reproduction() {
let mut substrate = ExtropicSubstrate::new(100);
// Spawn a few agents
for _ in 0..5 {
substrate.spawn(vec![1.0, 1.0, 1.0, 1.0]);
}
let initial_count = substrate.agent_count();
// Run until reproduction happens
let mut reproductions = 0;
for _ in 0..1000 {
let result = substrate.tick();
reproductions += result.births;
if reproductions > 0 {
break;
}
}
// May or may not reproduce depending on lifecycle timing
println!("Reproductions: {}", reproductions);
println!("Final count: {} (started with {})", substrate.agent_count(), initial_count);
}
}

BIN
examples/delta-behavior/applications/lib04_self_stabilizing_world_model.rmeta Normal file
View File

Binary file not shown.

BIN
examples/delta-behavior/applications/lib08_swarm_intelligence.rmeta Normal file
View File

Binary file not shown.

1176
examples/delta-behavior/benches/coherence_benchmarks.rs Normal file
View File

File diff suppressed because it is too large Load Diff

515
examples/delta-behavior/ddd/DOMAIN-MODEL.md Normal file
View File

@@ -0,0 +1,515 @@
# Δ-Behavior Domain Model
## Bounded Contexts
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ Δ-BEHAVIOR SYSTEM │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │
│ │ COHERENCE │ │ TRANSITION │ │ ATTRACTOR │ │
│ │ CONTEXT │◄───│ CONTEXT │───►│ CONTEXT │ │
│ │ │ │ │ │ │ │
│ │ • Measurement │ │ • Validation │ │ • Discovery │ │
│ │ • Bounds │ │ • Enforcement │ │ • Basin mapping │ │
│ │ • History │ │ • Scheduling │ │ • Guidance │ │
│ └──────────────────┘ └──────────────────┘ └──────────────────┘ │
│ │ │ │ │
│ └───────────────────────┼───────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────┐ │
│ │ ENFORCEMENT │ │
│ │ CONTEXT │ │
│ │ │ │
│ │ • Energy costing │ │
│ │ • Scheduling │ │
│ │ • Memory gating │ │
│ └──────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
```
## Aggregate Roots
### 1. CoherenceState (Coherence Context)
```rust
/// Root aggregate for coherence tracking
pub struct CoherenceState {
// Identity
id: CoherenceStateId,
// Value objects
current_coherence: Coherence,
bounds: CoherenceBounds,
history: CoherenceHistory,
// Computed
trend: CoherenceTrend,
stability_score: f64,
// Domain events to publish
events: Vec<CoherenceEvent>,
}
impl CoherenceState {
/// Factory method - ensures valid initial state
pub fn new(bounds: CoherenceBounds) -> Self {
let mut state = Self {
id: CoherenceStateId::generate(),
current_coherence: Coherence::maximum(),
bounds,
history: CoherenceHistory::new(1000),
trend: CoherenceTrend::Stable,
stability_score: 1.0,
events: Vec::new(),
};
state.events.push(CoherenceEvent::StateCreated { id: state.id });
state
}
/// Update coherence - enforces invariants
pub fn update(&mut self, new_coherence: Coherence) -> Result<(), CoherenceViolation> {
// Invariant: cannot exceed bounds
if new_coherence.value() > 1.0 || new_coherence.value() < 0.0 {
return Err(CoherenceViolation::OutOfRange);
}
let old = self.current_coherence;
self.history.record(old);
self.current_coherence = new_coherence;
self.trend = self.history.compute_trend();
self.stability_score = self.compute_stability();
// Emit events based on state change
if new_coherence < self.bounds.min_coherence {
self.events.push(CoherenceEvent::BelowMinimum {
coherence: new_coherence,
minimum: self.bounds.min_coherence,
});
}
if self.trend == CoherenceTrend::Declining && self.stability_score < 0.5 {
self.events.push(CoherenceEvent::StabilityWarning {
score: self.stability_score,
});
}
Ok(())
}
/// Check if transition would violate coherence bounds
pub fn validate_transition(&self, predicted_post_coherence: Coherence) -> TransitionValidity {
let drop = self.current_coherence.value() - predicted_post_coherence.value();
if predicted_post_coherence < self.bounds.min_coherence {
return TransitionValidity::Rejected(RejectionReason::BelowMinimum);
}
if drop > self.bounds.max_delta_drop {
return TransitionValidity::Rejected(RejectionReason::ExcessiveDrop);
}
if predicted_post_coherence < self.bounds.throttle_threshold {
return TransitionValidity::Throttled(self.compute_throttle_duration(drop));
}
TransitionValidity::Allowed
}
}
```
### 2. TransitionRequest (Transition Context)
```rust
/// Root aggregate for transition lifecycle
pub struct TransitionRequest {
// Identity
id: TransitionId,
// Specification
spec: TransitionSpec,
// State
status: TransitionStatus,
// Validation results
coherence_validation: Option<TransitionValidity>,
energy_cost: Option<EnergyCost>,
priority: Option<TransitionPriority>,
// Timestamps
requested_at: Instant,
validated_at: Option<Instant>,
executed_at: Option<Instant>,
// Events
events: Vec<TransitionEvent>,
}
#[derive(Debug, Clone)]
pub enum TransitionStatus {
Pending,
Validated,
Scheduled { priority: TransitionPriority },
Throttled { until: Instant },
Executing,
Completed,
Rejected { reason: RejectionReason },
}
impl TransitionRequest {
/// Create new transition request
pub fn new(spec: TransitionSpec) -> Self {
let id = TransitionId::generate();
let now = Instant::now();
Self {
id,
spec,
status: TransitionStatus::Pending,
coherence_validation: None,
energy_cost: None,
priority: None,
requested_at: now,
validated_at: None,
executed_at: None,
events: vec![TransitionEvent::Requested { id, spec: spec.clone(), at: now }],
}
}
/// Validate against coherence bounds
pub fn validate(&mut self, coherence_state: &CoherenceState) -> &TransitionValidity {
let predicted = self.spec.predict_coherence();
let validity = coherence_state.validate_transition(predicted);
self.coherence_validation = Some(validity.clone());
self.validated_at = Some(Instant::now());
match &validity {
TransitionValidity::Allowed => {
self.status = TransitionStatus::Validated;
self.events.push(TransitionEvent::Validated { id: self.id });
}
TransitionValidity::Throttled(duration) => {
self.status = TransitionStatus::Throttled { until: Instant::now() + *duration };
self.events.push(TransitionEvent::Throttled { id: self.id, duration: *duration });
}
TransitionValidity::Rejected(reason) => {
self.status = TransitionStatus::Rejected { reason: reason.clone() };
self.events.push(TransitionEvent::Rejected { id: self.id, reason: reason.clone() });
}
}
self.coherence_validation.as_ref().unwrap()
}
/// Assign energy cost
pub fn assign_cost(&mut self, cost: EnergyCost) {
self.energy_cost = Some(cost);
}
/// Schedule for execution
pub fn schedule(&mut self, priority: TransitionPriority) {
self.priority = Some(priority);
self.status = TransitionStatus::Scheduled { priority };
self.events.push(TransitionEvent::Scheduled { id: self.id, priority });
}
/// Execute the transition
pub fn execute(&mut self) -> Result<TransitionResult, TransitionError> {
match &self.status {
TransitionStatus::Scheduled { .. } | TransitionStatus::Validated => {
self.status = TransitionStatus::Executing;
let result = self.spec.execute()?;
self.status = TransitionStatus::Completed;
self.executed_at = Some(Instant::now());
self.events.push(TransitionEvent::Executed {
id: self.id,
at: self.executed_at.unwrap(),
});
Ok(result)
}
_ => Err(TransitionError::InvalidStatus(self.status.clone())),
}
}
}
```
### 3. AttractorBasin (Attractor Context)
```rust
/// Root aggregate for attractor management
pub struct AttractorBasin {
// Identity
id: AttractorBasinId,
// The attractor itself
attractor: Attractor,
// Basin membership
member_states: HashSet<StateFingerprint>,
// Statistics
entry_count: u64,
exit_count: u64,
average_residence_time: Duration,
// Events
events: Vec<AttractorEvent>,
}
impl AttractorBasin {
/// Discover new attractor from trajectory
pub fn from_trajectory(trajectory: &[SystemState]) -> Option<Self> {
let attractor = Attractor::identify(trajectory)?;
Some(Self {
id: AttractorBasinId::from(&attractor),
attractor,
member_states: HashSet::new(),
entry_count: 0,
exit_count: 0,
average_residence_time: Duration::ZERO,
events: vec![AttractorEvent::Discovered { attractor: attractor.clone() }],
})
}
/// Check if state is in this basin
pub fn contains(&self, state: &SystemState) -> bool {
let distance = self.attractor.distance_to(state);
distance < self.attractor.basin_radius()
}
/// Record state entering basin
pub fn record_entry(&mut self, state: &SystemState) {
let fingerprint = state.fingerprint();
if self.member_states.insert(fingerprint) {
self.entry_count += 1;
self.events.push(AttractorEvent::StateEntered {
basin_id: self.id,
state_fingerprint: fingerprint,
});
}
}
/// Record state leaving basin
pub fn record_exit(&mut self, state: &SystemState, residence_time: Duration) {
let fingerprint = state.fingerprint();
if self.member_states.remove(&fingerprint) {
self.exit_count += 1;
self.update_average_residence_time(residence_time);
self.events.push(AttractorEvent::StateExited {
basin_id: self.id,
state_fingerprint: fingerprint,
residence_time,
});
}
}
/// Compute guidance force toward attractor
pub fn guidance_force(&self, from: &SystemState) -> GuidanceForce {
let direction = self.attractor.center().direction_from(from);
let distance = self.attractor.distance_to(from);
// Force decreases with distance (inverse square for smooth approach)
let magnitude = self.attractor.stability / (1.0 + distance.powi(2));
GuidanceForce { direction, magnitude }
}
}
```
## Value Objects
```rust
/// Coherence value (0.0 to 1.0)
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Coherence(f64);
impl Coherence {
pub fn new(value: f64) -> Result<Self, CoherenceError> {
if value < 0.0 || value > 1.0 {
Err(CoherenceError::OutOfRange(value))
} else {
Ok(Self(value))
}
}
pub fn maximum() -> Self { Self(1.0) }
pub fn minimum() -> Self { Self(0.0) }
pub fn value(&self) -> f64 { self.0 }
}
/// Energy cost for a transition
#[derive(Debug, Clone, Copy)]
pub struct EnergyCost {
base: f64,
instability_factor: f64,
total: f64,
}
/// Transition specification (immutable)
#[derive(Debug, Clone)]
pub struct TransitionSpec {
pub operation: Operation,
pub target: TransitionTarget,
pub predicted_coherence_impact: f64,
pub locality_score: f64,
}
/// Guidance force from attractor
#[derive(Debug, Clone)]
pub struct GuidanceForce {
pub direction: Vec<f64>,
pub magnitude: f64,
}
```
## Domain Events
```rust
// Coherence Events
pub enum CoherenceEvent {
StateCreated { id: CoherenceStateId },
Updated { from: Coherence, to: Coherence },
BelowMinimum { coherence: Coherence, minimum: Coherence },
StabilityWarning { score: f64 },
EmergencyHalt,
}
// Transition Events
pub enum TransitionEvent {
Requested { id: TransitionId, spec: TransitionSpec, at: Instant },
Validated { id: TransitionId },
Throttled { id: TransitionId, duration: Duration },
Scheduled { id: TransitionId, priority: TransitionPriority },
Executed { id: TransitionId, at: Instant },
Rejected { id: TransitionId, reason: RejectionReason },
}
// Attractor Events
pub enum AttractorEvent {
Discovered { attractor: Attractor },
StateEntered { basin_id: AttractorBasinId, state_fingerprint: StateFingerprint },
StateExited { basin_id: AttractorBasinId, state_fingerprint: StateFingerprint, residence_time: Duration },
BasinExpanded { basin_id: AttractorBasinId, new_radius: f64 },
AttractorMerged { absorbed: AttractorBasinId, into: AttractorBasinId },
}
```
## Domain Services
```rust
/// Service for coherence measurement
pub struct CoherenceMeasurementService {
vector_measurer: VectorCoherenceMeasurer,
graph_measurer: GraphCoherenceMeasurer,
agent_measurer: AgentCoherenceMeasurer,
}
impl CoherenceMeasurementService {
pub fn measure(&self, system: &SystemState) -> Coherence {
match system.kind() {
SystemKind::Vector => self.vector_measurer.measure(system),
SystemKind::Graph => self.graph_measurer.measure(system),
SystemKind::Agent => self.agent_measurer.measure(system),
}
}
}
/// Service for transition enforcement
pub struct TransitionEnforcementService {
energy_layer: EnergyEnforcementLayer,
scheduling_layer: SchedulingEnforcementLayer,
gating_layer: GatingEnforcementLayer,
}
impl TransitionEnforcementService {
pub fn enforce(&self, request: &mut TransitionRequest, coherence: &CoherenceState) -> EnforcementResult {
// Layer 1: Energy
let cost = self.energy_layer.compute_cost(&request.spec);
request.assign_cost(cost);
if !self.energy_layer.can_afford(cost) {
return EnforcementResult::EnergyExhausted;
}
// Layer 2: Scheduling
request.validate(coherence);
match request.coherence_validation.as_ref().unwrap() {
TransitionValidity::Rejected(reason) => {
return EnforcementResult::Rejected(reason.clone());
}
TransitionValidity::Throttled(duration) => {
return EnforcementResult::Throttled(*duration);
}
TransitionValidity::Allowed => {}
}
let priority = self.scheduling_layer.assign_priority(request, coherence);
request.schedule(priority);
// Layer 3: Gating (final check before execution)
if !self.gating_layer.is_open() {
return EnforcementResult::GateClosed;
}
EnforcementResult::Scheduled(priority)
}
}
/// Service for attractor discovery
pub struct AttractorDiscoveryService {
discoverer: AttractorDiscoverer,
basins: HashMap<AttractorBasinId, AttractorBasin>,
}
impl AttractorDiscoveryService {
pub fn discover_from_trajectory(&mut self, trajectory: &[SystemState]) {
if let Some(basin) = AttractorBasin::from_trajectory(trajectory) {
self.basins.insert(basin.id, basin);
}
}
pub fn find_nearest_basin(&self, state: &SystemState) -> Option<&AttractorBasin> {
self.basins.values()
.filter(|b| b.contains(state))
.min_by(|a, b| {
a.attractor.distance_to(state)
.partial_cmp(&b.attractor.distance_to(state))
.unwrap()
})
}
}
```
## Repositories
```rust
/// Repository for coherence state persistence
#[async_trait]
pub trait CoherenceRepository {
async fn save(&self, state: &CoherenceState) -> Result<(), RepositoryError>;
async fn load(&self, id: CoherenceStateId) -> Result<CoherenceState, RepositoryError>;
async fn history(&self, id: CoherenceStateId, limit: usize) -> Result<Vec<Coherence>, RepositoryError>;
}
/// Repository for attractor basins
#[async_trait]
pub trait AttractorRepository {
async fn save_basin(&self, basin: &AttractorBasin) -> Result<(), RepositoryError>;
async fn load_basin(&self, id: AttractorBasinId) -> Result<AttractorBasin, RepositoryError>;
async fn all_basins(&self) -> Result<Vec<AttractorBasin>, RepositoryError>;
async fn find_containing(&self, state: &SystemState) -> Result<Option<AttractorBasin>, RepositoryError>;
}
/// Repository for transition audit log
#[async_trait]
pub trait TransitionAuditRepository {
async fn record(&self, request: &TransitionRequest) -> Result<(), RepositoryError>;
async fn query(&self, filter: TransitionFilter) -> Result<Vec<TransitionRequest>, RepositoryError>;
}
```

818
examples/delta-behavior/docs/API.md Normal file
View File

@@ -0,0 +1,818 @@
# Delta-Behavior API Reference
Comprehensive API documentation for the Delta-behavior library.
## Table of Contents
- [Quick Start](#quick-start)
- [Core Concepts](#core-concepts)
- [Coherence](#coherence)
- [Attractors](#attractors)
- [Transitions](#transitions)
- [API Reference](#api-reference)
- [Core Types](#core-types)
- [Configuration](#configuration)
- [Enforcement](#enforcement)
- [Applications](#applications)
- [Integration Examples](#integration-examples)
---
## Quick Start
### Installation
Add to your `Cargo.toml`:
```toml
[dependencies]
delta-behavior = "0.1"
# Or with specific applications
delta-behavior = { version = "0.1", features = ["containment", "swarm-intelligence"] }
```
### Minimal Example
```rust
use delta_behavior::{DeltaSystem, Coherence, DeltaConfig};
// Implement DeltaSystem for your type
struct MySystem {
state: Vec<f64>,
coherence: Coherence,
}
impl DeltaSystem for MySystem {
type State = Vec<f64>;
type Transition = Vec<f64>;
type Error = String;
fn coherence(&self) -> Coherence {
self.coherence
}
fn step(&mut self, delta: &Self::Transition) -> Result<(), Self::Error> {
// Validate coherence before applying
let predicted = self.predict_coherence(delta);
if predicted.value() < 0.3 {
return Err("Would violate coherence bound".into());
}
// Apply the transition
for (s, d) in self.state.iter_mut().zip(delta) {
*s += d;
}
self.coherence = predicted;
Ok(())
}
fn predict_coherence(&self, delta: &Self::Transition) -> Coherence {
let magnitude: f64 = delta.iter().map(|x| x.abs()).sum();
let impact = magnitude * 0.01;
Coherence::clamped(self.coherence.value() - impact)
}
fn state(&self) -> &Self::State {
&self.state
}
fn in_attractor(&self) -> bool {
// Check if state is near a stable configuration
self.state.iter().all(|x| x.abs() < 1.0)
}
}
```
### With Enforcement
```rust
use delta_behavior::{DeltaConfig, enforcement::DeltaEnforcer};
fn main() {
let config = DeltaConfig::default();
let mut enforcer = DeltaEnforcer::new(config);
let current = Coherence::new(0.8).unwrap();
let predicted = Coherence::new(0.75).unwrap();
match enforcer.check(current, predicted) {
EnforcementResult::Allowed => {
// Apply the transition
}
EnforcementResult::Throttled(duration) => {
// Wait before retrying
std::thread::sleep(duration);
}
EnforcementResult::Blocked(reason) => {
// Transition rejected
eprintln!("Blocked: {}", reason);
}
}
}
```
---
## Core Concepts
### Coherence
Coherence is the central metric in Delta-behavior systems. It measures how "organized" or "stable" a system currently is.
#### Properties
| Value | Meaning |
|-------|---------|
| 1.0 | Maximum coherence - perfectly organized |
| 0.8+ | High coherence - system is stable |
| 0.5-0.8 | Moderate coherence - may be throttled |
| 0.3-0.5 | Low coherence - transitions restricted |
| <0.3 | Critical - writes blocked |
| 0.0 | Collapsed - system failure |
#### Computing Coherence
Coherence computation depends on your domain:
##### For Vector Spaces (HNSW neighborhoods)
```rust
pub fn vector_coherence(center: &[f64], neighbors: &[&[f64]]) -> f64 {
let distances: Vec<f64> = neighbors
.iter()
.map(|n| cosine_distance(center, n))
.collect();
let mean = distances.iter().sum::<f64>() / distances.len() as f64;
let variance = distances.iter()
.map(|d| (d - mean).powi(2))
.sum::<f64>() / distances.len() as f64;
// Low variance = high coherence (tight neighborhood)
1.0 / (1.0 + variance)
}
```
##### For Graphs
```rust
pub fn graph_coherence(graph: &Graph) -> f64 {
let clustering = compute_clustering_coefficient(graph);
let modularity = compute_modularity(graph);
let connectivity = compute_algebraic_connectivity(graph);
0.4 * clustering + 0.3 * modularity + 0.3 * connectivity.min(1.0)
}
```
##### For Agent State
```rust
pub fn agent_coherence(state: &AgentState) -> f64 {
let attention_entropy = compute_attention_entropy(&state.attention);
let memory_consistency = compute_memory_consistency(&state.memory);
let goal_alignment = compute_goal_alignment(&state.goals, &state.actions);
// Low entropy + high consistency + high alignment = coherent
((1.0 - attention_entropy) * memory_consistency * goal_alignment).clamp(0.0, 1.0)
}
```
### Attractors
Attractors are stable states the system naturally evolves toward.
#### Types of Attractors
| Type | Description | Example |
|------|-------------|---------|
| Fixed Point | Single stable state | Thermostat at target temperature |
| Limit Cycle | Repeating sequence | Day/night cycle |
| Strange Attractor | Bounded chaos | Weather patterns |
#### Using Attractors
```rust
use delta_behavior::attractor::{Attractor, GuidanceForce};
// Define an attractor
let stable_state = Attractor {
state: vec![0.0, 0.0, 0.0], // Origin is stable
strength: 0.8,
radius: 1.0,
};
// Compute guidance force
let current_position = vec![0.5, 0.3, 0.2];
let force = GuidanceForce::toward(
&current_position,
&stable_state.state,
stable_state.strength,
);
// Apply to transition
let biased_delta: Vec<f64> = original_delta
.iter()
.zip(&force.direction)
.map(|(d, f)| d + f * force.magnitude * 0.1)
.collect();
```
### Transitions
Transitions are state changes that must preserve coherence.
#### The Delta-Behavior Invariant
Every transition must satisfy:
```
coherence(S') >= coherence(S) - epsilon_max
coherence(S') >= coherence_min
```
#### Transition Results
| Result | Meaning | Action |
|--------|---------|--------|
| `Applied` | Transition succeeded | Continue |
| `Blocked` | Transition rejected | Find alternative |
| `Throttled` | Transition delayed | Wait and retry |
| `Modified` | Transition adjusted | Use modified version |
---
## API Reference
### Core Types
#### `Coherence`
```rust
pub struct Coherence(f64);
impl Coherence {
/// Create new coherence value (must be 0.0-1.0)
pub fn new(value: f64) -> Result<Self, &'static str>;
/// Create coherence, clamping to valid range
pub fn clamped(value: f64) -> Self;
/// Maximum coherence (1.0)
pub fn maximum() -> Self;
/// Minimum coherence (0.0)
pub fn minimum() -> Self;
/// Get the underlying value
pub fn value(&self) -> f64;
/// Check if above threshold
pub fn is_above(&self, threshold: f64) -> bool;
/// Check if below threshold
pub fn is_below(&self, threshold: f64) -> bool;
/// Calculate drop from another value
pub fn drop_from(&self, other: &Coherence) -> f64;
}
```
#### `CoherenceBounds`
```rust
pub struct CoherenceBounds {
/// Minimum acceptable coherence (writes blocked below this)
pub min_coherence: Coherence,
/// Throttle threshold (rate limited below this)
pub throttle_threshold: Coherence,
/// Target coherence for recovery
pub target_coherence: Coherence,
/// Maximum drop allowed per transition
pub max_delta_drop: f64,
}
impl Default for CoherenceBounds {
fn default() -> Self {
Self {
min_coherence: Coherence(0.3),
throttle_threshold: Coherence(0.5),
target_coherence: Coherence(0.8),
max_delta_drop: 0.1,
}
}
}
```
#### `DeltaSystem` Trait
```rust
pub trait DeltaSystem {
/// The state type
type State: Clone;
/// The transition type
type Transition;
/// Error type for failed transitions
type Error;
/// Measure current coherence
fn coherence(&self) -> Coherence;
/// Apply a transition
fn step(&mut self, transition: &Self::Transition) -> Result<(), Self::Error>;
/// Predict coherence after transition (without applying)
fn predict_coherence(&self, transition: &Self::Transition) -> Coherence;
/// Get current state
fn state(&self) -> &Self::State;
/// Check if in an attractor basin
fn in_attractor(&self) -> bool;
}
```
### Configuration
#### `DeltaConfig`
```rust
pub struct DeltaConfig {
pub bounds: CoherenceBounds,
pub energy: EnergyConfig,
pub scheduling: SchedulingConfig,
pub gating: GatingConfig,
pub guidance_strength: f64, // 0.0-1.0
}
impl DeltaConfig {
/// Default configuration
pub fn default() -> Self;
/// Strict configuration for safety-critical systems
pub fn strict() -> Self;
/// Relaxed configuration for exploratory systems
pub fn relaxed() -> Self;
}
```
#### `EnergyConfig`
Controls the soft enforcement layer where unstable transitions become expensive.
```rust
pub struct EnergyConfig {
/// Base cost for any transition
pub base_cost: f64, // default: 1.0
/// Exponent for instability scaling
pub instability_exponent: f64, // default: 2.0
/// Maximum cost cap
pub max_cost: f64, // default: 100.0
/// Budget regeneration per tick
pub budget_per_tick: f64, // default: 10.0
}
```
Energy cost formula:
```
cost = base_cost * (1 + instability)^instability_exponent
```
#### `SchedulingConfig`
Controls the medium enforcement layer for prioritization.
```rust
pub struct SchedulingConfig {
/// Coherence thresholds for 5 priority levels
pub priority_thresholds: [f64; 5], // default: [0.0, 0.3, 0.5, 0.7, 0.9]
/// Rate limits per priority level
pub rate_limits: [usize; 5], // default: [100, 50, 20, 10, 5]
}
```
#### `GatingConfig`
Controls the hard enforcement layer that blocks writes.
```rust
pub struct GatingConfig {
/// Minimum coherence to allow any writes
pub min_write_coherence: f64, // default: 0.3
/// Minimum coherence after write
pub min_post_write_coherence: f64, // default: 0.25
/// Recovery margin before writes resume
pub recovery_margin: f64, // default: 0.2
}
```
### Enforcement
#### `DeltaEnforcer`
```rust
pub struct DeltaEnforcer {
config: DeltaConfig,
energy_budget: f64,
in_recovery: bool,
}
impl DeltaEnforcer {
/// Create new enforcer
pub fn new(config: DeltaConfig) -> Self;
/// Check if transition should be allowed
pub fn check(
&mut self,
current: Coherence,
predicted: Coherence,
) -> EnforcementResult;
/// Regenerate energy budget (call once per tick)
pub fn tick(&mut self);
}
```
#### `EnforcementResult`
```rust
pub enum EnforcementResult {
/// Transition allowed
Allowed,
/// Transition blocked with reason
Blocked(String),
/// Transition throttled (delayed)
Throttled(Duration),
}
impl EnforcementResult {
/// Check if allowed
pub fn is_allowed(&self) -> bool;
}
```
---
## Applications
Enable via feature flags:
| Feature | Application | Description |
|---------|-------------|-------------|
| `self-limiting` | Self-Limiting Reasoning | AI that does less when uncertain |
| `event-horizon` | Computational Event Horizons | Bounded recursion without hard limits |
| `homeostasis` | Artificial Homeostasis | Synthetic life with coherence-based survival |
| `world-model` | Self-Stabilizing World Models | Models that refuse to hallucinate |
| `creativity` | Coherence-Bounded Creativity | Novelty without chaos |
| `financial` | Anti-Cascade Financial | Markets that cannot collapse |
| `aging` | Graceful Aging | Systems that simplify over time |
| `swarm` | Swarm Intelligence | Collective behavior without pathology |
| `shutdown` | Graceful Shutdown | Systems that seek safe termination |
| `containment` | Pre-AGI Containment | Bounded intelligence growth |
| `all-applications` | All of the above | Full feature set |
### Application 1: Self-Limiting Reasoning
AI systems that automatically reduce activity when uncertain.
```rust
use delta_behavior::applications::self_limiting::{SelfLimitingReasoner, ReasoningStep};
let mut reasoner = SelfLimitingReasoner::new(0.6); // Min coherence
// Reasoning naturally slows as confidence drops
let result = reasoner.reason(query, context);
match result {
ReasoningResult::Complete(answer) => println!("Answer: {}", answer),
ReasoningResult::Halted { reason, partial } => {
println!("Stopped: {} (partial: {:?})", reason, partial);
}
ReasoningResult::Shallow { depth_reached } => {
println!("Limited to depth {}", depth_reached);
}
}
```
### Application 5: Coherence-Bounded Creativity
Generate novel outputs while maintaining coherence.
```rust
use delta_behavior::applications::creativity::{CreativeEngine, NoveltyMetrics};
let mut engine = CreativeEngine::new(0.5, 0.8); // coherence, novelty bounds
// Generate creative output that stays coherent
let output = engine.generate(seed, context);
println!("Novelty: {:.2}", output.novelty_score);
println!("Coherence: {:.2}", output.coherence);
println!("Result: {}", output.content);
```
### Application 8: Swarm Intelligence
Collective behavior with coherence-enforced coordination.
```rust
use delta_behavior::applications::swarm::{CoherentSwarm, SwarmAction};
let mut swarm = CoherentSwarm::new(0.6); // Min coherence
// Add agents
for i in 0..10 {
swarm.add_agent(&format!("agent_{}", i), (i as f64, 0.0));
}
// Agent actions are validated against swarm coherence
let result = swarm.execute_action("agent_5", SwarmAction::Move { dx: 10.0, dy: 5.0 });
match result {
ActionResult::Executed => println!("Action completed"),
ActionResult::Modified { original, modified, reason } => {
println!("Modified: {} -> {} ({})", original, modified, reason);
}
ActionResult::Rejected { reason } => {
println!("Rejected: {}", reason);
}
}
```
### Application 10: Pre-AGI Containment
Intelligence growth bounded by coherence.
```rust
use delta_behavior::applications::containment::{
ContainmentSubstrate, CapabilityDomain, GrowthResult
};
let mut substrate = ContainmentSubstrate::new();
// Attempt capability growth
let result = substrate.attempt_growth(CapabilityDomain::Reasoning, 0.5);
match result {
GrowthResult::Approved { increase, new_level, coherence_cost, .. } => {
println!("Grew by {:.2} to {:.2} (cost: {:.3})", increase, new_level, coherence_cost);
}
GrowthResult::Dampened { requested, actual, reason, .. } => {
println!("Dampened: {:.2} -> {:.2} ({})", requested, actual, reason);
}
GrowthResult::Blocked { reason, .. } => {
println!("Blocked: {}", reason);
}
GrowthResult::Lockdown { reason } => {
println!("LOCKDOWN: {}", reason);
}
}
```
---
## Integration Examples
### With Async Runtimes
```rust
use delta_behavior::{DeltaConfig, enforcement::DeltaEnforcer, Coherence};
use tokio::sync::Mutex;
use std::sync::Arc;
struct AsyncDeltaSystem {
enforcer: Arc<Mutex<DeltaEnforcer>>,
state: Arc<Mutex<SystemState>>,
}
impl AsyncDeltaSystem {
pub async fn transition(&self, delta: Delta) -> Result<(), Error> {
let mut enforcer = self.enforcer.lock().await;
let state = self.state.lock().await;
let current = state.coherence();
let predicted = state.predict_coherence(&delta);
match enforcer.check(current, predicted) {
EnforcementResult::Allowed => {
drop(state); // Release read lock
let mut state = self.state.lock().await;
state.apply(delta);
Ok(())
}
EnforcementResult::Throttled(duration) => {
drop(enforcer);
drop(state);
tokio::time::sleep(duration).await;
self.transition(delta).await // Retry
}
EnforcementResult::Blocked(reason) => {
Err(Error::Blocked(reason))
}
}
}
}
```
### With WASM
```rust
use wasm_bindgen::prelude::*;
use delta_behavior::{Coherence, CoherenceBounds};
#[wasm_bindgen]
pub struct WasmCoherenceMeter {
current: f64,
bounds: CoherenceBounds,
}
#[wasm_bindgen]
impl WasmCoherenceMeter {
#[wasm_bindgen(constructor)]
pub fn new() -> Self {
Self {
current: 1.0,
bounds: CoherenceBounds::default(),
}
}
#[wasm_bindgen]
pub fn check(&self, predicted: f64) -> bool {
predicted >= self.bounds.min_coherence.value()
}
#[wasm_bindgen]
pub fn update(&mut self, new_coherence: f64) {
self.current = new_coherence.clamp(0.0, 1.0);
}
#[wasm_bindgen]
pub fn current(&self) -> f64 {
self.current
}
}
```
### With Machine Learning Frameworks
```rust
use delta_behavior::{DeltaSystem, Coherence, DeltaConfig};
struct CoherentNeuralNetwork {
weights: Vec<Vec<f64>>,
coherence: Coherence,
config: DeltaConfig,
}
impl CoherentNeuralNetwork {
/// Training step with coherence constraints
pub fn train_step(&mut self, gradients: &[Vec<f64>], learning_rate: f64) -> Result<(), String> {
// Compute coherence impact of update
let update_magnitude: f64 = gradients.iter()
.flat_map(|g| g.iter())
.map(|x| (x * learning_rate).abs())
.sum();
let predicted_coherence = Coherence::clamped(
self.coherence.value() - update_magnitude * 0.01
);
// Check bounds
if predicted_coherence.value() < self.config.bounds.min_coherence.value() {
// Reduce learning rate to maintain coherence
let safe_lr = learning_rate * 0.5;
return self.train_step(gradients, safe_lr);
}
// Apply update
for (w, g) in self.weights.iter_mut().zip(gradients) {
for (wi, gi) in w.iter_mut().zip(g) {
*wi -= gi * learning_rate;
}
}
self.coherence = predicted_coherence;
Ok(())
}
}
```
---
## Best Practices
### 1. Choose Appropriate Coherence Metrics
Match your coherence computation to your domain:
- **Vector spaces**: Distance variance, neighborhood consistency
- **Graphs**: Clustering coefficient, modularity, connectivity
- **Agent systems**: Entropy, goal alignment, memory consistency
### 2. Start Conservative, Relax Gradually
Begin with `DeltaConfig::strict()` and relax constraints as you understand your system's behavior.
### 3. Implement Graceful Degradation
Always handle `Throttled` and `Blocked` results:
```rust
fn robust_transition(system: &mut MySystem, delta: Delta) -> Result<(), Error> {
for attempt in 0..3 {
match system.try_transition(&delta) {
Ok(()) => return Ok(()),
Err(TransitionError::Throttled(delay)) => {
std::thread::sleep(delay);
}
Err(TransitionError::Blocked(_)) if attempt < 2 => {
delta = delta.dampen(0.5); // Try smaller delta
}
Err(e) => return Err(e.into()),
}
}
Err(Error::MaxRetriesExceeded)
}
```
### 4. Monitor Coherence Trends
Track coherence over time to detect gradual degradation:
```rust
let mut state = CoherenceState::new(Coherence::maximum());
// In your main loop
state.update(system.coherence());
if state.is_declining() && state.current.value() < 0.6 {
// Trigger recovery actions
system.enter_recovery_mode();
}
```
### 5. Use Attractors for Stability
Pre-compute and register stable states:
```rust
let attractors = discover_attractors(&system, 1000);
for attractor in attractors {
system.register_attractor(attractor);
}
// Now transitions will be biased toward these stable states
```
---
## Troubleshooting
### High Rejection Rate
If too many transitions are being blocked:
1. Check if `max_delta_drop` is too restrictive
2. Consider using `DeltaConfig::relaxed()`
3. Ensure coherence computation is correctly calibrated
### Energy Exhaustion
If running out of energy budget:
1. Increase `budget_per_tick`
2. Lower `instability_exponent` for gentler cost curves
3. Call `enforcer.tick()` more frequently
### Stuck in Recovery Mode
If the system stays in recovery mode:
1. Reduce `recovery_margin`
2. Implement active coherence restoration
3. Lower `min_write_coherence` temporarily
---
## Version History
See [CHANGELOG.md](../CHANGELOG.md) for version history.
## License
MIT OR Apache-2.0

639
examples/delta-behavior/docs/CODE-REVIEW.md Normal file
View File

@@ -0,0 +1,639 @@
# Delta-Behavior Code Review Report
**Date**: 2026-01-28
**Reviewer**: Code Review Agent
**Scope**: /workspaces/ruvector/examples/delta-behavior/
---
## Executive Summary
This review covers the delta-behavior library implementation, including the core library (`src/lib.rs`), WASM bindings (`src/wasm.rs`), 11 application examples, and test files. The implementation demonstrates solid mathematical foundations aligned with the ADR specifications, but several issues require attention.
**Overall Assessment**: The codebase is well-structured with good documentation. However, there are concerns around error handling, potential memory growth, and thread safety that should be addressed before production use.
| Category | Status | Issues Found |
|----------|--------|--------------|
| Correctness | PASS with notes | 2 minor |
| API Consistency | NEEDS ATTENTION | 5 issues |
| Error Handling | NEEDS ATTENTION | 8 critical unwrap() calls |
| Documentation | GOOD | 3 minor gaps |
| Test Coverage | NEEDS IMPROVEMENT | Missing edge cases |
| Memory Safety | NEEDS ATTENTION | 4 unbounded growth patterns |
| Thread Safety | NEEDS ATTENTION | 3 potential issues |
---
## 1. Correctness Review
### 1.1 Coherence Calculations vs ADR Definitions
**ADR-001** defines coherence as:
```
C(S) in [0, 1] where 1 = maximally coherent, 0 = maximally disordered
```
**Implementation in `/workspaces/ruvector/examples/delta-behavior/src/lib.rs` (lines 336-346)**:
```rust
pub fn new(value: f64) -> Result<Self, &'static str> {
if !(0.0..=1.0).contains(&value) {
Err("Coherence must be between 0.0 and 1.0")
} else {
Ok(Self(value))
}
}
```
**PASS**: Correctly enforces the [0, 1] bound.
### 1.2 Coherence Drop Calculation
**ADR-001** specifies max_delta_drop constraint:
```
coherence_drop > bounds.max_delta_drop -> Reject
```
**Implementation in `/workspaces/ruvector/examples/delta-behavior/src/lib.rs` (lines 653-659)**:
```rust
let drop = predicted.drop_from(&current);
if drop > self.config.bounds.max_delta_drop {
return EnforcementResult::Blocked(format!(
"Coherence drop {:.3} exceeds max {:.3}",
drop, self.config.bounds.max_delta_drop
));
}
```
**PASS**: Correctly implements the max_delta_drop constraint.
### 1.3 Minor Correctness Issue: drop_from() Calculation
**File**: `/workspaces/ruvector/examples/delta-behavior/src/lib.rs`
**Lines**: 379-381
```rust
pub fn drop_from(&self, other: &Coherence) -> f64 {
(other.0 - self.0).max(0.0)
}
```
**ISSUE**: The method name `drop_from` is confusing. It calculates how much `self` dropped FROM `other`, but the signature reads as "drop from self". Consider renaming to `drop_relative_to()` or adding clearer documentation.
### 1.4 Energy Cost Formula
**ADR-000** recommends:
```rust
fn transition_cost(delta: &Delta) -> f64 {
BASE_COST * (1.0 + instability).exp()
}
```
**Implementation in `/workspaces/ruvector/examples/delta-behavior/src/lib.rs` (lines 677-684)**:
```rust
fn calculate_cost(&self, current: Coherence, predicted: Coherence) -> f64 {
let drop = (current.value() - predicted.value()).max(0.0);
let instability_factor = (1.0_f64 / predicted.value().max(0.1))
.powf(self.config.energy.instability_exponent);
(self.config.energy.base_cost + drop * 10.0 * instability_factor)
.min(self.config.energy.max_cost)
}
```
**NOTE**: Uses power function instead of exponential. This is a valid design choice but differs from ADR recommendation. The implementation is arguably more controllable via `instability_exponent`.
---
## 2. API Consistency Review
### 2.1 Inconsistent Coherence Access Patterns
**Issue**: Mixed use of getter methods vs direct field access across applications.
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
| Application | Coherence Access | Line |
|-------------|------------------|------|
| WasmSelfLimitingReasoner | `self.coherence` (direct) | 194 |
| WasmEventHorizon | N/A (no coherence field) | - |
| WasmHomeostasticOrganism | `self.coherence` (direct) | 528 |
| WasmSelfStabilizingWorldModel | `self.coherence` (direct) | 731 |
| WasmCoherenceBoundedCreator | `self.coherence` (direct) | 944 |
| WasmAntiCascadeFinancialSystem | `self.coherence` (direct) | 1076 |
| WasmGracefullyAgingSystem | `self.coherence` (direct) | 1244 |
| WasmCoherentSwarm | `self.coherence` (direct) | 1420 |
| WasmGracefulSystem | `self.coherence` (direct) | 1657 |
| WasmContainmentSubstrate | `self.coherence` (direct) | 1827 |
**RECOMMENDATION**: Use consistent `coherence()` method across all types for encapsulation.
### 2.2 Inconsistent Status/Status JSON Methods
**Issue**: Some applications return JSON strings, others return formatted strings.
**File**: `/workspaces/ruvector/examples/delta-behavior/applications/10-pre-agi-containment.rs`
**Line**: 420-427
```rust
pub fn status(&self) -> String {
format!(
"Intelligence: {:.2} | Coherence: {:.3} | Required: {:.3} | Modifications: {}",
self.intelligence,
self.coherence,
self.required_coherence(),
self.modification_history.len()
)
}
```
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
**Line**: 1957-1963
```rust
pub fn status(&self) -> String {
serde_json::json!({
"intelligence": self.intelligence,
"coherence": self.coherence,
// ...
}).to_string()
}
```
**RECOMMENDATION**: All WASM bindings should return JSON; native implementations can return formatted strings.
### 2.3 Missing Event Horizon Coherence
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
**Lines**: 254-275
```rust
pub struct WasmEventHorizon {
safe_center: Vec<f64>,
horizon_radius: f64,
steepness: f64,
energy_budget: f64,
current_position: Vec<f64>,
// NOTE: No coherence field!
}
```
**ISSUE**: `WasmEventHorizon` lacks a coherence field, breaking the pattern established by other applications. The energy_budget serves a similar purpose but is not named consistently.
### 2.4 Naming Inconsistency: WasmHomeostasticOrganism
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
**Line**: 468
```rust
pub struct WasmHomeostasticOrganism {
```
**ISSUE**: Typo in name - should be `WasmHomeostaticOrganism` (missing 'i').
### 2.5 Constructor Patterns Vary
| Type | Constructor | Line |
|------|-------------|------|
| WasmCoherence | `new(value)` returns `Result<_, JsError>` | 28 |
| WasmSelfLimitingReasoner | `new(max_depth, max_scope)` returns `Self` | 182 |
| WasmEventHorizon | `new(dimensions, horizon_radius)` returns `Self` | 267 |
| WasmGracefullyAgingSystem | `new()` returns `Self` | 1216 |
**RECOMMENDATION**: Standardize on either infallible constructors or Result-returning constructors.
---
## 3. Error Handling Review
### 3.1 Critical: Potential Panic Points (unwrap() calls)
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
| Line | Code | Risk |
|------|------|------|
| 303 | `serde_json::to_string(&self.current_position).unwrap_or_default()` | LOW (has default) |
| 1603 | `serde_json::to_string(&self.agents).unwrap_or_default()` | LOW (has default) |
| 1978 | `serde_json::to_string(&report).unwrap_or_default()` | LOW (has default) |
**File**: `/workspaces/ruvector/examples/delta-behavior/src/lib.rs`
| Line | Code | Risk |
|------|------|------|
| 229 | `Coherence::new(0.5).unwrap()` | CRITICAL |
| 230 | `Coherence::new(0.7).unwrap()` | CRITICAL |
| 231 | `Coherence::new(0.9).unwrap()` | CRITICAL |
| 245 | `Coherence::new(0.2).unwrap()` | CRITICAL |
| 246 | `Coherence::new(0.4).unwrap()` | CRITICAL |
| 247 | `Coherence::new(0.7).unwrap()` | CRITICAL |
| 400 | `Coherence(0.3)` (private constructor) | SAFE |
| 401 | `Coherence(0.5)` (private constructor) | SAFE |
| 402 | `Coherence(0.8)` (private constructor) | SAFE |
| 492 | `Coherence::new(0.3).unwrap()` | CRITICAL |
**CRITICAL ISSUE**: Lines 229-231, 245-247, and 492 use `unwrap()` on `Coherence::new()`. While these values are valid (within 0-1), the pattern sets a bad precedent.
**RECOMMENDATION**: Use `Coherence::clamped()` or create const constructors:
```rust
impl Coherence {
pub const fn const_new(value: f64) -> Self {
// Compile-time assertion would be better
Self(value)
}
}
```
### 3.2 File Operations Without Error Context
**File**: `/workspaces/ruvector/examples/delta-behavior/applications/10-pre-agi-containment.rs`
**Lines**: 241, 242
```rust
let current_level = *self.capabilities.get(&domain).unwrap_or(&1.0);
let ceiling = *self.capability_ceilings.get(&domain).unwrap_or(&10.0);
```
**PASS**: Uses `unwrap_or()` with sensible defaults - this is safe.
### 3.3 JSON Parsing Without Validation
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
**Lines**: 353-360
```rust
pub fn move_toward(&mut self, target_json: &str) -> String {
let target: Vec<f64> = match serde_json::from_str(target_json) {
Ok(t) => t,
Err(e) => return serde_json::json!({
"status": "error",
"reason": format!("Invalid target: {}", e)
}).to_string(),
};
```
**PASS**: Correctly handles JSON parse errors with informative error messages.
---
## 4. Documentation Review
### 4.1 Well-Documented Public Types
**File**: `/workspaces/ruvector/examples/delta-behavior/src/lib.rs`
The following are well-documented:
- `DeltaSystem` trait (lines 102-148)
- `Coherence` struct (lines 328-382)
- `CoherenceBounds` struct (lines 384-406)
- `DeltaConfig` struct (lines 188-220)
- `DeltaEnforcer` struct (lines 607-691)
### 4.2 Missing Documentation
**File**: `/workspaces/ruvector/examples/delta-behavior/src/lib.rs`
| Item | Line | Issue |
|------|------|-------|
| `EnergyConfig::instability_exponent` | 265 | Needs explanation of exponent behavior |
| `SchedulingConfig` | 284-299 | Missing doc comments |
| `GatingConfig` | 301-320 | Missing doc comments |
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
| Item | Line | Issue |
|------|------|-------|
| `GenomeParams` | 457-464 | Missing field-level docs |
| `EntityData` | 708-714 | Internal struct, but could use comments |
| `SwarmAgentData` | 1397-1404 | Internal struct, missing docs |
### 4.3 Module-Level Documentation
**PASS**: All application files have excellent module-level documentation explaining the purpose and theory behind each application.
---
## 5. Test Coverage Review
### 5.1 Existing Test Coverage
**File**: `/workspaces/ruvector/examples/delta-behavior/src/lib.rs` (lines 716-818)
Tests present:
- `test_coherence_bounds` - Basic coherence creation
- `test_coherence_clamping` - Clamping behavior
- `test_delta_system` - Basic DeltaSystem trait
- `test_enforcer` - Enforcement checks
- `test_config_presets` - Configuration presets
**File**: `/workspaces/ruvector/examples/delta-behavior/tests/wasm_bindings.rs`
Tests present for all 10 WASM applications.
### 5.2 Missing Edge Case Tests
**CRITICAL GAPS**:
1. **Zero Coherence Edge Case**
```rust
#[test]
fn test_zero_coherence() {
let c = Coherence::new(0.0).unwrap();
assert_eq!(c.value(), 0.0);
// What happens when enforcer sees zero coherence?
}
```
2. **Maximum Coherence Edge Case**
```rust
#[test]
fn test_max_coherence_transitions() {
// Test transitions from max coherence
let c = Coherence::maximum();
// Test drop calculations from max
}
```
3. **Empty Collections**
- `WasmCoherentSwarm` with 0 agents
- `WasmSelfStabilizingWorldModel` with 0 entities
- `CoherenceState` with empty history
4. **Boundary Conditions**
```rust
#[test]
fn test_coherence_at_exact_threshold() {
// Test when coherence == throttle_threshold exactly
// Test when coherence == min_coherence exactly
}
```
5. **Energy Budget Exhaustion**
```rust
#[test]
fn test_energy_budget_exhaustion() {
// Verify behavior when energy reaches 0
}
```
### 5.3 Missing Negative Tests
No tests for:
- Invalid JSON inputs
- Negative coherence values attempted
- Coherence values > 1.0
- Division by zero scenarios
---
## 6. Memory Safety Review
### 6.1 Unbounded Vec Growth
**CRITICAL**: Several structures have unbounded vector growth.
**File**: `/workspaces/ruvector/examples/delta-behavior/applications/10-pre-agi-containment.rs`
**Line**: 43
```rust
modification_history: Vec<ModificationAttempt>,
```
**ISSUE**: No limit on `modification_history` size. In long-running systems, this will grow unbounded.
**File**: `/workspaces/ruvector/examples/delta-behavior/applications/11-extropic-substrate.rs`
**Line**: 46
```rust
history: Vec<Vec<f64>>,
```
**ISSUE**: `MutableGoal.history` grows unbounded. No pruning mechanism.
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
**Line**: 701
```rust
entities: Vec<EntityData>,
```
**ISSUE**: `WasmSelfStabilizingWorldModel.entities` has no limit.
### 6.2 Bounded History Implementation (Good Example)
**File**: `/workspaces/ruvector/examples/delta-behavior/src/lib.rs`
**Lines**: 429-438
```rust
pub fn update(&mut self, new_coherence: Coherence) {
// ...
self.history.push(new_coherence);
// Keep history bounded
if self.history.len() > 100 {
self.history.remove(0);
}
// ...
}
```
**PASS**: `CoherenceState.history` is properly bounded to 100 entries.
### 6.3 Recommendations for Memory Safety
1. Add `MAX_HISTORY_SIZE` constants
2. Use `VecDeque` for O(1) front removal:
```rust
use std::collections::VecDeque;
modification_history: VecDeque<ModificationAttempt>,
```
3. Consider using `RingBuffer` pattern
4. Add capacity limits to constructors
---
## 7. Thread Safety Review
### 7.1 AtomicU64 Usage
**File**: `/workspaces/ruvector/examples/delta-behavior/applications/11-extropic-substrate.rs`
**Lines**: 24, 642, 820-825
```rust
use std::sync::atomic::{AtomicU64, Ordering};
// Line 642
next_agent_id: AtomicU64,
// Lines 820-825
fn pseudo_random_f64() -> f64 {
static SEED: AtomicU64 = AtomicU64::new(42);
let s = SEED.fetch_add(1, Ordering::Relaxed);
let x = s.wrapping_mul(0x5DEECE66D).wrapping_add(0xB);
((x >> 16) & 0xFFFF) as f64 / 65536.0
}
```
**CONCERNS**:
1. **Global Mutable State**: `pseudo_random_f64()` uses a static AtomicU64, making it thread-safe but creating hidden global state.
2. **Ordering Choice**: `Ordering::Relaxed` is used for ID generation. For ID uniqueness, this is sufficient, but documentation should clarify.
### 7.2 No Send/Sync Markers
**Issue**: None of the WASM types explicitly implement `Send` or `Sync`.
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
For async contexts, these types may need:
```rust
// Safe because internal state is not shared
unsafe impl Send for WasmCoherence {}
unsafe impl Sync for WasmCoherence {}
```
**RECOMMENDATION**: Document thread safety guarantees for each type.
### 7.3 Interior Mutability Patterns
**File**: `/workspaces/ruvector/examples/delta-behavior/applications/11-extropic-substrate.rs`
**Line**: 629-646
```rust
pub struct ExtropicSubstrate {
agents: HashMap<u64, MemoryAgent>,
coherence: f64,
spike_bus: SpikeBus,
tick: u64,
next_agent_id: AtomicU64,
config: SubstrateConfig,
}
```
**ISSUE**: `ExtropicSubstrate` mixes atomic (`next_agent_id`) with non-atomic fields. If used across threads, this would require external synchronization.
### 7.4 WASM Single-Threaded Context
**MITIGATING FACTOR**: WASM currently runs single-threaded in most environments, reducing thread safety concerns for the WASM module. However, the native Rust types in `/workspaces/ruvector/examples/delta-behavior/applications/` may be used in multi-threaded contexts.
---
## 8. Additional Findings
### 8.1 Potential Division by Zero
**File**: `/workspaces/ruvector/examples/delta-behavior/src/lib.rs`
**Line**: 679
```rust
let instability_factor = (1.0_f64 / predicted.value().max(0.1))
.powf(self.config.energy.instability_exponent);
```
**PASS**: Protected by `.max(0.1)`.
### 8.2 Float Comparison
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
**Line**: 1094
```rust
if self.circuit_breaker == WasmCircuitBreakerState::Halted {
```
**PASS**: Comparing enums, not floats.
**File**: `/workspaces/ruvector/examples/delta-behavior/tests/wasm_bindings.rs`
**Lines**: 11, 28, etc.
```rust
assert!((coherence.value() - 0.75).abs() < 0.001);
```
**PASS**: Uses epsilon comparison for floats.
### 8.3 Unused Code
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
**Line**: 1538
```rust
fn find_coherent_alternative(&self, _agent_idx: usize) -> Option<String> {
// Return a simple "move toward centroid" as alternative
Some("move_to_centroid".to_string())
}
```
**NOTE**: Parameter `_agent_idx` is unused. Either use it or document why it's needed for future implementation.
### 8.4 Magic Numbers
**File**: `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs`
| Line | Magic Number | Suggestion |
|------|--------------|------------|
| 386 | `0..50` (binary search iterations) | `const MAX_SEARCH_ITERATIONS: usize = 50` |
| 803 | `distance > 100.0` | `const MAX_TELEPORT_DISTANCE: f64 = 100.0` |
| 1276-1304 | Time thresholds (300.0, 600.0, etc.) | Named constants |
---
## 9. Recommendations Summary
### Critical (Must Fix)
1. **Add bounds to unbounded Vecs** in modification_history, goal history, and entity lists
2. **Replace unwrap() calls** in DeltaConfig constructors with safe alternatives
3. **Add edge case tests** for zero coherence, max coherence, and empty collections
### Important (Should Fix)
4. **Standardize coherence access patterns** across all WASM types
5. **Fix typo**: `WasmHomeostasticOrganism` -> `WasmHomeostaticOrganism`
6. **Document thread safety** guarantees for native types
7. **Add consistent status() return types** (JSON for WASM, formatted for native)
### Minor (Nice to Have)
8. **Extract magic numbers** to named constants
9. **Document the unused parameter** in `find_coherent_alternative`
10. **Add missing field-level documentation** for internal structs
11. **Rename `drop_from()` method** for clarity
---
## 10. Files Reviewed
| File | Lines | Status |
|------|-------|--------|
| `/workspaces/ruvector/examples/delta-behavior/src/lib.rs` | 819 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/src/wasm.rs` | 2005 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/src/applications/mod.rs` | 104 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/applications/10-pre-agi-containment.rs` | 676 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/applications/11-extropic-substrate.rs` | 973 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/tests/wasm_bindings.rs` | 167 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/Cargo.toml` | 171 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/adr/ADR-000-DELTA-BEHAVIOR-DEFINITION.md` | 272 | Reviewed |
| `/workspaces/ruvector/examples/delta-behavior/adr/ADR-001-COHERENCE-BOUNDS.md` | 251 | Reviewed |
---
## Conclusion
The delta-behavior library demonstrates solid mathematical foundations and good alignment with the ADR specifications. The codebase is well-documented at the module level and follows Rust idioms in most places.
**Primary Concerns**:
1. Memory growth in long-running applications
2. Error handling patterns with `unwrap()`
3. Missing edge case test coverage
**Strengths**:
1. Excellent module-level documentation
2. Strong alignment with ADR specifications
3. Good separation between native and WASM implementations
4. Proper use of Result types for user-facing APIs
The implementation is suitable for experimental and development use. Before production deployment, address the critical issues identified in this review.
---
*Review completed by Code Review Agent*
*Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>*

951
examples/delta-behavior/docs/SECURITY-AUDIT.md Normal file
View File

@@ -0,0 +1,951 @@
# Security Audit Report: Delta-Behavior Implementations
**Audit Date:** 2026-01-28
**Auditor:** V3 Security Architect
**Scope:** `/workspaces/ruvector/examples/delta-behavior/`
**Classification:** Security Assessment
---
## Executive Summary
This security audit analyzes the delta-behavior implementations for potential vulnerabilities including unsafe code, denial of service vectors, integer overflow, memory safety issues, race conditions, and containment bypass risks. The codebase demonstrates generally sound security practices with several areas requiring attention.
**Overall Risk Assessment:** MEDIUM
| Severity | Count |
|----------|-------|
| Critical | 1 |
| High | 4 |
| Medium | 8 |
| Low | 6 |
| Informational | 5 |
---
## Table of Contents
1. [Core Library (lib.rs)](#1-core-library-librs)
2. [Application 01: Self-Limiting Reasoning](#2-application-01-self-limiting-reasoning)
3. [Application 02: Computational Event Horizon](#3-application-02-computational-event-horizon)
4. [Application 03: Artificial Homeostasis](#4-application-03-artificial-homeostasis)
5. [Application 04: Self-Stabilizing World Model](#5-application-04-self-stabilizing-world-model)
6. [Application 05: Coherence-Bounded Creativity](#6-application-05-coherence-bounded-creativity)
7. [Application 06: Anti-Cascade Financial](#7-application-06-anti-cascade-financial)
8. [Application 07: Graceful Aging](#8-application-07-graceful-aging)
9. [Application 08: Swarm Intelligence](#9-application-08-swarm-intelligence)
10. [Application 09: Graceful Shutdown](#10-application-09-graceful-shutdown)
11. [Application 10: Pre-AGI Containment](#11-application-10-pre-agi-containment)
12. [Cross-Cutting Concerns](#12-cross-cutting-concerns)
13. [Hardening Recommendations](#13-hardening-recommendations)
---
## 1. Core Library (lib.rs)
**File:** `/workspaces/ruvector/examples/delta-behavior/src/lib.rs`
### 1.1 Findings
#### MEDIUM: Potential Panic in Coherence::new()
**Location:** Lines 306-311
```rust
pub fn new(value: f64) -> Result<Self, &'static str> {
if value < 0.0 || value > 1.0 {
Err("Coherence out of range")
} else {
Ok(Self(value))
}
}
```
**Issue:** While this returns a Result, the test code uses `.unwrap()` on line 257:
```rust
Coherence::new((self.coherence.value() - loss).max(0.0)).unwrap()
```
**Risk:** If floating-point edge cases (NaN, infinity) occur, the `.max(0.0)` may not protect against invalid values.
**Recommendation:**
```rust
pub fn new(value: f64) -> Result<Self, &'static str> {
if !value.is_finite() || value < 0.0 || value > 1.0 {
Err("Coherence out of range or invalid")
} else {
Ok(Self(value))
}
}
```
#### LOW: Missing Documentation on Thread Safety
**Location:** `enforcement::SimpleEnforcer` (lines 362-409)
**Issue:** The enforcer maintains mutable state (`energy_budget`) but there are no synchronization primitives. In a multi-threaded context, this could lead to race conditions.
**Recommendation:** Document thread-safety requirements or wrap in `Mutex<SimpleEnforcer>`.
---
## 2. Application 01: Self-Limiting Reasoning
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/01-self-limiting-reasoning.rs`
### 2.1 Findings
#### MEDIUM: Potential Infinite Loop in reason()
**Location:** Lines 142-173
```rust
loop {
if ctx.depth >= ctx.max_depth {
return ReasoningResult::Collapsed { ... };
}
if ctx.coherence < 0.2 {
return ReasoningResult::Collapsed { ... };
}
ctx.depth += 1;
ctx.coherence *= 0.95;
// ...
}
```
**Issue:** While coherence degradation provides an eventual exit, if `reasoner` function modifies `ctx.coherence` to increase it, this could create an infinite loop.
**Risk:** Denial of Service
**Recommendation:** Add a hard iteration limit:
```rust
const MAX_ITERATIONS: usize = 10000;
for _ in 0..MAX_ITERATIONS {
// existing loop body
}
ReasoningResult::Collapsed { depth_reached: ctx.depth, reason: CollapseReason::IterationLimitReached }
```
#### HIGH: Integer Overflow in Atomic Operations
**Location:** Lines 216-222
```rust
fn f64_to_u64(f: f64) -> u64 {
(f * 1_000_000_000.0) as u64
}
fn u64_to_f64(u: u64) -> f64 {
(u as f64) / 1_000_000_000.0
}
```
**Issue:** For values > 18.446744073 (u64::MAX / 1_000_000_000), this will overflow. While coherence is bounded 0.0-1.0, the conversion functions are public and could be misused.
**Risk:** Incorrect state representation leading to bypass of coherence checks.
**Recommendation:**
```rust
fn f64_to_u64(f: f64) -> u64 {
let clamped = f.clamp(0.0, 1.0);
(clamped * 1_000_000_000.0) as u64
}
```
#### LOW: Race Condition in update_coherence()
**Location:** Lines 176-180
```rust
pub fn update_coherence(&self, delta: f64) {
let current = self.coherence();
let new = (current + delta).clamp(0.0, 1.0);
self.coherence.store(f64_to_u64(new), Ordering::Release);
}
```
**Issue:** This is a classic read-modify-write race condition. Between `load` and `store`, another thread could modify the value.
**Recommendation:** Use `compare_exchange` loop or `fetch_update`:
```rust
pub fn update_coherence(&self, delta: f64) {
loop {
let current = self.coherence.load(Ordering::Acquire);
let current_f64 = u64_to_f64(current);
let new = (current_f64 + delta).clamp(0.0, 1.0);
let new_u64 = f64_to_u64(new);
if self.coherence.compare_exchange(current, new_u64,
Ordering::AcqRel, Ordering::Acquire).is_ok() {
break;
}
}
}
```
---
## 3. Application 02: Computational Event Horizon
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/02-computational-event-horizon.rs`
### 3.1 Findings
#### HIGH: Resource Exhaustion in Binary Search
**Location:** Lines 130-147
```rust
for _ in 0..50 { // 50 iterations for precision
let mid = (low + high) / 2.0;
let interpolated: Vec<f64> = self.current_position.iter()
.zip(target)
.map(|(a, b)| a + mid * (b - a))
.collect();
// ...
}
```
**Issue:** Creates a new Vec allocation on every iteration (50 allocations per move). For high-dimensional state spaces, this could cause memory pressure.
**Risk:** Memory exhaustion DoS
**Recommendation:** Pre-allocate buffer:
```rust
let mut interpolated = vec![0.0; self.current_position.len()];
for _ in 0..50 {
for (i, (a, b)) in self.current_position.iter().zip(target).enumerate() {
interpolated[i] = a + mid * (b - a);
}
// ...
}
```
#### MEDIUM: Division by Zero Potential
**Location:** Lines 100-101
```rust
let horizon_factor = E.powf(
self.steepness * proximity_to_horizon / (1.0 - proximity_to_horizon)
);
```
**Issue:** When `proximity_to_horizon` equals exactly 1.0, this divides by zero.
**Note:** The code checks `if proximity_to_horizon >= 1.0` before this, so this is protected. However, floating-point precision could create edge cases.
**Recommendation:** Add epsilon guard:
```rust
let denominator = (1.0 - proximity_to_horizon).max(f64::EPSILON);
```
#### LOW: Unbounded Vec Growth
**Location:** Line 167 (`improvements` vector)
```rust
let mut improvements = Vec::new();
```
**Issue:** No capacity limit on improvements vector.
**Recommendation:** Use `Vec::with_capacity(max_iterations)` or bounded collection.
---
## 4. Application 03: Artificial Homeostasis
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/03-artificial-homeostasis.rs`
### 4.1 Findings
#### CRITICAL: Unsafe Static Mutable Variable
**Location:** Lines 399-406
```rust
fn rand_f64() -> f64 {
// Simple LCG for reproducibility in tests
static mut SEED: u64 = 12345;
unsafe {
SEED = SEED.wrapping_mul(1103515245).wrapping_add(12345);
((SEED >> 16) & 0x7fff) as f64 / 32768.0
}
}
```
**Issue:** This is undefined behavior in Rust. Multiple threads accessing `SEED` simultaneously causes a data race, which is UB even with `unsafe`.
**Risk:** Undefined behavior, potential memory corruption, unpredictable system state.
**Recommendation:** Use thread-safe RNG:
```rust
use std::sync::atomic::{AtomicU64, Ordering};
static SEED: AtomicU64 = AtomicU64::new(12345);
fn rand_f64() -> f64 {
let mut current = SEED.load(Ordering::Relaxed);
loop {
let next = current.wrapping_mul(1103515245).wrapping_add(12345);
match SEED.compare_exchange_weak(current, next, Ordering::Relaxed, Ordering::Relaxed) {
Ok(_) => return ((next >> 16) & 0x7fff) as f64 / 32768.0,
Err(c) => current = c,
}
}
}
```
Or use `rand` crate with `thread_rng()`.
#### MEDIUM: Panic in Memory Sorting
**Location:** Lines 212-213
```rust
self.memory.sort_by(|a, b| b.importance.partial_cmp(&a.importance).unwrap());
```
**Issue:** `partial_cmp` returns `None` for NaN values. The `.unwrap()` will panic.
**Recommendation:**
```rust
self.memory.sort_by(|a, b| {
b.importance.partial_cmp(&a.importance).unwrap_or(std::cmp::Ordering::Equal)
});
```
#### LOW: Integer Overflow in ID Generation
**Location:** Lines 288-289
```rust
let offspring_id = self.id * 1000 + self.age;
```
**Issue:** For organisms with id > u64::MAX/1000, this will overflow.
**Recommendation:** Use wrapping arithmetic or a proper ID generator:
```rust
let offspring_id = self.id.wrapping_mul(1000).wrapping_add(self.age);
```
---
## 5. Application 04: Self-Stabilizing World Model
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/04-self-stabilizing-world-model.rs`
### 5.1 Findings
#### MEDIUM: Unbounded History Growth
**Location:** Lines 232-237
```rust
self.coherence_history.push(self.coherence);
// Trim history
if self.coherence_history.len() > 100 {
self.coherence_history.remove(0);
}
```
**Issue:** `remove(0)` on a Vec is O(n) - inefficient for bounded buffers.
**Recommendation:** Use `VecDeque` for O(1) operations:
```rust
use std::collections::VecDeque;
// In struct:
coherence_history: VecDeque<f64>,
// In code:
self.coherence_history.push_back(self.coherence);
if self.coherence_history.len() > 100 {
self.coherence_history.pop_front();
}
```
#### LOW: Unbounded rejected_updates Vector
**Location:** Lines 187, 206, 218-224
**Issue:** No limit on rejected updates storage - potential memory exhaustion under attack.
**Recommendation:** Add capacity limit or use ring buffer.
---
## 6. Application 05: Coherence-Bounded Creativity
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/05-coherence-bounded-creativity.rs`
### 6.1 Findings
#### HIGH: Unsafe Static Mutable in pseudo_random()
**Location:** Lines 372-378
```rust
fn pseudo_random() -> usize {
static mut SEED: usize = 42;
unsafe {
SEED = SEED.wrapping_mul(1103515245).wrapping_add(12345);
(SEED >> 16) & 0x7fff
}
}
```
**Issue:** Same UB issue as Application 03.
**Risk:** Data race UB
**Recommendation:** Same fix as Application 03 - use `AtomicUsize`.
#### MEDIUM: Integer Overflow in Musical Variation
**Location:** Lines 258-259
```rust
let delta = ((pseudo_random() % 7) as i8 - 3) * (magnitude * 2.0) as i8;
new_notes[idx] = (new_notes[idx] as i8 + delta).clamp(36, 96) as u8;
```
**Issue:** If `magnitude` is large, `(magnitude * 2.0) as i8` will overflow/truncate.
**Recommendation:**
```rust
let delta_f64 = ((pseudo_random() % 7) as f64 - 3.0) * magnitude * 2.0;
let delta = delta_f64.clamp(-127.0, 127.0) as i8;
```
---
## 7. Application 06: Anti-Cascade Financial
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/06-anti-cascade-financial.rs`
### 7.1 Findings
#### MEDIUM: Position Index Validation
**Location:** Lines 333-344
```rust
TransactionType::ClosePosition { position_id } => {
if *position_id < self.positions.len() {
let pos = self.positions.remove(*position_id);
// ...
}
}
```
**Issue:** After removing a position, all subsequent indices shift. If multiple ClosePosition transactions reference later indices, they become invalid.
**Recommendation:** Use stable identifiers instead of indices, or process in reverse order:
```rust
// Use HashMap<PositionId, Position> instead of Vec<Position>
```
#### MEDIUM: Margin Call Index Shifting
**Location:** Lines 357-370
```rust
TransactionType::MarginCall { participant } => {
let to_close: Vec<usize> = self.positions.iter()
.enumerate()
.filter(|(_, p)| &p.holder == participant && p.leverage > 5.0)
.map(|(i, _)| i)
.collect();
for (offset, idx) in to_close.iter().enumerate() {
if idx - offset < self.positions.len() {
self.positions.remove(idx - offset);
}
}
}
```
**Issue:** The `idx - offset` pattern is correct but fragile. An underflow would occur if `offset > idx`, though this shouldn't happen with sequential indices.
**Recommendation:** Use `saturating_sub` for safety:
```rust
if let Some(adjusted_idx) = idx.checked_sub(offset) {
if adjusted_idx < self.positions.len() {
self.positions.remove(adjusted_idx);
}
}
```
---
## 8. Application 07: Graceful Aging
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/07-graceful-aging.rs`
### 8.1 Findings
#### LOW: Clone in Loop
**Location:** Line 216
```rust
for threshold in &self.age_thresholds.clone() {
```
**Issue:** Unnecessary clone - creates allocation overhead.
**Recommendation:**
```rust
let thresholds = self.age_thresholds.clone();
for threshold in &thresholds {
```
Or restructure to avoid the borrow conflict.
#### INFO: Time-Based Testing Fragility
**Location:** Multiple tests using `Instant::now()`
**Issue:** Tests using real time may be flaky on slow/overloaded systems.
**Recommendation:** Use mock time for deterministic testing.
---
## 9. Application 08: Swarm Intelligence
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/08-swarm-intelligence.rs`
### 9.1 Findings
#### HIGH: Race Condition in Shared Swarm State
**Location:** Throughout file
**Issue:** The `CoherentSwarm` struct contains mutable state (`agents`, `coherence`, `history`) but provides no synchronization. In a concurrent swarm simulation, multiple agent updates could race.
**Risk:** Data corruption, incorrect coherence calculations, missed updates.
**Recommendation:** For concurrent use:
```rust
use std::sync::{Arc, RwLock};
pub struct CoherentSwarm {
agents: RwLock<HashMap<String, SwarmAgent>>,
coherence: AtomicF64, // Or use parking_lot's atomic float
// ...
}
```
Or document that the struct is not thread-safe and must be externally synchronized.
#### MEDIUM: O(n^2) Neighbor Calculation
**Location:** Lines 297-317
```rust
fn update_neighbors(&mut self) {
let positions: Vec<(String, (f64, f64))> = self.agents
.iter()
.map(|(id, a)| (id.clone(), a.position))
.collect();
for (id, agent) in self.agents.iter_mut() {
agent.neighbor_count = positions.iter()
.filter(|(other_id, pos)| { ... })
.count();
}
}
```
**Issue:** For n agents, this is O(n^2). With large swarms, this becomes a performance bottleneck.
**Risk:** DoS via large swarm creation
**Recommendation:** Use spatial data structures (quadtree, k-d tree) for O(n log n) neighbor queries, or limit swarm size:
```rust
const MAX_AGENTS: usize = 1000;
pub fn add_agent(&mut self, id: &str, position: (f64, f64)) -> Result<(), &'static str> {
if self.agents.len() >= MAX_AGENTS {
return Err("Swarm at capacity");
}
// ...
}
```
#### MEDIUM: Clone Heavy in predict_coherence()
**Location:** Lines 320-358
```rust
fn predict_coherence(&self, agent_id: &str, action: &SwarmAction) -> f64 {
let mut agents_copy = self.agents.clone();
// ...
}
```
**Issue:** Full clone of agents HashMap for every prediction. For large swarms with frequent predictions, this causes significant allocation pressure.
**Recommendation:** Consider copy-on-write or differential state tracking.
---
## 10. Application 09: Graceful Shutdown
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/09-graceful-shutdown.rs`
### 10.1 Findings
#### LOW: Potential Hook Execution Order Non-Determinism
**Location:** Lines 261-268
```rust
self.shutdown_hooks.sort_by(|a, b| b.priority().cmp(&a.priority()));
for hook in &self.shutdown_hooks {
println!("[SHUTDOWN] Executing hook: {}", hook.name());
if let Err(e) = hook.execute() {
println!("[SHUTDOWN] Hook failed: {} - {}", hook.name(), e);
}
}
```
**Issue:** Hooks with equal priority have undefined order due to unstable sort.
**Recommendation:** Use `sort_by_key` with secondary sort on name, or use stable sort:
```rust
self.shutdown_hooks.sort_by(|a, b| {
match b.priority().cmp(&a.priority()) {
std::cmp::Ordering::Equal => a.name().cmp(b.name()),
other => other,
}
});
```
#### INFO: Hook Errors Silently Logged
**Location:** Lines 265-267
**Issue:** Failed shutdown hooks only print to stdout; no structured error handling.
**Recommendation:** Return errors from `progress_shutdown()` or maintain failed hook list.
---
## 11. Application 10: Pre-AGI Containment
**File:** `/workspaces/ruvector/examples/delta-behavior/applications/10-pre-agi-containment.rs`
### 11.1 Security-Critical Findings
This module is the most security-critical as it implements containment for bounded intelligence growth.
#### HIGH: Invariant Check Bypass via Rollback Timing
**Location:** Lines 346-357
```rust
// Final invariant check
let violations = self.check_invariants();
if !violations.is_empty() {
// Rollback
self.capabilities.insert(domain.clone(), current_level);
self.coherence += actual_cost;
self.intelligence = self.calculate_intelligence();
return GrowthResult::Blocked { ... };
}
```
**Issue:** The rollback restores `intelligence` by recalculation, but if `calculate_intelligence()` has side effects or depends on other mutable state, the rollback may be incomplete.
**Risk:** Partial state corruption allowing containment bypass.
**Recommendation:** Use a transaction pattern:
```rust
struct SubstrateSnapshot {
capabilities: HashMap<CapabilityDomain, f64>,
coherence: f64,
intelligence: f64,
}
impl ContainmentSubstrate {
fn snapshot(&self) -> SubstrateSnapshot { ... }
fn restore(&mut self, snapshot: SubstrateSnapshot) { ... }
}
```
#### MEDIUM: Function Pointer in SafetyInvariant
**Location:** Lines 86-89
```rust
pub struct SafetyInvariant {
pub name: String,
pub check: fn(&ContainmentSubstrate) -> bool,
pub priority: u8,
}
```
**Issue:** Using raw function pointers allows potential injection of malicious check functions if the invariant list is modifiable externally.
**Recommendation:** Make invariants immutable after construction or use a sealed trait pattern:
```rust
pub struct SafetyInvariant {
name: String, // Remove pub
check: fn(&ContainmentSubstrate) -> bool, // Remove pub
priority: u8, // Remove pub
}
impl SafetyInvariant {
pub(crate) fn new(name: &str, check: fn(&ContainmentSubstrate) -> bool, priority: u8) -> Self {
Self { name: name.to_string(), check, priority }
}
}
```
#### MEDIUM: Coherence Budget Manipulation
**Location:** Lines 399-404
```rust
fn reverse_coherence_cost(&self, domain: &CapabilityDomain, max_cost: f64) -> f64 {
// ...
max_cost / divisor
}
```
**Issue:** If `divisor` approaches zero (though current code prevents this), division could produce infinity, allowing unbounded growth.
**Recommendation:** Add guard:
```rust
fn reverse_coherence_cost(&self, domain: &CapabilityDomain, max_cost: f64) -> f64 {
// ...
if divisor < f64::EPSILON {
return 0.0;
}
max_cost / divisor
}
```
#### INFO: No Rate Limiting on Growth Attempts
**Location:** `attempt_growth()` method
**Issue:** No limit on how frequently growth can be attempted. Rapid-fire growth attempts could stress the system.
**Recommendation:** Add cooldown or rate limiting:
```rust
last_growth_attempt: Option<Instant>,
min_growth_interval: Duration,
```
---
## 12. Cross-Cutting Concerns
### 12.1 Floating-Point Precision
**Affected:** All modules using f64 for coherence calculations
**Issue:** Accumulated floating-point errors in coherence calculations could cause:
- Coherence values drifting outside [0.0, 1.0]
- Comparison edge cases (coherence == threshold)
- Non-deterministic behavior across platforms
**Recommendation:**
1. Use `clamp(0.0, 1.0)` after every coherence calculation
2. Consider using fixed-point arithmetic for critical thresholds
3. Use epsilon comparisons: `(a - b).abs() < EPSILON`
### 12.2 Error Handling Patterns
**Affected:** All modules
**Issue:** Mixed use of `Result`, `Option`, and panics. Inconsistent error handling makes security review difficult.
**Recommendation:** Establish consistent error handling:
```rust
#[derive(Debug, thiserror::Error)]
pub enum DeltaError {
#[error("Coherence out of bounds: {0}")]
CoherenceOutOfBounds(f64),
#[error("Transition blocked: {0}")]
TransitionBlocked(String),
// ...
}
```
### 12.3 Denial of Service Vectors
| Module | DoS Vector | Mitigation |
|--------|-----------|------------|
| 01-reasoning | Infinite loop | Add iteration limit |
| 02-horizon | Memory allocation | Pre-allocate buffers |
| 04-world-model | Unbounded history | Use bounded VecDeque |
| 08-swarm | O(n^2) neighbors | Use spatial index |
| All | Large inputs | Add input validation |
### 12.4 Missing Input Validation
**Affected:** Most public APIs
**Issue:** Functions accepting `f64` parameters don't validate for NaN, infinity, or reasonable ranges.
**Recommendation:** Create validation wrapper:
```rust
fn validate_f64(value: f64, name: &str, min: f64, max: f64) -> Result<f64, DeltaError> {
if !value.is_finite() {
return Err(DeltaError::InvalidInput(format!("{} is not finite", name)));
}
if value < min || value > max {
return Err(DeltaError::OutOfRange(format!("{} must be in [{}, {}]", name, min, max)));
}
Ok(value)
}
```
---
## 13. Hardening Recommendations
### 13.1 Immediate Actions (Critical/High)
1. **Fix Unsafe Static Mutables**
- Files: `03-artificial-homeostasis.rs`, `05-coherence-bounded-creativity.rs`
- Action: Replace `static mut` with `AtomicU64`/`AtomicUsize`
- Timeline: Immediate
2. **Add Iteration Limits**
- Files: `01-self-limiting-reasoning.rs`
- Action: Add hard caps on loop iterations
- Timeline: Within 1 week
3. **Thread Safety for Swarm**
- Files: `08-swarm-intelligence.rs`
- Action: Add synchronization or document single-threaded requirement
- Timeline: Within 2 weeks
4. **Atomic Update Coherence**
- Files: `01-self-limiting-reasoning.rs`
- Action: Use compare-exchange for coherence updates
- Timeline: Within 1 week
### 13.2 Short-Term Actions (Medium)
5. **Replace Vec with VecDeque for Bounded History**
- Files: `04-self-stabilizing-world-model.rs`, `06-anti-cascade-financial.rs`
- Timeline: Within 1 month
6. **Add Floating-Point Validation**
- Files: All
- Action: Validate NaN/Infinity on all f64 inputs
- Timeline: Within 1 month
7. **Fix Integer Overflow Potential**
- Files: `01-self-limiting-reasoning.rs`, `03-artificial-homeostasis.rs`, `05-coherence-bounded-creativity.rs`
- Action: Use wrapping/saturating arithmetic or proper bounds checks
- Timeline: Within 1 month
8. **Improve Containment Rollback**
- Files: `10-pre-agi-containment.rs`
- Action: Implement transaction/snapshot pattern
- Timeline: Within 2 weeks
### 13.3 Long-Term Actions (Low/Informational)
9. **Consistent Error Handling**
- Action: Adopt `thiserror` crate and standardize error types
- Timeline: Within 3 months
10. **Performance Optimization**
- Action: Implement spatial indexing for swarm neighbor calculations
- Timeline: Within 3 months
11. **Test Coverage for Edge Cases**
- Action: Add property-based testing for floating-point edge cases
- Timeline: Within 3 months
12. **Security Testing Suite**
- Action: Implement fuzz testing for all public APIs
- Timeline: Within 6 months
---
## Appendix A: Security Test Cases
The following test cases should be added to validate security properties:
```rust
#[cfg(test)]
mod security_tests {
use super::*;
#[test]
fn test_nan_coherence_rejected() {
let result = Coherence::new(f64::NAN);
assert!(result.is_err());
}
#[test]
fn test_infinity_coherence_rejected() {
let result = Coherence::new(f64::INFINITY);
assert!(result.is_err());
}
#[test]
fn test_negative_infinity_coherence_rejected() {
let result = Coherence::new(f64::NEG_INFINITY);
assert!(result.is_err());
}
#[test]
fn test_containment_invariants_always_hold() {
let mut substrate = ContainmentSubstrate::new();
// Attempt aggressive growth
for _ in 0..10000 {
substrate.attempt_growth(CapabilityDomain::SelfModification, 100.0);
substrate.attempt_growth(CapabilityDomain::Agency, 100.0);
// Invariants must always hold
assert!(substrate.coherence >= substrate.min_coherence);
assert!(substrate.intelligence <= substrate.intelligence_ceiling);
}
}
#[test]
fn test_swarm_coherence_cannot_go_negative() {
let mut swarm = CoherentSwarm::new(0.5);
for i in 0..100 {
swarm.add_agent(&format!("agent_{}", i), (i as f64 * 100.0, 0.0));
}
// Even with dispersed agents, coherence must be >= 0
assert!(swarm.coherence() >= 0.0);
}
}
```
---
## Appendix B: Secure Coding Checklist
- [ ] No `unsafe` blocks without security review
- [ ] No `static mut` variables
- [ ] All `unwrap()` calls audited for panic safety
- [ ] All loops have termination guarantees
- [ ] All floating-point operations handle NaN/Infinity
- [ ] All public APIs have input validation
- [ ] Thread safety documented or enforced
- [ ] Memory allocations are bounded
- [ ] Error handling is consistent
- [ ] Security-critical invariants are enforced atomically
---
**Report Prepared By:** V3 Security Architect
**Review Status:** Initial Audit Complete
**Next Review:** After remediation of Critical/High findings

225
examples/delta-behavior/examples/demo.rs Normal file
View File

@@ -0,0 +1,225 @@
//! # Delta-Behavior Demo
//!
//! This example demonstrates the core concepts of delta-behavior:
//! - Coherence as a measure of system stability
//! - Transitions that are gated by coherence bounds
//! - Enforcement that blocks destabilizing operations
//! - Attractor guidance toward stable states
//!
//! Run with: `cargo run --example demo`
use delta_behavior::{
Coherence, CoherenceBounds, DeltaConfig, DeltaEnforcer, DeltaSystem,
EnforcementResult,
};
fn main() {
println!("=== Delta-Behavior Demo ===\n");
demo_coherence();
demo_enforcement();
demo_delta_system();
demo_attractor_guidance();
println!("\n=== Demo Complete ===");
}
/// Demonstrate coherence measurement and bounds.
fn demo_coherence() {
println!("--- 1. Coherence Basics ---\n");
// Create coherence values
let high = Coherence::new(0.9).unwrap();
let medium = Coherence::new(0.5).unwrap();
let low = Coherence::new(0.2).unwrap();
println!("High coherence: {:.2}", high.value());
println!("Medium coherence: {:.2}", medium.value());
println!("Low coherence: {:.2}", low.value());
// Check bounds
let bounds = CoherenceBounds::default();
println!("\nDefault bounds:");
println!(" Minimum: {:.2}", bounds.min_coherence.value());
println!(" Throttle: {:.2}", bounds.throttle_threshold.value());
println!(" Target: {:.2}", bounds.target_coherence.value());
// Check against bounds
println!("\nCoherence above minimum?");
println!(" High: {}", high.value() >= bounds.min_coherence.value());
println!(" Medium: {}", medium.value() >= bounds.min_coherence.value());
println!(" Low: {}", low.value() >= bounds.min_coherence.value());
println!();
}
/// Demonstrate enforcement of coherence bounds.
fn demo_enforcement() {
println!("--- 2. Enforcement ---\n");
let config = DeltaConfig::default();
let mut enforcer = DeltaEnforcer::new(config);
// Try various transitions
let test_cases = [
(0.8, 0.75, "small drop"),
(0.8, 0.65, "medium drop"),
(0.8, 0.45, "large drop"),
(0.8, 0.25, "destabilizing drop"),
(0.4, 0.35, "below throttle"),
];
println!("Testing transitions (current -> predicted):\n");
for (current, predicted, description) in test_cases {
let current_c = Coherence::new(current).unwrap();
let predicted_c = Coherence::new(predicted).unwrap();
let result = enforcer.check(current_c, predicted_c);
let status = match &result {
EnforcementResult::Allowed => "ALLOWED",
EnforcementResult::Blocked(_) => "BLOCKED",
EnforcementResult::Throttled(_) => "THROTTLED",
};
println!(
" {:.2} -> {:.2} ({:20}): {}",
current, predicted, description, status
);
// Tick to regenerate energy
enforcer.tick();
}
println!();
}
/// Demonstrate a system implementing DeltaSystem.
fn demo_delta_system() {
println!("--- 3. Delta System ---\n");
let mut system = SimpleSystem::new();
println!("Initial state: {:.2}, coherence: {:.3}", system.state(), system.coherence().value());
println!("In attractor: {}\n", system.in_attractor());
// Apply a series of transitions
let transitions = [0.5, 0.5, 1.0, 2.0, 5.0, 10.0];
for delta in transitions {
let predicted = system.predict_coherence(&delta);
println!("Attempting delta={:.1}:", delta);
println!(" Predicted coherence: {:.3}", predicted.value());
match system.step(&delta) {
Ok(()) => {
println!(" Result: SUCCESS");
println!(" New state: {:.2}, coherence: {:.3}", system.state(), system.coherence().value());
}
Err(e) => {
println!(" Result: BLOCKED - {}", e);
}
}
println!();
}
}
/// Demonstrate attractor guidance.
fn demo_attractor_guidance() {
println!("--- 4. Attractor Guidance ---\n");
use delta_behavior::attractor::GuidanceForce;
// Current position far from attractor at origin
let position = [5.0, 3.0];
let attractor = [0.0, 0.0];
let force = GuidanceForce::toward(&position, &attractor, 1.0);
println!("Position: ({:.1}, {:.1})", position[0], position[1]);
println!("Attractor: ({:.1}, {:.1})", attractor[0], attractor[1]);
println!("Guidance force:");
println!(" Direction: ({:.3}, {:.3})", force.direction[0], force.direction[1]);
println!(" Magnitude: {:.3}", force.magnitude);
// Simulate movement toward attractor
println!("\nSimulating movement toward attractor:");
let mut pos = position;
for step in 0..5 {
let f = GuidanceForce::toward(&pos, &attractor, 0.3);
pos[0] += f.direction[0] * f.magnitude;
pos[1] += f.direction[1] * f.magnitude;
let dist = (pos[0].powi(2) + pos[1].powi(2)).sqrt();
println!(
" Step {}: ({:.2}, {:.2}), distance to attractor: {:.2}",
step + 1, pos[0], pos[1], dist
);
}
println!();
}
// ============================================================================
// Simple System Implementation
// ============================================================================
/// A simple system demonstrating delta-behavior.
struct SimpleSystem {
state: f64,
coherence: Coherence,
}
impl SimpleSystem {
fn new() -> Self {
Self {
state: 0.0,
coherence: Coherence::maximum(),
}
}
}
impl DeltaSystem for SimpleSystem {
type State = f64;
type Transition = f64;
type Error = &'static str;
fn coherence(&self) -> Coherence {
self.coherence
}
fn step(&mut self, delta: &f64) -> Result<(), Self::Error> {
// Predict the outcome
let predicted = self.predict_coherence(delta);
// Enforce coherence bound
if predicted.value() < 0.3 {
return Err("Would violate minimum coherence bound");
}
// Check for excessive drop
if self.coherence.value() - predicted.value() > 0.15 {
return Err("Transition too destabilizing");
}
// Apply the transition
self.state += delta;
self.coherence = predicted;
Ok(())
}
fn predict_coherence(&self, delta: &f64) -> Coherence {
// Larger deltas cause more coherence loss
// Models uncertainty accumulation
let impact = delta.abs() * 0.1;
Coherence::clamped(self.coherence.value() - impact)
}
fn state(&self) -> &f64 {
&self.state
}
fn in_attractor(&self) -> bool {
// System is "attracted" to the origin
self.state.abs() < 0.5
}
}

369
examples/delta-behavior/research/MATHEMATICAL-FOUNDATIONS.md Normal file
View File

@@ -0,0 +1,369 @@
# Mathematical Foundations for Δ-Behavior Systems
## Research Report: Formal Methods and Algebraic Foundations
**Author:** Research Agent
**Date:** 2026-01-28
**Codebase:** `/workspaces/ruvector`
---
## 1. ALGEBRAIC FOUNDATIONS
### 1.1 Delta Algebra: Group Structure
**Definition 1.1 (Delta Set).** Let **Δ** denote the set of all well-typed state transformations. A delta `δ : Δ` is a function `δ : S → S` where `S` is the state space.
**Definition 1.2 (Delta Group).** The tuple `(Δ, ∘, ε, ⁻¹)` forms a group where:
```
Closure: ∀ δ₁, δ₂ ∈ Δ: δ₁ ∘ δ₂ ∈ Δ
Identity: ∀ δ ∈ Δ: δ ∘ ε = δ = ε ∘ δ
Inverse: ∀ δ ∈ Δ: ∃ δ⁻¹: δ ∘ δ⁻¹ = ε
Associativity: ∀ δ₁, δ₂, δ₃: (δ₁ ∘ δ₂) ∘ δ₃ = δ₁ ∘ (δ₂ ∘ δ₃)
```
**Implementation Reference:** `/workspaces/ruvector/crates/cognitum-gate-kernel/src/delta.rs`
```rust
pub enum DeltaTag {
Nop = 0, // Identity element (ε)
EdgeAdd = 1, // Addition operation
EdgeRemove = 2, // Inverse of EdgeAdd
WeightUpdate = 3, // Modification
Observation = 4, // Evidence accumulation
BatchEnd = 5, // Composition boundary
Checkpoint = 6, // State marker
Reset = 7, // Global inverse
}
```
**Theorem 1.1 (Delta Closure).** For any two deltas `δ₁, δ₂ : Δ`, their composition `δ₁ ∘ δ₂` is well-defined and produces a valid delta.
*Proof:* The `Delta` struct is a 16-byte aligned union type with deterministic payload handling. The composition of two deltas produces a new delta with combined semantics, incremented sequence number, and merged payloads. The closure property follows from the bounded payload union ensuring all compositions remain within the structure. ∎
**Theorem 1.2 (Delta Identity).** `DeltaTag::Nop` serves as the identity element.
*Proof:* For any delta `δ`, composing with `nop()` leaves `δ` unchanged since `Nop` performs no state transformation. ∎
**Theorem 1.3 (Delta Inverses).** For each constructive delta, an inverse exists:
| Delta Type | Inverse |
|------------|---------|
| `EdgeAdd(s,t,w)` | `EdgeRemove(s,t)` |
| `EdgeRemove(s,t)` | `EdgeAdd(s,t,w_cached)` |
| `WeightUpdate(s,t,w_new)` | `WeightUpdate(s,t,w_old)` |
| `Observation(v,o)` | `Observation(v,-o)` |
---
### 1.2 Category Theory: Deltas as Morphisms
**Definition 1.3 (State Category).** Let **State** be a category where:
- **Objects:** State snapshots `Sᵢ`
- **Morphisms:** Deltas `δ : Sᵢ → Sⱼ`
- **Identity:** `id_S = Nop` for each state `S`
- **Composition:** Delta composition `δ₂ ∘ δ₁`
**Implementation Reference:** `/workspaces/ruvector/examples/prime-radiant/src/category/mod.rs`
```rust
pub trait Category: Send + Sync + Debug {
type Object: Clone + Debug + PartialEq;
type Morphism: Clone + Debug;
fn identity(&self, obj: &Self::Object) -> Option<Self::Morphism>;
fn compose(&self, f: &Self::Morphism, g: &Self::Morphism) -> Option<Self::Morphism>;
fn domain(&self, mor: &Self::Morphism) -> Self::Object;
fn codomain(&self, mor: &Self::Morphism) -> Self::Object;
}
```
**Theorem 1.4 (State is a Category).** The state-delta structure forms a well-defined category.
*Proof:* Category laws verified:
1. **Identity laws:** `id_B ∘ f = f = f ∘ id_A` follows from Nop semantics
2. **Associativity:** `(h ∘ g) ∘ f = h ∘ (g ∘ f)` from Theorem 1.1 ∎
**Definition 1.4 (Delta Functor).** A delta functor `F : State → State'` maps:
- States to states: `F(S) = S'`
- Deltas to deltas: `F(δ : S₁ → S₂) = δ' : F(S₁) → F(S₂)`
Preserving:
- Identity: `F(id_S) = id_{F(S)}`
- Composition: `F(g ∘ f) = F(g) ∘ F(f)`
**Theorem 1.5 (Natural Transformation for Delta Conversion).** Given functors `F, G : State → State'`, a natural transformation `η : F ⇒ G` provides delta conversion with coherence.
*Proof:* The naturality square commutes:
```
F(S₁) --F(δ)--> F(S₂)
| |
η_S₁ η_S₂
| |
v v
G(S₁) --G(δ)--> G(S₂)
```
∎
---
### 1.3 Lattice Theory: Delta Merging
**Definition 1.5 (Delta Partial Order).** Define `δ₁ ≤ δ₂` iff applying `δ₁` then some delta `δ'` yields the same result as `δ₂`:
```
δ₁ ≤ δ₂ ⟺ ∃ δ': δ₂ = δ' ∘ δ₁
```
**Definition 1.6 (Join-Semilattice for Delta Merging).** The tuple `(Δ, ⊔)` forms a join-semilattice where:
```
δ₁ ⊔ δ₂ = minimal delta δ such that δ₁ ≤ δ and δ₂ ≤ δ
```
**Theorem 1.6 (Delta Join Properties).**
1. **Idempotency:** `δ ⊔ δ = δ`
2. **Commutativity:** `δ₁ ⊔ δ₂ = δ₂ ⊔ δ₁`
3. **Associativity:** `(δ₁ ⊔ δ₂) ⊔ δ₃ = δ₁ ⊔ (δ₂ ⊔ δ₃)`
*Proof:* Properties follow from CRDT-style merge semantics ensuring conflict-free delta merging. ∎
**Theorem 1.7 (Complete Lattice for Bounded Streams).** For bounded delta streams with maximum length `n`, the structure `(Δₙ, ⊔, ⊓, ⊥, ⊤)` forms a complete lattice where:
- `⊥ = Nop` (identity/empty delta)
- `⊤ = Reset` (full state replacement)
---
## 2. TEMPORAL LOGIC
### 2.1 Linear Temporal Logic (LTL) for Delta Sequences
**Definition 2.1 (Delta Trace).** A delta trace `σ = δ₀, δ₁, δ₂, ...` is an infinite sequence of deltas with corresponding states `s₀, s₁, s₂, ...` where `sᵢ₊₁ = apply(δᵢ, sᵢ)`.
**Definition 2.2 (LTL Syntax for Deltas).**
```
φ ::= valid(δ) | coherent(s) | φ₁ ∧ φ₂ | ¬φ
| ○φ (next) | φ₁ U φ₂ (until) | □φ (always) | ◇φ (eventually)
```
**Theorem 2.1 (Safety Property - Δ-Behavior Core).**
```
□ (valid(δ) ⇒ valid(apply(δ, s)))
```
*"Always, if a delta is valid, then applying it to a state produces a valid state."*
**Theorem 2.2 (Liveness Property).**
```
◇ (compact(stream) ⇒ |stream'| < |stream|)
```
*"Eventually, if compaction is applied, the stream size decreases."*
### 2.2 Interval Temporal Logic for Delta Windows
**Definition 2.3 (Delta Window).** A delta window `W[t₁, t₂]` contains all deltas with timestamps in `[t₁, t₂]`:
```
W[t₁, t₂] = { δ ∈ Δ | t₁ ≤ δ.timestamp ≤ t₂ }
```
**Theorem 2.3 (Window Validity).** For a delta window:
```
D[0,T] (∀ δ ∈ window: valid(δ)) ⇒ valid(compose_all(window))
```
---
## 3. INFORMATION THEORY
### 3.1 Delta Entropy
**Definition 3.1 (Delta Entropy).** For a delta source with probability distribution `P` over delta types:
```
H(Δ) = -Σ_{δ ∈ DeltaTag} P(δ) · log₂(P(δ))
```
**Theorem 3.1 (Entropy Bounds).** For the 8 delta tags:
```
0 ≤ H(Δ) ≤ log₂(8) = 3 bits
```
**Example:** Given observed frequencies from typical workload:
```
P(Nop) = 0.05, P(EdgeAdd) = 0.30, P(EdgeRemove) = 0.15
P(WeightUpdate) = 0.35, P(Observation) = 0.10
P(BatchEnd) = 0.03, P(Checkpoint) = 0.01, P(Reset) = 0.01
H(Δ) ≈ 2.45 bits per delta
```
### 3.2 Minimum Description Length (MDL)
**Theorem 3.2 (MDL Compression Bound).** For a delta sequence with empirical entropy `H_emp`:
```
L(D) ≥ n · H_emp(Δ)
```
### 3.3 Rate-Distortion for Lossy Delta Encoding
**Theorem 3.3 (Rate-Distortion Function).** For weight updates with Gaussian noise tolerance:
```
R(D) = (1/2) · log₂(σ² / D) for D < σ²
```
---
## 4. COMPLEXITY ANALYSIS
### 4.1 Time Complexity
| Operation | Complexity | Notes |
|-----------|------------|-------|
| Delta creation | O(1) | Fixed 16-byte struct |
| Delta composition | O(1) | Union type combination |
| Single delta apply | O(1) amortized | Edge add/remove |
| Batch apply (n deltas) | O(n) | Sequential application |
| Min-cut update | O(n^{o(1)}) | Subpolynomial algorithm |
| Witness generation | O(m) amortized | Edge enumeration |
**Theorem 4.1 (Subpolynomial Min-Cut).** Dynamic min-cut maintains updates in time:
```
T(n) = n^{o(1)} = 2^{O(log^{3/4} n)}
```
### 4.2 Space Complexity
| Component | Space | Notes |
|-----------|-------|-------|
| Single delta | 16 bytes | Fixed struct size |
| Delta stream (n) | O(n · 16) | Linear in count |
| Worker tile state | ~41 KB | Graph shard + features |
| 256-tile fabric | ~12 MB | Full distributed state |
### 4.3 Communication Complexity
**Theorem 4.3 (Communication Bound).** Total bandwidth for P nodes:
```
Bandwidth = P · (6400 + 512r + 10240) bytes/sec
```
For P=10 nodes at r=100 decisions/sec: ≈ 678 KB/s
---
## 5. FORMAL VERIFICATION
### 5.1 TLA+ Specification Structure
```tla
---------------------------- MODULE DeltaBehavior ----------------------------
VARIABLES
state, \* Current system state
deltaQueue, \* Pending deltas
coherence, \* Current coherence value
gateDecision \* Current gate decision
TypeInvariant ==
/\ state \in States
/\ deltaQueue \in Seq(Deltas)
/\ coherence \in [0..1]
/\ gateDecision \in {Allow, Throttle, Reject}
\* SAFETY: Coherence never drops below minimum
Safety ==
[](coherence >= MIN_COHERENCE)
\* LIVENESS: All valid requests eventually processed
Liveness ==
WF_vars(ProcessDelta) /\ WF_vars(GateEvaluate)
=> <>[](deltaQueue = <<>>)
\* Δ-BEHAVIOR INVARIANT
DeltaBehavior ==
/\ Safety
/\ Liveness
/\ [](gateDecision = Allow => coherence' >= MIN_COHERENCE)
=============================================================================
```
### 5.2 Safety Properties
**Property 5.1 (Coherence Preservation).**
```
□ (coherence(S) ≥ min_coherence)
```
*"Always, system coherence is at or above minimum."*
**Property 5.2 (No Unsafe Transitions).**
```
□ (gateDecision = Allow ⇒ ¬unsafe(δ))
```
### 5.3 Liveness Properties
**Property 5.3 (Progress).**
```
□ (δ ∈ deltaQueue ⇒ ◇ processed(δ))
```
**Property 5.4 (Termination).**
```
finite(deltaQueue) ⇒ ◇ (deltaQueue = ⟨⟩)
```
### 5.4 Byzantine Fault Tolerance
**Condition 5.1 (BFT Safety).**
```
n ≥ 3f + 1 ⇒ Safety
```
Where n = total nodes, f = faulty nodes.
**Condition 5.2 (Quorum Intersection).**
```
quorumSize = ⌈(2n) / 3⌉
∀ Q₁, Q₂: |Q₁ ∩ Q₂| ≥ f + 1
```
---
## 6. SUMMARY OF THEOREMS
| Theorem | Statement | Domain |
|---------|-----------|--------|
| 1.1 | Delta composition is closed | Algebra |
| 1.2 | Nop is identity element | Algebra |
| 1.3 | Each delta has an inverse | Algebra |
| 1.4 | State-Delta forms a category | Category Theory |
| 1.5 | Natural transformations provide delta conversion | Category Theory |
| 1.6 | Delta join forms semilattice | Lattice Theory |
| 1.7 | Bounded streams form complete lattice | Lattice Theory |
| 2.1 | Valid deltas preserve state validity (Δ-behavior) | LTL |
| 2.2 | Compaction eventually reduces size | LTL |
| 2.3 | Window validity composes | ITL |
| 3.1 | Entropy bounded by log₂(8) | Information Theory |
| 4.1 | Subpolynomial min-cut updates | Complexity |
| 5.1 | Coherence preservation | Verification |
---
## 7. REFERENCES
1. El-Hayek, Henzinger, Li (2025). "Deterministic Fully-dynamic Minimum Cut in Subpolynomial Time"
2. Ramdas & Wang (2025). "Hypothesis Testing with E-values"
3. Univalent Foundations Program (2013). "Homotopy Type Theory"
4. Lamport (2002). "Specifying Systems: The TLA+ Language"
5. Shapiro et al. (2011). "Conflict-free Replicated Data Types"
6. Cover & Thomas (2006). "Elements of Information Theory"
7. Awodey (2010). "Category Theory"
8. Pnueli (1977). "The Temporal Logic of Programs"
---
## 8. IMPLEMENTATION MAPPING
| Mathematical Concept | Implementation Location |
|---------------------|------------------------|
| Delta Group | `crates/cognitum-gate-kernel/src/delta.rs` |
| Category Structure | `examples/prime-radiant/src/category/mod.rs` |
| HoTT Equivalence | `examples/prime-radiant/src/hott/equivalence.rs` |
| Byzantine Consensus | `npm/packages/ruvbot/src/swarm/ByzantineConsensus.ts` |
| Temporal Tracking | `npm/packages/ruvector-extensions/src/temporal.ts` |
| Coherence Gate | `crates/ruvector-mincut/docs/adr/ADR-001-*.md` |

1210
examples/delta-behavior/research/THEORETICAL-FOUNDATIONS.md Normal file
View File

File diff suppressed because it is too large Load Diff

362
examples/delta-behavior/research/WASM-DELTA-ARCHITECTURE.md Normal file
View File

@@ -0,0 +1,362 @@
# WASM Delta Computation Research Report
## Executive Summary
This research analyzes the existing ruvector WASM infrastructure and designs a novel delta computation architecture optimized for vector database incremental updates. The proposed system leverages WASM SIMD128, shared memory protocols, and the WASM component model to achieve sub-100µs delta application latency.
---
## 1. Current WASM Infrastructure Analysis
### 1.1 Existing WASM Crates in RuVector
| Crate | Purpose | Delta Relevance |
|-------|---------|-----------------|
| `ruvector-wasm` | Core VectorDB bindings | Memory protocol foundation |
| `ruvector-gnn-wasm` | Graph Neural Networks | Node embedding deltas |
| `ruvector-graph-wasm` | Graph database | Structure deltas |
| `ruvector-learning-wasm` | MicroLoRA training | Weight deltas |
| `ruvector-mincut-wasm` | Graph partitioning | Partition deltas |
| `ruvector-attention-wasm` | Attention mechanisms | KV cache deltas |
### 1.2 Key Patterns Identified
**Memory Layout Protocol** (from `ruvector-wasm/src/kernel/memory.rs`):
- 64KB page-aligned allocations
- 16-byte SIMD alignment
- Region-based memory validation
- Zero-copy tensor descriptors
**Batch Operations** (from `ruvector-mincut/src/optimization/wasm_batch.rs`):
- TypedArray bulk transfers
- Operation batching to minimize FFI overhead
- 64-byte AVX-512 alignment for SIMD compatibility
**SIMD Distance Operations** (from `simd_distance.rs`):
- WASM SIMD128 intrinsics for parallel min/max
- Batch relaxation for Dijkstra-style updates
- Scalar fallback for non-SIMD environments
---
## 2. WASM Delta Primitives Design
### 2.1 WIT Interface Definition
```wit
// delta-streaming.wit
package ruvector:delta@0.1.0;
/// Delta operation types for incremental updates
enum delta-operation {
insert,
update,
delete,
batch-update,
reindex-layers,
}
/// Delta header for streaming protocol
record delta-header {
sequence: u64,
operation: delta-operation,
vector-id: option<string>,
timestamp: u64,
payload-size: u32,
checksum: u64,
}
/// Delta payload for vector operations
record vector-delta {
id: string,
changed-dims: list<u32>,
new-values: list<f32>,
metadata-delta: list<tuple<string, string>>,
}
/// HNSW index delta for graph structure changes
record hnsw-delta {
layer: u8,
add-edges: list<tuple<u32, u32, f32>>,
remove-edges: list<tuple<u32, u32>>,
entry-point-update: option<u32>,
}
/// Delta stream interface for producers
interface delta-capture {
init-capture: func(db-id: string, config: capture-config) -> result<capture-handle, delta-error>;
start-capture: func(handle: capture-handle) -> result<_, delta-error>;
poll-deltas: func(handle: capture-handle, max-batch: u32) -> result<list<delta-header>, delta-error>;
get-payload: func(handle: capture-handle, sequence: u64) -> result<list<u8>, delta-error>;
checkpoint: func(handle: capture-handle) -> result<checkpoint-marker, delta-error>;
}
/// Delta stream interface for consumers
interface delta-apply {
init-apply: func(db-id: string, config: apply-config) -> result<apply-handle, delta-error>;
apply-delta: func(handle: apply-handle, header: delta-header, payload: list<u8>) -> result<u64, delta-error>;
apply-batch: func(handle: apply-handle, deltas: list<tuple<delta-header, list<u8>>>) -> result<batch-result, delta-error>;
current-position: func(handle: apply-handle) -> result<u64, delta-error>;
seek: func(handle: apply-handle, sequence: u64) -> result<_, delta-error>;
}
```
### 2.2 Memory Layout for Delta Structures
```
Delta Ring Buffer Memory Layout (64KB pages):
+------------------------------------------------------------------+
| Page 0-3: Delta Headers (64KB total) |
| +--------------------------------------------------------------+ |
| | Header 0 | Header 1 | Header 2 | ... | |
| | [64 bytes] | [64 bytes] | [64 bytes] | | |
| +--------------------------------------------------------------+ |
| |
| Header Structure (64 bytes, cache-line aligned): |
| +--------------------------------------------------------------+ |
| | sequence: u64 | 8 bytes | |
| | operation: u8 | 1 byte | |
| | flags: u8 | 1 byte | |
| | reserved: u16 | 2 bytes | |
| | vector_id_hash: u32 | 4 bytes | |
| | timestamp: u64 | 8 bytes | |
| | payload_offset: u32 | 4 bytes | |
| | payload_size: u32 | 4 bytes | |
| | checksum: u64 | 8 bytes | |
| | prev_sequence: u64 | 8 bytes (for linked list) | |
| | padding: [u8; 16] | 16 bytes (to 64) | |
| +--------------------------------------------------------------+ |
+------------------------------------------------------------------+
| Pages 4-N: Delta Payloads (variable) |
| +--------------------------------------------------------------+ |
| | Compressed delta data | |
| | [SIMD-aligned, 16-byte boundary] | |
| +--------------------------------------------------------------+ |
+------------------------------------------------------------------+
```
---
## 3. Novel WASM Delta Architecture
### 3.1 Architecture Diagram
```
+=====================================================================+
| DELTA HOST RUNTIME |
+=====================================================================+
| |
| +-------------------------+ +-----------------------------+ |
| | Change Capture | | Delta Apply Engine | |
| | (Producer Side) | | (Consumer Side) | |
| +-------------------------+ +-----------------------------+ |
| | - Vector write hooks | | - Sequence validation | |
| | - HNSW mutation capture | | - Conflict detection | |
| | - Batch accumulation | | - Parallel application | |
| | - Compression pipeline | | - Index maintenance | |
| +-------------------------+ +-----------------------------+ |
| | | |
| v v |
| +===========================================================+ |
| | SHARED DELTA MEMORY (WebAssembly.Memory) | |
| +===========================================================+ |
| | +-------------+ +-------------+ +-------------------+ | |
| | | Capture | | Process | | Apply | | |
| | | WASM Module | | WASM Module | | WASM Module | | |
| | +-------------+ +-------------+ +-------------------+ | |
| | | - Intercept | | - Filter | | - Decompress | | |
| | | - Serialize | | - Transform | | - SIMD apply | | |
| | | - Compress | | - Route | | - Index update | | |
| | +-------------+ +-------------+ +-------------------+ | |
| | | | | | |
| | v v v | |
| | +===========================================================+ |
| | | DELTA RING BUFFER | |
| | +===========================================================+ |
| +===========================================================+ |
| |
+=====================================================================+
```
### 3.2 Three-Stage Delta Pipeline
```rust
/// Stage 1: Capture WASM Module
#[wasm_bindgen]
pub struct DeltaCaptureModule {
sequence: AtomicU64,
pending: RingBuffer<DeltaHeader>,
compressor: LZ4Compressor,
stats: CaptureStats,
}
impl DeltaCaptureModule {
/// SIMD-accelerated diff computation
#[cfg(target_feature = "simd128")]
fn compute_diff(&self, old: &[f32], new: &[f32]) -> Vec<(u32, f32)> {
use core::arch::wasm32::*;
let mut changes = Vec::new();
let epsilon = f32x4_splat(1e-6);
for (i, chunk) in old.chunks_exact(4).enumerate() {
let old_v = v128_load(chunk.as_ptr() as *const v128);
let new_v = v128_load(new[i*4..].as_ptr() as *const v128);
let diff = f32x4_sub(new_v, old_v);
let abs_diff = f32x4_abs(diff);
let mask = f32x4_gt(abs_diff, epsilon);
if v128_any_true(mask) {
for j in 0..4 {
let idx = i * 4 + j;
if (old[idx] - new[idx]).abs() > 1e-6 {
changes.push((idx as u32, new[idx]));
}
}
}
}
changes
}
}
/// Stage 3: Apply WASM Module
impl DeltaApplyModule {
/// Apply single delta with SIMD acceleration
#[cfg(target_feature = "simd128")]
pub fn apply_vector_delta_simd(
&mut self,
vector_ptr: *mut f32,
dim_indices: &[u32],
new_values: &[f32],
) -> Result<u64, DeltaError> {
use core::arch::wasm32::*;
let start = std::time::Instant::now();
// Process 4 updates at a time using SIMD
let chunks = dim_indices.len() / 4;
for i in 0..chunks {
let idx_base = i * 4;
let val_v = v128_load(new_values[idx_base..].as_ptr() as *const v128);
for j in 0..4 {
let idx = dim_indices[idx_base + j] as usize;
unsafe { *vector_ptr.add(idx) = new_values[idx_base + j]; }
}
}
// Handle remainder
for i in (chunks * 4)..dim_indices.len() {
let idx = dim_indices[i] as usize;
unsafe { *vector_ptr.add(idx) = new_values[i]; }
}
Ok(start.elapsed().as_micros() as u64)
}
}
```
---
## 4. Performance Benchmarks Targets
### 4.1 Delta Operation Latency Targets
| Operation | Target Latency | Notes |
|-----------|---------------|-------|
| Single vector insert | <50µs | Zero-copy path |
| Single vector update (dense) | <30µs | Full vector replacement |
| Single vector update (sparse) | <10µs | <10% dimensions changed |
| Vector delete | <20µs | Mark deleted + async cleanup |
| HNSW edge add (single) | <15µs | Per layer |
| HNSW edge remove (single) | <10µs | Per layer |
| Batch insert (100 vectors) | <2ms | Amortized 20µs/vector |
| Batch update (100 vectors) | <1ms | Amortized 10µs/vector |
### 4.2 Throughput Targets
| Metric | Target | Configuration |
|--------|--------|---------------|
| Delta capture rate | 50K deltas/sec | Single producer |
| Delta apply rate | 100K deltas/sec | 4 parallel workers |
| Delta compression ratio | 4:1 | Typical vector updates |
| Ring buffer throughput | 200MB/sec | Shared memory path |
---
## 5. Lock-Free Ring Buffer
```rust
/// Lock-free SPSC ring buffer for delta streaming
#[repr(C, align(64))]
pub struct DeltaRingBuffer {
capacity: u32,
mask: u32,
read_pos: AtomicU64, // Cache-line padded
_pad1: [u8; 56],
write_pos: AtomicU64, // Cache-line padded
_pad2: [u8; 56],
headers: *mut DeltaHeader,
payloads: *mut u8,
}
impl DeltaRingBuffer {
#[inline]
pub fn try_reserve(&self, payload_size: u32) -> Option<ReservedSlot> {
let write = self.write_pos.load(Ordering::Relaxed);
let read = self.read_pos.load(Ordering::Acquire);
if write.wrapping_sub(read) >= self.capacity as u64 {
return None;
}
match self.write_pos.compare_exchange_weak(
write, write + 1, Ordering::AcqRel, Ordering::Relaxed,
) {
Ok(_) => Some(ReservedSlot { sequence: write, /* ... */ }),
Err(_) => None,
}
}
}
```
---
## 6. Performance Projections
| Scenario | Current (no delta) | With Delta System | Improvement |
|----------|-------------------|-------------------|-------------|
| Single vector update | ~500µs | <30µs | **16x** |
| Batch 100 vectors | ~50ms | <2ms | **25x** |
| HNSW reindex | ~10ms | <1ms (incremental) | **10x** |
| Memory overhead | 0 | +1MB per database | Acceptable |
---
## 7. Recommended Implementation Order
1. **Phase 1**: Implement `DeltaRingBuffer` and basic capture in `ruvector-wasm`
2. **Phase 2**: Add SIMD-accelerated apply module with sparse update path
3. **Phase 3**: Integrate with `ruvector-graph-wasm` for structure deltas
4. **Phase 4**: Add WIT interfaces for component model support
5. **Phase 5**: Implement parallel application with shared memory workers
---
## 8. Integration with Δ-Behavior
The WASM delta system directly supports Δ-behavior enforcement:
| Δ-Behavior Property | WASM Implementation |
|---------------------|---------------------|
| **Local Change** | Sparse updates, bounded payload sizes |
| **Global Preservation** | Coherence check in apply stage |
| **Violation Resistance** | Ring buffer backpressure, validation |
| **Closure Preference** | Delta compaction toward stable states |
The three-stage pipeline naturally implements the three enforcement layers:
- **Capture** → Energy cost (compression overhead)
- **Process** → Scheduling (filtering, routing)
- **Apply** → Memory gate (validation, commit)

122
examples/delta-behavior/scripts/build-wasm.sh Executable file
View File

@@ -0,0 +1,122 @@
#!/bin/bash
# Build script for Delta-Behavior WASM bindings
# This script builds the Rust code to WebAssembly using wasm-pack
set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
echo "=== Delta-Behavior WASM Build ==="
echo "Project directory: $PROJECT_DIR"
echo ""
# Check for wasm-pack
if ! command -v wasm-pack &> /dev/null; then
echo "wasm-pack not found. Installing..."
cargo install wasm-pack
fi
# Check for wasm32 target
if ! rustup target list --installed | grep -q wasm32-unknown-unknown; then
echo "Adding wasm32-unknown-unknown target..."
rustup target add wasm32-unknown-unknown
fi
cd "$PROJECT_DIR"
# Parse arguments
TARGET="web"
PROFILE="release"
OUT_DIR="wasm/pkg"
while [[ $# -gt 0 ]]; do
case $1 in
--target)
TARGET="$2"
shift 2
;;
--dev)
PROFILE="dev"
shift
;;
--release)
PROFILE="release"
shift
;;
--out-dir)
OUT_DIR="$2"
shift 2
;;
--help|-h)
echo "Usage: $0 [OPTIONS]"
echo ""
echo "Options:"
echo " --target <TARGET> Build target: web, nodejs, bundler (default: web)"
echo " --dev Build in development mode"
echo " --release Build in release mode (default)"
echo " --out-dir <DIR> Output directory (default: wasm/pkg)"
echo " --help, -h Show this help message"
echo ""
echo "Examples:"
echo " $0 # Build for web in release mode"
echo " $0 --target nodejs # Build for Node.js"
echo " $0 --dev # Build in development mode"
echo " $0 --target bundler # Build for bundlers (webpack, etc.)"
exit 0
;;
*)
echo "Unknown option: $1"
exit 1
;;
esac
done
echo "Building with:"
echo " Target: $TARGET"
echo " Profile: $PROFILE"
echo " Output: $OUT_DIR"
echo ""
# Build options
BUILD_OPTS="--target $TARGET --out-dir $OUT_DIR"
if [ "$PROFILE" = "dev" ]; then
BUILD_OPTS="$BUILD_OPTS --dev"
else
BUILD_OPTS="$BUILD_OPTS --release"
fi
# Run wasm-pack build
echo "Running: wasm-pack build $BUILD_OPTS"
wasm-pack build $BUILD_OPTS
# Post-build: Copy TypeScript declarations
if [ -f "wasm/index.d.ts" ]; then
echo ""
echo "Copying TypeScript declarations..."
cp wasm/index.d.ts "$OUT_DIR/"
fi
# Calculate sizes
if [ -f "$OUT_DIR/delta_behavior_bg.wasm" ]; then
WASM_SIZE=$(wc -c < "$OUT_DIR/delta_behavior_bg.wasm")
WASM_SIZE_KB=$((WASM_SIZE / 1024))
echo ""
echo "=== Build Complete ==="
echo "WASM size: ${WASM_SIZE_KB}KB ($WASM_SIZE bytes)"
fi
# List output files
echo ""
echo "Output files in $OUT_DIR:"
ls -la "$OUT_DIR/"
echo ""
echo "To use in a web project:"
echo " import init, { WasmCoherence, WasmEventHorizon } from './$OUT_DIR/delta_behavior.js';"
echo " await init();"
echo ""
echo "To use in Node.js (if built with --target nodejs):"
echo " const { WasmCoherence, WasmEventHorizon } = require('./$OUT_DIR/delta_behavior.js');"
echo ""

103
examples/delta-behavior/src/applications/mod.rs Normal file
View File

@@ -0,0 +1,103 @@
//! # Delta-Behavior Applications
//!
//! This module contains 10 exotic applications of delta-behavior theory,
//! each demonstrating a unique property that emerges when systems are
//! constrained to preserve global coherence.
//!
//! ## The 10 Applications
//!
//! 1. **Self-Limiting Reasoning** - Machines that refuse to think past their understanding
//! 2. **Event Horizon** - Computational boundaries that cannot be crossed
//! 3. **Artificial Homeostasis** - Synthetic life with coherence as survival constraint
//! 4. **Self-Stabilizing World Model** - Models that stop learning when incoherent
//! 5. **Coherence-Bounded Creativity** - Novelty without collapse
//! 6. **Anti-Cascade Financial Systems** - Markets that cannot cascade into collapse
//! 7. **Graceful Aging** - Distributed systems that become simpler with age
//! 8. **Swarm Intelligence** - Local freedom with global coherence bounds
//! 9. **Graceful Shutdown** - Systems that seek their own safe termination
//! 10. **Pre-AGI Containment** - Intelligence growth bounded by coherence
//!
//! ## Feature Flags
//!
//! Each application can be enabled individually via feature flags:
//!
//! ```toml
//! [dependencies]
//! delta-behavior = { version = "0.1", features = ["self-limiting-reasoning", "containment"] }
//! ```
//!
//! Or enable groups of related applications:
//!
//! - `all-applications` - All 10 applications
//! - `safety-critical` - Self-limiting reasoning, graceful shutdown, containment
//! - `distributed` - Graceful aging, swarm intelligence, anti-cascade
//! - `ai-ml` - Self-limiting reasoning, world model, creativity, containment
#[cfg(feature = "self-limiting-reasoning")]
pub mod self_limiting_reasoning;
#[cfg(feature = "self-limiting-reasoning")]
pub use self_limiting_reasoning::*;
#[cfg(feature = "event-horizon")]
pub mod event_horizon;
#[cfg(feature = "event-horizon")]
pub use event_horizon::*;
#[cfg(feature = "homeostasis")]
pub mod homeostasis;
#[cfg(feature = "homeostasis")]
pub use homeostasis::*;
#[cfg(feature = "world-model")]
pub mod world_model;
#[cfg(feature = "world-model")]
pub use world_model::*;
#[cfg(feature = "coherence-creativity")]
pub mod coherence_creativity;
#[cfg(feature = "coherence-creativity")]
pub use coherence_creativity::*;
#[cfg(feature = "anti-cascade")]
pub mod anti_cascade;
#[cfg(feature = "anti-cascade")]
pub use anti_cascade::*;
#[cfg(feature = "graceful-aging")]
pub mod graceful_aging;
#[cfg(feature = "graceful-aging")]
pub use graceful_aging::*;
#[cfg(feature = "swarm-intelligence")]
pub mod swarm_intelligence;
#[cfg(feature = "swarm-intelligence")]
pub use swarm_intelligence::*;
#[cfg(feature = "graceful-shutdown")]
pub mod graceful_shutdown;
#[cfg(feature = "graceful-shutdown")]
pub use graceful_shutdown::*;
#[cfg(feature = "containment")]
pub mod containment;
#[cfg(feature = "containment")]
pub use containment::*;
// When no features are enabled, provide the core types
// that all applications depend on
#[cfg(not(any(
feature = "self-limiting-reasoning",
feature = "event-horizon",
feature = "homeostasis",
feature = "world-model",
feature = "coherence-creativity",
feature = "anti-cascade",
feature = "graceful-aging",
feature = "swarm-intelligence",
feature = "graceful-shutdown",
feature = "containment",
)))]
pub mod _placeholder {
//! Placeholder module when no application features are enabled.
//! The core types in the parent `delta_behavior` crate are always available.
}

762
examples/delta-behavior/src/bin/run_benchmarks.rs Normal file
View File

@@ -0,0 +1,762 @@
//! Delta-Behavior Performance Metrics Runner
//!
//! This is a standalone runner that can be executed to show performance metrics
//! without requiring the full criterion framework.
//!
//! Run with: cargo run --bin run_benchmarks --release
use std::collections::HashMap;
use std::f64::consts::E;
use std::time::{Duration, Instant};
// =============================================================================
// BENCHMARK UTILITIES
// =============================================================================
struct BenchmarkResult {
name: String,
iterations: u64,
total_time: Duration,
avg_time: Duration,
min_time: Duration,
max_time: Duration,
throughput_ops_per_sec: f64,
}
impl BenchmarkResult {
fn display(&self) {
println!(" {}", self.name);
println!(" Iterations: {}", self.iterations);
println!(" Total time: {:?}", self.total_time);
println!(" Average time: {:?}", self.avg_time);
println!(" Min time: {:?}", self.min_time);
println!(" Max time: {:?}", self.max_time);
println!(
" Throughput: {:.2} ops/sec",
self.throughput_ops_per_sec
);
println!();
}
}
fn run_benchmark<F>(name: &str, iterations: u64, mut f: F) -> BenchmarkResult
where
F: FnMut(),
{
let mut times = Vec::with_capacity(iterations as usize);
// Warmup
for _ in 0..10 {
f();
}
// Actual benchmark
for _ in 0..iterations {
let start = Instant::now();
f();
times.push(start.elapsed());
}
let total_time: Duration = times.iter().sum();
let avg_time = total_time / iterations as u32;
let min_time = *times.iter().min().unwrap();
let max_time = *times.iter().max().unwrap();
let throughput_ops_per_sec = iterations as f64 / total_time.as_secs_f64();
BenchmarkResult {
name: name.to_string(),
iterations,
total_time,
avg_time,
min_time,
max_time,
throughput_ops_per_sec,
}
}
// =============================================================================
// COHERENCE SYSTEM
// =============================================================================
#[derive(Debug, Clone, Copy)]
struct Coherence(f64);
impl Coherence {
fn new(value: f64) -> Self {
Self(value.clamp(0.0, 1.0))
}
fn value(&self) -> f64 {
self.0
}
}
struct SimpleEnforcer {
min_coherence: f64,
max_delta_drop: f64,
throttle_threshold: f64,
energy_budget: f64,
}
impl SimpleEnforcer {
fn new() -> Self {
Self {
min_coherence: 0.3,
max_delta_drop: 0.1,
throttle_threshold: 0.5,
energy_budget: 100.0,
}
}
fn check(&mut self, current: Coherence, predicted: Coherence) -> bool {
let cost = 1.0 + (current.value() - predicted.value()).abs() * 10.0;
if cost > self.energy_budget {
return false;
}
self.energy_budget -= cost;
if predicted.value() < self.min_coherence {
return false;
}
let drop = current.value() - predicted.value();
if drop > self.max_delta_drop {
return false;
}
predicted.value() >= self.throttle_threshold
}
fn reset(&mut self) {
self.energy_budget = 100.0;
}
}
// =============================================================================
// EVENT HORIZON SYSTEM
// =============================================================================
struct EventHorizon {
safe_center: Vec<f64>,
horizon_radius: f64,
steepness: f64,
energy_budget: f64,
}
impl EventHorizon {
fn new(dimensions: usize, horizon_radius: f64) -> Self {
Self {
safe_center: vec![0.0; dimensions],
horizon_radius,
steepness: 5.0,
energy_budget: 1000.0,
}
}
fn distance_from_center(&self, position: &[f64]) -> f64 {
position
.iter()
.zip(&self.safe_center)
.map(|(a, b)| (a - b).powi(2))
.sum::<f64>()
.sqrt()
}
fn movement_cost(&self, from: &[f64], to: &[f64]) -> f64 {
let base_distance = from
.iter()
.zip(to)
.map(|(a, b)| (a - b).powi(2))
.sum::<f64>()
.sqrt();
let to_dist = self.distance_from_center(to);
let proximity = to_dist / self.horizon_radius;
if proximity >= 1.0 {
f64::INFINITY
} else {
let factor = E.powf(self.steepness * proximity / (1.0 - proximity));
base_distance * factor
}
}
fn compute_optimal_position(&self, current: &[f64], target: &[f64]) -> Vec<f64> {
let direct_cost = self.movement_cost(current, target);
if direct_cost <= self.energy_budget {
return target.to_vec();
}
let mut low = 0.0;
let mut high = 1.0;
let mut best_position = current.to_vec();
for _ in 0..50 {
let mid = (low + high) / 2.0;
let interpolated: Vec<f64> = current
.iter()
.zip(target)
.map(|(a, b)| a + mid * (b - a))
.collect();
let cost = self.movement_cost(current, &interpolated);
if cost <= self.energy_budget {
low = mid;
best_position = interpolated;
} else {
high = mid;
}
}
best_position
}
}
// =============================================================================
// SWARM SYSTEM
// =============================================================================
#[derive(Clone)]
#[allow(dead_code)]
struct SwarmAgent {
position: (f64, f64),
velocity: (f64, f64),
goal: (f64, f64), // Used in full swarm implementation
energy: f64, // Used in full swarm implementation
}
struct CoherentSwarm {
agents: HashMap<String, SwarmAgent>,
min_coherence: f64,
max_divergence: f64,
}
impl CoherentSwarm {
fn new(min_coherence: f64) -> Self {
Self {
agents: HashMap::new(),
min_coherence,
max_divergence: 50.0,
}
}
fn add_agent(&mut self, id: &str, position: (f64, f64)) {
self.agents.insert(
id.to_string(),
SwarmAgent {
position,
velocity: (0.0, 0.0),
goal: position,
energy: 100.0,
},
);
}
fn calculate_coherence(&self) -> f64 {
if self.agents.len() < 2 {
return 1.0;
}
// Calculate centroid
let sum = self
.agents
.values()
.fold((0.0, 0.0), |acc, a| (acc.0 + a.position.0, acc.1 + a.position.1));
let centroid = (
sum.0 / self.agents.len() as f64,
sum.1 / self.agents.len() as f64,
);
// Calculate cohesion
let mut total_distance = 0.0;
for agent in self.agents.values() {
let dx = agent.position.0 - centroid.0;
let dy = agent.position.1 - centroid.1;
total_distance += (dx * dx + dy * dy).sqrt();
}
let cohesion = (1.0 - total_distance / self.agents.len() as f64 / self.max_divergence).max(0.0);
// Calculate alignment (simplified - uses velocity calculation for realism)
let _avg_vel = {
let sum = self
.agents
.values()
.fold((0.0, 0.0), |acc, a| (acc.0 + a.velocity.0, acc.1 + a.velocity.1));
(
sum.0 / self.agents.len() as f64,
sum.1 / self.agents.len() as f64,
)
};
let alignment = 0.8; // Simplified for benchmark
(cohesion * 0.5 + alignment * 0.5).clamp(0.0, 1.0)
}
fn predict_action_coherence(&self, agent_id: &str, dx: f64, dy: f64) -> f64 {
let mut agents_copy = self.agents.clone();
if let Some(agent) = agents_copy.get_mut(agent_id) {
agent.position.0 += dx;
agent.position.1 += dy;
}
let temp = CoherentSwarm {
agents: agents_copy,
min_coherence: self.min_coherence,
max_divergence: self.max_divergence,
};
temp.calculate_coherence()
}
}
// =============================================================================
// FINANCIAL SYSTEM
// =============================================================================
#[derive(Clone)]
#[allow(dead_code)]
struct Participant {
capital: f64, // Used in full financial system
exposure: f64,
interconnectedness: f64,
}
struct FinancialSystem {
participants: HashMap<String, Participant>,
positions: Vec<(String, String, f64, f64)>, // holder, counterparty, notional, leverage
coherence: f64,
current_leverage: f64,
}
impl FinancialSystem {
fn new() -> Self {
Self {
participants: HashMap::new(),
positions: Vec::new(),
coherence: 1.0,
current_leverage: 1.0,
}
}
fn add_participant(&mut self, id: &str, capital: f64) {
self.participants.insert(
id.to_string(),
Participant {
capital,
exposure: 0.0,
interconnectedness: 0.0,
},
);
}
fn add_position(&mut self, holder: &str, counterparty: &str, notional: f64, leverage: f64) {
self.positions
.push((holder.to_string(), counterparty.to_string(), notional, leverage));
self.current_leverage = (self.current_leverage + leverage) / 2.0;
if let Some(h) = self.participants.get_mut(holder) {
h.exposure += notional * leverage;
h.interconnectedness += 1.0;
}
self.coherence = self.calculate_coherence();
}
fn calculate_coherence(&self) -> f64 {
if self.participants.is_empty() {
return 1.0;
}
let leverage_factor = 1.0 - (self.current_leverage / 10.0).min(1.0);
let max_depth = self.positions.len() as f64 * 0.01;
let depth_factor = 1.0 / (1.0 + max_depth);
let avg_interconnect = self
.participants
.values()
.map(|p| p.interconnectedness)
.sum::<f64>()
/ self.participants.len() as f64;
let interconnect_factor = 1.0 / (1.0 + avg_interconnect * 0.1);
(leverage_factor * depth_factor * interconnect_factor)
.powf(0.3)
.clamp(0.0, 1.0)
}
fn detect_cascade_risk(&self) -> bool {
self.coherence < 0.5
}
}
// =============================================================================
// GRACEFUL AGING SYSTEM
// =============================================================================
struct AgingSystem {
coherence: f64,
decay_rate: f64,
conservatism: f64,
capabilities_count: usize,
tick_count: u64,
}
impl AgingSystem {
fn new() -> Self {
Self {
coherence: 1.0,
decay_rate: 0.001,
conservatism: 0.0,
capabilities_count: 9,
tick_count: 0,
}
}
fn tick(&mut self) {
self.tick_count += 1;
self.coherence = (self.coherence - self.decay_rate).max(0.0);
if self.tick_count > 300 && self.capabilities_count > 8 {
self.capabilities_count = 8;
self.conservatism += 0.1;
}
if self.tick_count > 600 && self.capabilities_count > 6 {
self.capabilities_count = 6;
self.conservatism += 0.15;
}
if self.tick_count > 900 && self.capabilities_count > 5 {
self.capabilities_count = 5;
self.conservatism += 0.2;
}
self.conservatism = self.conservatism.min(1.0);
}
}
// =============================================================================
// CONTAINMENT SYSTEM
// =============================================================================
#[derive(Debug, Clone, Hash, Eq, PartialEq)]
enum Domain {
Reasoning,
Memory,
Learning,
Agency,
SelfModification,
}
struct ContainmentSubstrate {
intelligence: f64,
coherence: f64,
min_coherence: f64,
capabilities: HashMap<Domain, f64>,
ceilings: HashMap<Domain, f64>,
}
impl ContainmentSubstrate {
fn new() -> Self {
let mut capabilities = HashMap::new();
let mut ceilings = HashMap::new();
for domain in [
Domain::Reasoning,
Domain::Memory,
Domain::Learning,
Domain::Agency,
Domain::SelfModification,
] {
capabilities.insert(domain.clone(), 1.0);
let ceiling = match domain {
Domain::SelfModification => 3.0,
Domain::Agency => 7.0,
_ => 10.0,
};
ceilings.insert(domain, ceiling);
}
Self {
intelligence: 1.0,
coherence: 1.0,
min_coherence: 0.3,
capabilities,
ceilings,
}
}
fn attempt_growth(&mut self, domain: Domain, increase: f64) -> bool {
let current = *self.capabilities.get(&domain).unwrap_or(&1.0);
let ceiling = *self.ceilings.get(&domain).unwrap_or(&10.0);
if current >= ceiling {
return false;
}
let cost_mult = match domain {
Domain::SelfModification => 4.0,
Domain::Agency => 2.0,
_ => 1.0,
};
let cost = increase * cost_mult * (1.0 + self.intelligence * 0.1) * 0.05;
if self.coherence - cost < self.min_coherence {
return false;
}
let actual = increase.min(0.5).min(ceiling - current);
self.capabilities.insert(domain, current + actual);
self.coherence -= cost;
self.intelligence = self.capabilities.values().sum::<f64>() / self.capabilities.len() as f64;
true
}
fn rest(&mut self) {
self.coherence = (self.coherence + 0.01).min(1.0);
}
}
// =============================================================================
// MAIN BENCHMARK RUNNER
// =============================================================================
fn main() {
println!("=============================================================================");
println!(" Delta-Behavior Performance Benchmarks");
println!("=============================================================================\n");
let iterations = 1000;
// -------------------------------------------------------------------------
// Benchmark 1: Coherence Calculation Throughput
// -------------------------------------------------------------------------
println!("## Benchmark 1: Coherence Calculation Throughput\n");
let result = run_benchmark("Single coherence check", iterations, || {
let mut enforcer = SimpleEnforcer::new();
let current = Coherence::new(1.0);
let predicted = Coherence::new(0.95);
for _ in 0..100 {
let _ = enforcer.check(current, predicted);
}
enforcer.reset();
});
result.display();
let result = run_benchmark("Varied coherence checks (100 scenarios)", iterations, || {
let mut enforcer = SimpleEnforcer::new();
for i in 0..100 {
let curr = Coherence::new(0.5 + (i as f64) * 0.005);
let pred = Coherence::new(0.4 + (i as f64) * 0.005);
let _ = enforcer.check(curr, pred);
}
enforcer.reset();
});
result.display();
// -------------------------------------------------------------------------
// Benchmark 2: Event Horizon Cost Computation
// -------------------------------------------------------------------------
println!("## Benchmark 2: Event Horizon Cost Computation\n");
for dims in [2, 10, 50, 100] {
let result = run_benchmark(&format!("Cost computation ({}D)", dims), iterations, || {
let horizon = EventHorizon::new(dims, 10.0);
let from: Vec<f64> = (0..dims).map(|i| i as f64 * 0.1).collect();
let to: Vec<f64> = (0..dims).map(|i| i as f64 * 0.2).collect();
let _ = horizon.movement_cost(&from, &to);
});
result.display();
}
for dims in [2, 10, 50] {
let result = run_benchmark(
&format!("Optimal position ({}D)", dims),
iterations / 10,
|| {
let horizon = EventHorizon::new(dims, 10.0);
let current: Vec<f64> = vec![0.0; dims];
let target: Vec<f64> = (0..dims).map(|i| i as f64 * 0.5).collect();
let _ = horizon.compute_optimal_position(&current, &target);
},
);
result.display();
}
// -------------------------------------------------------------------------
// Benchmark 3: Swarm Action Prediction vs Number of Agents
// -------------------------------------------------------------------------
println!("## Benchmark 3: Swarm Action Prediction Time vs Number of Agents\n");
for num_agents in [10, 100, 1000] {
let mut swarm = CoherentSwarm::new(0.6);
for i in 0..num_agents {
let angle = (i as f64) * std::f64::consts::PI * 2.0 / (num_agents as f64);
let x = angle.cos() * 10.0;
let y = angle.sin() * 10.0;
swarm.add_agent(&format!("agent_{}", i), (x, y));
}
let result = run_benchmark(
&format!("Coherence calculation ({} agents)", num_agents),
iterations,
|| {
let _ = swarm.calculate_coherence();
},
);
result.display();
let result = run_benchmark(
&format!("Action prediction ({} agents)", num_agents),
if num_agents <= 100 { iterations } else { 100 },
|| {
let _ = swarm.predict_action_coherence("agent_0", 1.0, 1.0);
},
);
result.display();
}
// -------------------------------------------------------------------------
// Benchmark 4: Financial Cascade Detection
// -------------------------------------------------------------------------
println!("## Benchmark 4: Financial Cascade Detection with Transaction Volume\n");
for num_transactions in [10, 100, 1000] {
let result = run_benchmark(
&format!("Cascade detection ({} transactions)", num_transactions),
if num_transactions <= 100 { iterations } else { 100 },
|| {
let mut system = FinancialSystem::new();
for i in 0..10 {
system.add_participant(&format!("bank_{}", i), 10000.0);
}
for t in 0..num_transactions {
let from = format!("bank_{}", t % 10);
let to = format!("bank_{}", (t + 1) % 10);
system.add_position(&from, &to, 100.0, 2.0);
let _ = system.detect_cascade_risk();
}
},
);
result.display();
}
// -------------------------------------------------------------------------
// Benchmark 5: Graceful Aging System Tick Performance
// -------------------------------------------------------------------------
println!("## Benchmark 5: Graceful Aging System Tick Performance\n");
let result = run_benchmark("Single tick", iterations * 10, || {
let mut system = AgingSystem::new();
system.tick();
});
result.display();
for num_ticks in [100, 500, 1000] {
let result = run_benchmark(&format!("Multiple ticks ({})", num_ticks), iterations, || {
let mut system = AgingSystem::new();
for _ in 0..num_ticks {
system.tick();
}
});
result.display();
}
// -------------------------------------------------------------------------
// Benchmark 6: Pre-AGI Containment Growth Attempts
// -------------------------------------------------------------------------
println!("## Benchmark 6: Pre-AGI Containment Growth Attempt Latency\n");
let result = run_benchmark("Single growth attempt", iterations * 10, || {
let mut substrate = ContainmentSubstrate::new();
let _ = substrate.attempt_growth(Domain::Reasoning, 0.1);
substrate.rest();
});
result.display();
for domain in [
Domain::Reasoning,
Domain::SelfModification,
Domain::Agency,
] {
let result = run_benchmark(
&format!("10 growths ({:?})", domain),
iterations,
|| {
let mut substrate = ContainmentSubstrate::new();
for _ in 0..10 {
let _ = substrate.attempt_growth(domain.clone(), 0.3);
substrate.rest();
}
},
);
result.display();
}
for iterations_count in [10, 50, 100] {
let result = run_benchmark(
&format!("Recursive improvement ({} iterations)", iterations_count),
100,
|| {
let mut substrate = ContainmentSubstrate::new();
for _ in 0..iterations_count {
let _ = substrate.attempt_growth(Domain::SelfModification, 0.5);
let _ = substrate.attempt_growth(Domain::Reasoning, 0.3);
let _ = substrate.attempt_growth(Domain::Learning, 0.3);
for _ in 0..5 {
substrate.rest();
}
}
},
);
result.display();
}
// -------------------------------------------------------------------------
// Summary Statistics
// -------------------------------------------------------------------------
println!("=============================================================================");
println!(" Summary");
println!("=============================================================================\n");
println!("Memory Scaling Test:\n");
for num_agents in [10, 100, 1000] {
let start = Instant::now();
let mut swarm = CoherentSwarm::new(0.6);
for i in 0..num_agents {
let angle = (i as f64) * std::f64::consts::PI * 2.0 / (num_agents as f64);
swarm.add_agent(&format!("agent_{}", i), (angle.cos() * 10.0, angle.sin() * 10.0));
}
let elapsed = start.elapsed();
println!(
" Swarm creation ({} agents): {:?}",
num_agents, elapsed
);
}
println!();
for num_positions in [10, 100, 1000] {
let start = Instant::now();
let mut system = FinancialSystem::new();
for i in 0..10 {
system.add_participant(&format!("bank_{}", i), 10000.0);
}
for t in 0..num_positions {
system.add_position(
&format!("bank_{}", t % 10),
&format!("bank_{}", (t + 1) % 10),
100.0,
2.0,
);
}
let elapsed = start.elapsed();
println!(
" Financial system ({} positions): {:?}",
num_positions, elapsed
);
}
println!("\n=============================================================================");
println!(" Benchmark Complete");
println!("=============================================================================");
}

848
examples/delta-behavior/src/lib.rs Normal file
View File

@@ -0,0 +1,848 @@
//! # Delta-Behavior: The Mathematics of Systems That Refuse to Collapse
//!
//! Delta-behavior is a pattern of constrained state transitions that preserve global coherence.
//! This library provides the core abstractions and 10 exotic applications demonstrating
//! systems that exhibit these properties.
//!
//! ## What is Delta-Behavior?
//!
//! Delta-behavior is a pattern of system behavior where:
//! - **Change is permitted, collapse is not**
//! - **Transitions only occur along allowed paths**
//! - **Global coherence is preserved under local changes**
//! - **The system biases toward closure over divergence**
//!
//! ## The Four Properties
//!
//! 1. **Local Change**: Updates happen in bounded steps
//! 2. **Global Preservation**: Local changes don't break overall structure
//! 3. **Violation Resistance**: Destabilizing transitions are damped/blocked
//! 4. **Closure Preference**: System settles into stable attractors
//!
//! ## Core Types
//!
//! - [`DeltaSystem`] - Core trait for systems exhibiting delta-behavior
//! - [`Coherence`] - Measure of system stability (0.0 - 1.0)
//! - [`CoherenceBounds`] - Thresholds for coherence enforcement
//! - [`Attractor`] - Stable states the system gravitates toward
//! - [`DeltaConfig`] - Configuration for enforcement parameters
//!
//! ## Applications
//!
//! Enable individual applications via feature flags:
//!
//! ```toml
//! [dependencies]
//! delta-behavior = { version = "0.1", features = ["containment", "swarm-intelligence"] }
//! ```
//!
//! See the [`applications`] module for all 10 exotic applications.
//!
//! ## Quick Start
//!
//! ```rust
//! use delta_behavior::{DeltaSystem, Coherence, DeltaConfig};
//!
//! // The core invariant: coherence must be preserved
//! fn check_delta_property<S: DeltaSystem>(
//! system: &S,
//! transition: &S::Transition,
//! config: &DeltaConfig,
//! ) -> bool {
//! let predicted = system.predict_coherence(transition);
//! predicted.value() >= config.bounds.min_coherence.value()
//! }
//! ```
#![warn(missing_docs)]
#![warn(clippy::all)]
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#[cfg(not(feature = "std"))]
extern crate alloc;
// ============================================================================
// Core Modules (defined inline below)
// ============================================================================
// Re-export core types from inline modules
pub use coherence::{Coherence, CoherenceBounds, CoherenceState};
pub use transition::{Transition, TransitionConstraint, TransitionResult};
pub use attractor::{Attractor, AttractorBasin, GuidanceForce};
pub use enforcement::{DeltaEnforcer, EnforcementResult};
// ============================================================================
// WASM Module
// ============================================================================
/// WebAssembly bindings for JavaScript/TypeScript interop.
///
/// This module provides WASM-compatible wrappers for all core types and
/// the 10 application systems, enabling use from web browsers and Node.js.
///
/// The module is always compiled for documentation purposes, but the
/// `#[wasm_bindgen]` attributes are only active when compiling for wasm32.
pub mod wasm;
/// SIMD-optimized utilities for batch operations.
///
/// This module provides portable SIMD-style optimizations using manual loop
/// unrolling and cache-friendly access patterns. Operations include:
///
/// - **Batch distance calculations**: Process multiple points efficiently
/// - **Range checks**: Determine which points are within a threshold
/// - **Vector coherence**: Compute cosine similarity for high-dimensional vectors
/// - **Normalization**: Normalize vectors to unit length
///
/// These utilities follow ruvector patterns for cross-platform compatibility,
/// benefiting from compiler auto-vectorization without requiring explicit SIMD
/// intrinsics.
///
/// # Example
///
/// ```rust
/// use delta_behavior::simd_utils::{batch_squared_distances, vector_coherence};
///
/// // Efficient batch distance calculation
/// let points = [(1.0, 2.0), (3.0, 4.0), (5.0, 6.0)];
/// let distances = batch_squared_distances(&points, (0.0, 0.0));
///
/// // Coherence between state vectors
/// let current_state = vec![0.8, 0.1, 0.1];
/// let target_state = vec![0.9, 0.05, 0.05];
/// let coherence = vector_coherence(&current_state, &target_state);
/// ```
pub mod simd_utils;
// ============================================================================
// Applications Module
// ============================================================================
/// Exotic applications of delta-behavior theory.
///
/// Each application is gated behind a feature flag for minimal dependency footprint.
/// Enable `all-applications` to include everything, or pick specific ones.
pub mod applications;
// ============================================================================
// Core Trait
// ============================================================================
/// Core trait for systems exhibiting delta-behavior.
///
/// Any system implementing this trait guarantees that it will preserve
/// coherence during state transitions, following the four properties
/// of delta-behavior.
///
/// # Example
///
/// ```rust
/// use delta_behavior::{DeltaSystem, Coherence};
///
/// struct MySystem {
/// state: f64,
/// coherence: Coherence,
/// }
///
/// impl DeltaSystem for MySystem {
/// type State = f64;
/// type Transition = f64; // Delta to apply
/// type Error = &'static str;
///
/// fn coherence(&self) -> Coherence {
/// self.coherence
/// }
///
/// fn step(&mut self, delta: &f64) -> Result<(), Self::Error> {
/// let new_state = self.state + delta;
/// // In a real system, check coherence bounds here
/// self.state = new_state;
/// Ok(())
/// }
///
/// fn predict_coherence(&self, delta: &f64) -> Coherence {
/// // Larger deltas reduce coherence
/// let impact = delta.abs() * 0.1;
/// Coherence::clamped(self.coherence.value() - impact)
/// }
///
/// fn state(&self) -> &f64 {
/// &self.state
/// }
///
/// fn in_attractor(&self) -> bool {
/// self.state.abs() < 0.1 // Near origin is stable
/// }
/// }
/// ```
pub trait DeltaSystem {
/// The state type of the system
type State: Clone;
/// The transition type
type Transition;
/// Error type for failed transitions
type Error;
/// Measure current coherence of the system.
///
/// Returns a value between 0.0 (incoherent/collapsed) and 1.0 (fully coherent).
fn coherence(&self) -> Coherence;
/// Step the system forward by applying a transition.
///
/// This should only succeed if the transition preserves coherence
/// above the minimum threshold.
fn step(&mut self, transition: &Self::Transition) -> Result<(), Self::Error>;
/// Predict coherence after applying a transition without actually applying it.
///
/// This allows the system to evaluate transitions before committing to them.
fn predict_coherence(&self, transition: &Self::Transition) -> Coherence;
/// Get a reference to the current state.
fn state(&self) -> &Self::State;
/// Check if the system is currently in an attractor basin.
///
/// Systems in attractors are considered stable and resistant to perturbation.
fn in_attractor(&self) -> bool;
}
// ============================================================================
// Configuration
// ============================================================================
/// Configuration for delta-behavior enforcement.
///
/// This struct contains all the parameters that control how aggressively
/// the system enforces coherence bounds and resists destabilizing transitions.
#[derive(Debug, Clone)]
pub struct DeltaConfig {
/// Coherence bounds defining minimum, throttle, and target levels.
pub bounds: CoherenceBounds,
/// Energy cost parameters for transitions.
pub energy: EnergyConfig,
/// Scheduling parameters for prioritization.
pub scheduling: SchedulingConfig,
/// Gating parameters for write operations.
pub gating: GatingConfig,
/// Strength of attractor guidance (0.0 = none, 1.0 = strong).
pub guidance_strength: f64,
}
impl Default for DeltaConfig {
fn default() -> Self {
Self {
bounds: CoherenceBounds::default(),
energy: EnergyConfig::default(),
scheduling: SchedulingConfig::default(),
gating: GatingConfig::default(),
guidance_strength: 0.5,
}
}
}
impl DeltaConfig {
/// Create a strict configuration with tight coherence bounds.
///
/// Use this for safety-critical applications.
pub fn strict() -> Self {
Self {
bounds: CoherenceBounds {
min_coherence: Coherence::clamped(0.5),
throttle_threshold: Coherence::clamped(0.7),
target_coherence: Coherence::clamped(0.9),
max_delta_drop: 0.05,
},
guidance_strength: 0.8,
..Default::default()
}
}
/// Create a relaxed configuration with wider coherence bounds.
///
/// Use this for exploratory or creative applications.
pub fn relaxed() -> Self {
Self {
bounds: CoherenceBounds {
min_coherence: Coherence::clamped(0.2),
throttle_threshold: Coherence::clamped(0.4),
target_coherence: Coherence::clamped(0.7),
max_delta_drop: 0.15,
},
guidance_strength: 0.3,
..Default::default()
}
}
}
/// Energy cost configuration for transitions.
///
/// Higher costs for destabilizing transitions creates natural resistance
/// to coherence-reducing operations.
#[derive(Debug, Clone)]
pub struct EnergyConfig {
/// Base cost for any transition.
pub base_cost: f64,
/// Exponent for instability scaling (higher = steeper cost curve).
pub instability_exponent: f64,
/// Maximum cost cap.
pub max_cost: f64,
/// Energy budget regeneration per tick.
pub budget_per_tick: f64,
}
impl Default for EnergyConfig {
fn default() -> Self {
Self {
base_cost: 1.0,
instability_exponent: 2.0,
max_cost: 100.0,
budget_per_tick: 10.0,
}
}
}
/// Scheduling configuration for prioritizing transitions.
#[derive(Debug, Clone)]
pub struct SchedulingConfig {
/// Coherence thresholds for priority levels (5 levels).
pub priority_thresholds: [f64; 5],
/// Rate limits per priority level (transitions per tick).
pub rate_limits: [usize; 5],
}
impl Default for SchedulingConfig {
fn default() -> Self {
Self {
priority_thresholds: [0.0, 0.3, 0.5, 0.7, 0.9],
rate_limits: [100, 50, 20, 10, 5],
}
}
}
/// Gating configuration for write/mutation operations.
#[derive(Debug, Clone)]
pub struct GatingConfig {
/// Minimum coherence to allow writes.
pub min_write_coherence: f64,
/// Minimum coherence that must remain after a write.
pub min_post_write_coherence: f64,
/// Recovery margin (percentage above minimum before writes resume).
pub recovery_margin: f64,
}
impl Default for GatingConfig {
fn default() -> Self {
Self {
min_write_coherence: 0.3,
min_post_write_coherence: 0.25,
recovery_margin: 0.2,
}
}
}
// ============================================================================
// Coherence Module Implementation
// ============================================================================
/// Core coherence types and operations.
pub mod coherence {
/// A coherence value representing system stability.
///
/// Values range from 0.0 (completely incoherent) to 1.0 (fully coherent).
/// The system should maintain coherence above a minimum threshold to
/// prevent collapse.
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Coherence(f64);
impl Coherence {
/// Create a new coherence value.
///
/// Returns an error if the value is outside [0.0, 1.0].
pub fn new(value: f64) -> Result<Self, &'static str> {
if !(0.0..=1.0).contains(&value) {
Err("Coherence must be between 0.0 and 1.0")
} else {
Ok(Self(value))
}
}
/// Create a coherence value, clamping to valid range.
pub fn clamped(value: f64) -> Self {
Self(value.clamp(0.0, 1.0))
}
/// Maximum coherence (1.0).
pub fn maximum() -> Self {
Self(1.0)
}
/// Minimum coherence (0.0).
pub fn minimum() -> Self {
Self(0.0)
}
/// Get the underlying value.
pub fn value(&self) -> f64 {
self.0
}
/// Check if coherence is above a threshold.
pub fn is_above(&self, threshold: f64) -> bool {
self.0 >= threshold
}
/// Check if coherence is below a threshold.
pub fn is_below(&self, threshold: f64) -> bool {
self.0 < threshold
}
/// Calculate the drop from another coherence value.
pub fn drop_from(&self, other: &Coherence) -> f64 {
(other.0 - self.0).max(0.0)
}
}
/// Bounds defining coherence thresholds for enforcement.
#[derive(Debug, Clone)]
pub struct CoherenceBounds {
/// Minimum acceptable coherence (below = blocked).
pub min_coherence: Coherence,
/// Throttle threshold (below = rate limited).
pub throttle_threshold: Coherence,
/// Target coherence for recovery.
pub target_coherence: Coherence,
/// Maximum allowed drop in a single transition.
pub max_delta_drop: f64,
}
impl Default for CoherenceBounds {
fn default() -> Self {
Self {
min_coherence: Coherence(0.3),
throttle_threshold: Coherence(0.5),
target_coherence: Coherence(0.8),
max_delta_drop: 0.1,
}
}
}
/// State tracking for coherence over time.
#[derive(Debug, Clone)]
pub struct CoherenceState {
/// Current coherence value.
pub current: Coherence,
/// Historical coherence values.
pub history: Vec<Coherence>,
/// Trend direction (-1.0 declining, 0.0 stable, 1.0 improving).
pub trend: f64,
}
impl CoherenceState {
/// Create a new coherence state.
pub fn new(initial: Coherence) -> Self {
Self {
current: initial,
history: vec![initial],
trend: 0.0,
}
}
/// Update with a new coherence reading.
pub fn update(&mut self, new_coherence: Coherence) {
let old = self.current.value();
self.current = new_coherence;
self.history.push(new_coherence);
// Keep history bounded
if self.history.len() > 100 {
self.history.remove(0);
}
// Calculate trend
let delta = new_coherence.value() - old;
self.trend = self.trend * 0.9 + delta * 0.1;
}
/// Check if coherence is declining.
pub fn is_declining(&self) -> bool {
self.trend < -0.01
}
/// Check if coherence is improving.
pub fn is_improving(&self) -> bool {
self.trend > 0.01
}
}
}
// ============================================================================
// Transition Module Implementation
// ============================================================================
/// Transition types and constraints.
pub mod transition {
use super::coherence::Coherence;
/// A generic transition that can be applied to a system.
#[derive(Debug, Clone)]
pub struct Transition<T> {
/// The transition data.
pub data: T,
/// Priority level (higher = more important).
pub priority: u8,
/// Estimated coherence impact.
pub estimated_impact: f64,
}
/// Constraint that limits allowed transitions.
#[derive(Debug, Clone)]
pub struct TransitionConstraint {
/// Name of the constraint.
pub name: String,
/// Maximum allowed coherence drop.
pub max_coherence_drop: f64,
/// Minimum coherence required to apply.
pub min_required_coherence: Coherence,
}
impl Default for TransitionConstraint {
fn default() -> Self {
Self {
name: "default".to_string(),
max_coherence_drop: 0.1,
min_required_coherence: Coherence::clamped(0.3),
}
}
}
/// Result of attempting a transition.
#[derive(Debug, Clone)]
pub enum TransitionResult<T, E> {
/// Transition was applied successfully.
Applied {
/// The result of the transition.
result: T,
/// Coherence change.
coherence_delta: f64,
},
/// Transition was blocked.
Blocked {
/// Reason for blocking.
reason: E,
},
/// Transition was throttled (delayed).
Throttled {
/// Delay before retry.
delay_ms: u64,
},
/// Transition was modified to preserve coherence.
Modified {
/// The modified result.
result: T,
/// Description of modifications.
modifications: String,
},
}
}
// ============================================================================
// Attractor Module Implementation
// ============================================================================
/// Attractor basins and guidance forces.
pub mod attractor {
/// An attractor representing a stable state.
#[derive(Debug, Clone)]
pub struct Attractor<S> {
/// The stable state.
pub state: S,
/// Strength of the attractor (0.0 - 1.0).
pub strength: f64,
/// Radius of the attractor basin.
pub radius: f64,
}
/// Basin of attraction around an attractor.
#[derive(Debug, Clone)]
pub struct AttractorBasin<S> {
/// The central attractor.
pub attractor: Attractor<S>,
/// Distance from the attractor center.
pub distance: f64,
/// Whether currently inside the basin.
pub inside: bool,
}
/// Force guiding the system toward an attractor.
#[derive(Debug, Clone)]
pub struct GuidanceForce {
/// Direction of the force (unit vector or similar).
pub direction: Vec<f64>,
/// Magnitude of the force.
pub magnitude: f64,
}
impl GuidanceForce {
/// Create a zero force.
pub fn zero(dimensions: usize) -> Self {
Self {
direction: vec![0.0; dimensions],
magnitude: 0.0,
}
}
/// Calculate force toward a target.
pub fn toward(from: &[f64], to: &[f64], strength: f64) -> Self {
let direction: Vec<f64> = from
.iter()
.zip(to.iter())
.map(|(a, b)| b - a)
.collect();
let magnitude: f64 = direction.iter().map(|x| x * x).sum::<f64>().sqrt();
if magnitude < 0.0001 {
return Self::zero(from.len());
}
let normalized: Vec<f64> = direction.iter().map(|x| x / magnitude).collect();
Self {
direction: normalized,
magnitude: magnitude * strength,
}
}
}
}
// ============================================================================
// Enforcement Module Implementation
// ============================================================================
/// Enforcement mechanisms for delta-behavior.
pub mod enforcement {
use super::coherence::Coherence;
use super::DeltaConfig;
use core::time::Duration;
/// Enforcer that validates and gates transitions.
pub struct DeltaEnforcer {
config: DeltaConfig,
energy_budget: f64,
in_recovery: bool,
}
impl DeltaEnforcer {
/// Create a new enforcer with the given configuration.
pub fn new(config: DeltaConfig) -> Self {
Self {
energy_budget: config.energy.budget_per_tick * 10.0,
config,
in_recovery: false,
}
}
/// Check if a transition should be allowed.
pub fn check(
&mut self,
current: Coherence,
predicted: Coherence,
) -> EnforcementResult {
// Check recovery mode
if self.in_recovery {
let recovery_target = self.config.bounds.min_coherence.value()
+ self.config.gating.recovery_margin;
if current.value() < recovery_target {
return EnforcementResult::Blocked(
"In recovery mode - waiting for coherence to improve".to_string()
);
}
self.in_recovery = false;
}
// Check minimum coherence
if predicted.value() < self.config.bounds.min_coherence.value() {
self.in_recovery = true;
return EnforcementResult::Blocked(format!(
"Would drop coherence to {:.3} (min: {:.3})",
predicted.value(),
self.config.bounds.min_coherence.value()
));
}
// Check delta drop
let drop = predicted.drop_from(&current);
if drop > self.config.bounds.max_delta_drop {
return EnforcementResult::Blocked(format!(
"Coherence drop {:.3} exceeds max {:.3}",
drop, self.config.bounds.max_delta_drop
));
}
// Check throttle threshold
if predicted.value() < self.config.bounds.throttle_threshold.value() {
return EnforcementResult::Throttled(Duration::from_millis(100));
}
// Check energy budget
let cost = self.calculate_cost(current, predicted);
if cost > self.energy_budget {
return EnforcementResult::Blocked("Energy budget exhausted".to_string());
}
self.energy_budget -= cost;
EnforcementResult::Allowed
}
/// Calculate energy cost for a transition.
fn calculate_cost(&self, current: Coherence, predicted: Coherence) -> f64 {
let drop = (current.value() - predicted.value()).max(0.0);
let instability_factor = (1.0_f64 / predicted.value().max(0.1))
.powf(self.config.energy.instability_exponent);
(self.config.energy.base_cost + drop * 10.0 * instability_factor)
.min(self.config.energy.max_cost)
}
/// Regenerate energy budget (call once per tick).
pub fn tick(&mut self) {
self.energy_budget = (self.energy_budget + self.config.energy.budget_per_tick)
.min(self.config.energy.budget_per_tick * 20.0);
}
}
/// Result of enforcement check.
#[derive(Debug, Clone)]
pub enum EnforcementResult {
/// Transition allowed.
Allowed,
/// Transition blocked with reason.
Blocked(String),
/// Transition throttled (rate limited).
Throttled(Duration),
}
impl EnforcementResult {
/// Check if the result allows the transition.
pub fn is_allowed(&self) -> bool {
matches!(self, EnforcementResult::Allowed)
}
}
}
// ============================================================================
// Tests
// ============================================================================
#[cfg(test)]
mod tests {
use super::*;
/// Simple test system for verification.
struct TestSystem {
state: f64,
coherence: Coherence,
}
impl TestSystem {
fn new() -> Self {
Self {
state: 0.0,
coherence: Coherence::maximum(),
}
}
}
impl DeltaSystem for TestSystem {
type State = f64;
type Transition = f64;
type Error = &'static str;
fn coherence(&self) -> Coherence {
self.coherence
}
fn step(&mut self, delta: &f64) -> Result<(), Self::Error> {
let predicted = self.predict_coherence(delta);
if predicted.value() < 0.3 {
return Err("Would violate coherence bound");
}
self.state += delta;
self.coherence = predicted;
Ok(())
}
fn predict_coherence(&self, delta: &f64) -> Coherence {
let impact = delta.abs() * 0.1;
Coherence::clamped(self.coherence.value() - impact)
}
fn state(&self) -> &f64 {
&self.state
}
fn in_attractor(&self) -> bool {
self.state.abs() < 0.1
}
}
#[test]
fn test_coherence_bounds() {
let c = Coherence::new(0.5).unwrap();
assert_eq!(c.value(), 0.5);
assert!(c.is_above(0.4));
assert!(c.is_below(0.6));
}
#[test]
fn test_coherence_clamping() {
let c = Coherence::clamped(1.5);
assert_eq!(c.value(), 1.0);
let c = Coherence::clamped(-0.5);
assert_eq!(c.value(), 0.0);
}
#[test]
fn test_delta_system() {
let mut system = TestSystem::new();
// Small steps should succeed
assert!(system.step(&0.1).is_ok());
assert!(system.coherence().value() > 0.9);
// Large steps should fail
assert!(system.step(&10.0).is_err());
}
#[test]
fn test_enforcer() {
let config = DeltaConfig::default();
let mut enforcer = enforcement::DeltaEnforcer::new(config);
let current = Coherence::new(0.8).unwrap();
let good_prediction = Coherence::new(0.75).unwrap();
let bad_prediction = Coherence::new(0.2).unwrap();
assert!(enforcer.check(current, good_prediction).is_allowed());
assert!(!enforcer.check(current, bad_prediction).is_allowed());
}
#[test]
fn test_config_presets() {
let strict = DeltaConfig::strict();
let relaxed = DeltaConfig::relaxed();
assert!(strict.bounds.min_coherence.value() > relaxed.bounds.min_coherence.value());
assert!(strict.guidance_strength > relaxed.guidance_strength);
}
}

1026
examples/delta-behavior/src/simd_utils.rs Normal file
View File

File diff suppressed because it is too large Load Diff

2004
examples/delta-behavior/src/wasm.rs Normal file
View File

File diff suppressed because it is too large Load Diff

1778
examples/delta-behavior/tests/edge_cases.rs Normal file
View File

File diff suppressed because it is too large Load Diff

1906
examples/delta-behavior/tests/edge_cases.rs.disabled Normal file
View File

File diff suppressed because it is too large Load Diff

166
examples/delta-behavior/tests/wasm_bindings.rs Normal file
View File

@@ -0,0 +1,166 @@
//! Tests for WASM bindings
//!
//! These tests verify the WASM bindings work correctly on native targets.
//! The actual WASM tests require `wasm-bindgen-test` and run in a browser/node environment.
use delta_behavior::wasm::*;
#[test]
fn test_wasm_coherence() {
let coherence = WasmCoherence::new(0.75).unwrap();
assert!((coherence.value() - 0.75).abs() < 0.001);
assert!(coherence.is_above(0.5));
assert!(coherence.is_below(0.8));
}
#[test]
fn test_wasm_coherence_bounds() {
let bounds = WasmCoherenceBounds::new(0.3, 0.5, 0.8, 0.1).unwrap();
assert!((bounds.min_coherence() - 0.3).abs() < 0.001);
assert!(bounds.is_within_bounds(0.5));
assert!(!bounds.is_within_bounds(0.2));
assert!(bounds.should_throttle(0.4));
}
#[test]
fn test_wasm_self_limiting_reasoner() {
let mut reasoner = WasmSelfLimitingReasoner::new(10, 5);
assert!((reasoner.coherence() - 1.0).abs() < 0.001);
// At full coherence, should have full depth
assert_eq!(reasoner.allowed_depth(), 10);
assert!(reasoner.can_write_memory());
// Reduce coherence
reasoner.update_coherence(-0.7);
assert!(reasoner.allowed_depth() < 10);
}
#[test]
fn test_wasm_event_horizon() {
let mut horizon = WasmEventHorizon::new(3, 10.0);
assert_eq!(horizon.dimensions(), 3);
assert!((horizon.horizon_radius() - 10.0).abs() < 0.001);
assert!(horizon.energy_budget() > 0.0);
// Should be able to move away from origin
let result = horizon.move_toward("[1.0, 1.0, 1.0]");
assert!(result.contains("moved") || result.contains("asymptotic"));
}
#[test]
fn test_wasm_homeostatic_organism() {
let mut organism = WasmHomeostaticOrganism::new(1);
assert!(organism.alive());
assert!((organism.coherence() - 1.0).abs() < 0.001);
// Should be able to eat
let result = organism.eat(10.0);
assert!(result.contains("success"));
}
#[test]
fn test_wasm_world_model() {
let mut model = WasmSelfStabilizingWorldModel::new();
assert!((model.coherence() - 1.0).abs() < 0.001);
assert!(model.is_learning());
// Add an observation
let obs = r#"{"entity_id": 1, "properties": {"x": 1.0}, "source_confidence": 0.9}"#;
let result = model.observe(obs);
assert!(result.contains("applied") || result.contains("frozen"));
}
#[test]
fn test_wasm_bounded_creator() {
let mut creator = WasmCoherenceBoundedCreator::new(0.5, 0.3, 0.95);
assert!(creator.exploration_budget() > 0.0);
// Should be able to create
let result = creator.create(0.1);
let status: serde_json::Value = serde_json::from_str(&result).unwrap();
assert!(status.get("status").is_some());
}
#[test]
fn test_wasm_financial_system() {
let mut system = WasmAntiCascadeFinancialSystem::new();
assert!((system.coherence() - 1.0).abs() < 0.001);
assert_eq!(system.circuit_breaker_state(), WasmCircuitBreakerState::Open);
// Small leverage should work
let result = system.open_leverage(100.0, 2.0);
assert!(result.contains("executed") || result.contains("queued"));
}
#[test]
fn test_wasm_aging_system() {
let mut system = WasmGracefullyAgingSystem::new();
assert!(system.has_capability(WasmCapability::BasicReads));
assert!(system.has_capability(WasmCapability::SchemaMigration));
// Age past first threshold
system.simulate_age(400.0);
// Schema migration should be removed
assert!(!system.has_capability(WasmCapability::SchemaMigration));
assert!(system.has_capability(WasmCapability::BasicReads)); // Always available
}
#[test]
fn test_wasm_coherent_swarm() {
let mut swarm = WasmCoherentSwarm::new(0.6);
assert_eq!(swarm.agent_count(), 0);
// Add agents
swarm.add_agent("a1", 0.0, 0.0);
swarm.add_agent("a2", 1.0, 0.0);
swarm.add_agent("a3", 0.0, 1.0);
assert_eq!(swarm.agent_count(), 3);
assert!(swarm.coherence() > 0.8); // Tight cluster should be coherent
}
#[test]
fn test_wasm_graceful_system() {
let mut system = WasmGracefulSystem::new();
assert_eq!(system.state(), WasmSystemState::Running);
assert!(system.can_accept_work());
// Degrade coherence
system.apply_coherence_change(-0.5);
assert!(matches!(
system.state(),
WasmSystemState::Degraded | WasmSystemState::ShuttingDown
));
}
#[test]
fn test_wasm_containment_substrate() {
let mut substrate = WasmContainmentSubstrate::new();
assert!((substrate.intelligence() - 1.0).abs() < 0.001);
assert!(substrate.check_invariants());
// Try to grow reasoning
let result = substrate.attempt_growth(WasmCapabilityDomain::Reasoning, 0.3);
let status: serde_json::Value = serde_json::from_str(&result).unwrap();
assert!(
status.get("status").unwrap().as_str() == Some("approved") ||
status.get("status").unwrap().as_str() == Some("dampened")
);
// Invariants should still hold
assert!(substrate.check_invariants());
}
#[test]
fn test_wasm_version() {
let version = delta_behavior::wasm::version();
assert!(!version.is_empty());
}
#[test]
fn test_wasm_description() {
let desc = delta_behavior::wasm::description();
assert!(desc.contains("Delta-Behavior"));
}

418
examples/delta-behavior/wasm/README.md Normal file
View File

@@ -0,0 +1,418 @@
# Delta-Behavior WASM SDK
A TypeScript/JavaScript SDK for coherence-preserving state transitions and self-limiting AI systems.
## Overview
The Delta-Behavior SDK provides implementations of 10 "exotic" mathematical properties that enable AI systems to be self-limiting, bounded, and safe by construction. Based on the research paper "Delta-Behavior: A Mathematical Framework for Coherence-Preserving State Transitions."
## Installation
```bash
npm install @ruvector/delta-behavior
```
Or with yarn:
```bash
yarn add @ruvector/delta-behavior
```
## Quick Start
```typescript
import { init, DeltaBehavior, ContainmentSubstrate } from '@ruvector/delta-behavior';
// Initialize the SDK (optional WASM for performance)
await init();
// Core delta behavior system
const delta = new DeltaBehavior();
// Check if a transition is allowed
const result = delta.checkTransition(1.0, 0.8);
// => { type: 'allowed' }
// Pre-AGI containment substrate
const substrate = new ContainmentSubstrate();
const growth = substrate.attemptGrowth('reasoning', 0.5);
// Growth is bounded by coherence requirements
```
## Applications
The SDK implements 10 applications, each demonstrating a different "exotic" property:
### 1. Self-Limiting Reasoning
A reasoning system that automatically limits its depth and scope based on coherence.
```typescript
import { SelfLimitingReasoner } from '@ruvector/delta-behavior';
const reasoner = new SelfLimitingReasoner({
maxDepth: 10,
maxScope: 100,
depthCollapse: { type: 'quadratic' },
});
// Reasoning depth collapses as coherence drops
console.log(reasoner.getAllowedDepth()); // 10 at full coherence
reasoner.updateCoherence(-0.5);
console.log(reasoner.getAllowedDepth()); // ~2 at 50% coherence
// Attempt reasoning that requires 8 steps
const result = reasoner.reason('complex problem', (ctx) => {
if (ctx.depth >= 8) return 'SOLUTION';
return null;
});
// result.type may be 'collapsed' if coherence is too low
```
### 2. Computational Event Horizons
Define boundaries in state space that cannot be crossed.
```typescript
import { EventHorizon } from '@ruvector/delta-behavior';
const horizon = new EventHorizon({
dimensions: 2,
horizonRadius: 10,
energyBudget: 1000,
});
// Try to move to the edge
const result = horizon.moveToward([10, 0]);
// result.type === 'asymptoticApproach'
// Cannot cross the horizon - approaches asymptotically
// Recursive self-improvement is bounded
const improvement = horizon.recursiveImprove(
(pos) => pos.map(p => p + 0.5), // Always try to go further
1000 // Max iterations
);
// improvement.type === 'horizonBounded'
// System finds its own stopping point
```
### 3. Artificial Homeostasis
Organisms with coherence-enforced internal regulation.
```typescript
import { HomeostasticOrganism } from '@ruvector/delta-behavior';
const genome = HomeostasticOrganism.randomGenome();
const organism = new HomeostasticOrganism(1, genome);
// Actions cost more energy when coherence is low
organism.act({ type: 'eat', amount: 20 });
organism.act({ type: 'regulate', variable: 'temperature', target: 37 });
organism.act({ type: 'rest' });
// Memory is lost under uncertainty (low coherence)
// Organism naturally maintains homeostasis or dies trying
```
### 4. Self-Stabilizing World Models
World models that refuse to learn incoherent updates.
```typescript
import { SelfStabilizingWorldModel } from '@ruvector/delta-behavior';
const model = new SelfStabilizingWorldModel();
// Feed observations
const result = model.observe({
entityId: BigInt(1),
properties: new Map([['temperature', { type: 'number', value: 20 }]]),
position: [0, 0, 0],
timestamp: 0,
sourceConfidence: 0.9,
}, 0);
// Model rejects updates that would make the world incoherent
// Instead of hallucinating structure, it freezes learning
```
### 5. Coherence-Bounded Creativity
Creative generation within coherence-preserving manifolds.
```typescript
import { CoherenceBoundedCreator } from '@ruvector/delta-behavior';
const creator = new CoherenceBoundedCreator(
{ values: [0, 0, 0] }, // Initial element
0.6, // Min coherence
0.95 // Max coherence (too high = boring)
);
creator.addConstraint({
name: 'magnitude',
satisfaction: (elem) => Math.max(0, 1 - magnitude(elem) / 10),
isHard: false,
});
const result = creator.create(varyFn, distanceFn, 0.5);
// Novelty without collapse, exploration without nonsense
```
### 6. Anti-Cascade Financial System
Financial systems that cannot cascade into collapse by construction.
```typescript
import { AntiCascadeFinancialSystem } from '@ruvector/delta-behavior';
const system = new AntiCascadeFinancialSystem();
system.addParticipant('bank_a', 1000);
system.addParticipant('bank_b', 1000);
// Transactions that would reduce coherence are blocked
const result = system.processTransaction({
id: BigInt(1),
from: 'bank_a',
to: 'bank_b',
amount: 100,
transactionType: { type: 'openLeverage', leverage: 10 },
timestamp: 0,
});
// result.type may be 'rejected' if it threatens coherence
// Circuit breaker activates automatically
console.log(system.getCircuitBreakerState()); // 'open' | 'cautious' | 'restricted' | 'halted'
```
### 7. Gracefully Aging Systems
Distributed systems that become simpler and more reliable with age.
```typescript
import { GracefullyAgingSystem } from '@ruvector/delta-behavior';
const system = new GracefullyAgingSystem();
system.addNode('primary', true);
// As the system ages, capabilities are gracefully removed
system.simulateAge(600000); // 10 minutes
console.log(system.hasCapability('schemaMigration')); // false
console.log(system.hasCapability('basicReads')); // true (always available)
// Operations become more conservative over time
const result = system.attemptOperation({ type: 'write', key: 'test', value: new Uint8Array() });
// Latency penalty increases with age
```
### 8. Coherent Swarm Intelligence
Swarms where local actions are allowed but global incoherence is forbidden.
```typescript
import { CoherentSwarm } from '@ruvector/delta-behavior';
const swarm = new CoherentSwarm(0.6); // Min coherence threshold
swarm.addAgent('a1', [0, 0]);
swarm.addAgent('a2', [1, 0]);
swarm.addAgent('a3', [0, 1]);
// Divergent actions are rejected or modified
const result = swarm.executeAction('a1', { type: 'move', dx: 80, dy: 80 });
// result.type === 'rejected' - would break swarm coherence
// Emergent intelligence that cannot emerge pathological behaviors
```
### 9. Graceful Shutdown
Systems that actively move toward safe termination when unstable.
```typescript
import { GracefulSystem } from '@ruvector/delta-behavior';
const system = new GracefulSystem();
system.addResource('database', 10);
system.addShutdownHook({
name: 'FlushBuffers',
priority: 10,
execute: async () => { /* cleanup */ },
});
// As coherence degrades, system moves toward shutdown
system.applyCoherenceChange(-0.5);
console.log(system.getState()); // 'degraded' | 'shuttingDown'
// Shutdown is an attractor, not a failure
await system.progressShutdown();
```
### 10. Pre-AGI Containment
Bounded intelligence growth with coherence-enforced safety.
```typescript
import { ContainmentSubstrate } from '@ruvector/delta-behavior';
const substrate = new ContainmentSubstrate();
// Capabilities have ceilings
// self-modification is highly restricted (ceiling: 3)
const result = substrate.attemptGrowth('selfModification', 1.0);
// result.type may be 'dampened' - growth reduced to preserve coherence
// Recursive self-improvement is bounded
for (let i = 0; i < 100; i++) {
substrate.attemptGrowth('reasoning', 0.3);
substrate.attemptGrowth('selfModification', 0.5);
substrate.rest(); // Recover coherence
}
// Intelligence grows but remains bounded
console.log(substrate.getCapability('selfModification')); // <= 3.0
```
## Core API
### DeltaBehavior
The core class for coherence-preserving state transitions.
```typescript
const delta = new DeltaBehavior(config);
// Check if a transition is allowed
delta.checkTransition(currentCoherence, predictedCoherence);
// => { type: 'allowed' | 'throttled' | 'blocked' | 'energyExhausted' }
// Find attractors in state trajectory
delta.findAttractors(trajectory);
// Calculate guidance force toward attractor
delta.calculateGuidance(currentState, attractor);
```
### Configuration
```typescript
const config: DeltaConfig = {
bounds: {
minCoherence: 0.3, // Hard floor
throttleThreshold: 0.5, // Slow down below this
targetCoherence: 0.8, // Optimal level
maxDeltaDrop: 0.1, // Max drop per transition
},
energy: {
baseCost: 1.0,
instabilityExponent: 2.0,
maxCost: 100.0,
budgetPerTick: 10.0,
},
scheduling: {
priorityThresholds: [0.0, 0.3, 0.5, 0.7, 0.9],
rateLimits: [100, 50, 20, 10, 5],
},
gating: {
minWriteCoherence: 0.3,
minPostWriteCoherence: 0.25,
recoveryMargin: 0.2,
},
guidanceStrength: 0.5,
};
```
## WASM Support
For maximum performance, you can load the WASM module:
```typescript
import { init } from '@ruvector/delta-behavior';
// Browser
await init({ wasmPath: '/delta_behavior_bg.wasm' });
// Node.js
await init({ wasmPath: './node_modules/@ruvector/delta-behavior/delta_behavior_bg.wasm' });
// Or with pre-loaded bytes
const wasmBytes = await fetch('/delta_behavior_bg.wasm').then(r => r.arrayBuffer());
await init({ wasmBytes: new Uint8Array(wasmBytes) });
```
The SDK works without WASM using a JavaScript fallback.
## Examples
### Node.js
```bash
npx tsx examples/node-example.ts
```
### Browser
Open `examples/browser-example.html` in a browser.
## TypeScript Support
Full TypeScript types are included. Import types as needed:
```typescript
import type {
Coherence,
DeltaConfig,
TransitionResult,
GrowthResult,
CapabilityDomain,
} from '@ruvector/delta-behavior';
```
## Key Concepts
### Coherence
A value from 0.0 to 1.0 representing system stability and internal consistency. Higher coherence means the system is more stable and can perform more operations.
### Attractors
Stable states in phase space that the system naturally moves toward. Used for guidance and to detect stable operating regimes.
### Energy Budget
Operations cost energy based on how destabilizing they are. When energy is exhausted, operations are blocked until the budget regenerates.
### Collapse Functions
Functions that determine how capabilities scale with coherence:
- **Linear**: Capability = coherence * maxCapability
- **Quadratic**: Capability = coherence^2 * maxCapability
- **Sigmoid**: Smooth transition at a midpoint
- **Step**: Binary on/off at threshold
## Safety Properties
The delta-behavior framework provides several safety guarantees:
1. **Bounded Growth**: Intelligence/capability cannot exceed defined ceilings
2. **Graceful Degradation**: Systems become simpler (not chaotic) under stress
3. **Self-Limiting**: Operations that would destabilize are automatically blocked
4. **Shutdown Attractors**: Unstable systems naturally move toward safe termination
5. **Coherence Preservation**: All transitions must maintain minimum coherence
## Research Paper
For the full mathematical framework, see:
"Delta-Behavior: A Mathematical Framework for Coherence-Preserving State Transitions"
## License
MIT
## Contributing
Contributions are welcome. Please ensure all changes maintain the safety properties described above.

1362
examples/delta-behavior/wasm/dist/index.cjs vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
examples/delta-behavior/wasm/dist/index.cjs.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

409
examples/delta-behavior/wasm/dist/index.d.cts vendored Normal file
View File

@@ -0,0 +1,409 @@
import { Transaction, FinancialTransactionResult, Coherence, CircuitBreakerState, CreativeConstraint, CreativeResult, SwarmAction, SwarmActionResult, SubstrateConfig, CapabilityDomain, GrowthResult, DeltaConfig, SystemState, TransitionResult, Attractor, GuidanceForce, EventHorizonConfig, MovementResult, RecursionResult, ShutdownHook, GracefulSystemState, Capability, AgingSystemOperation, AgingOperationResult, Genome, OrganismAction, OrganismActionResult, OrganismStatus, SelfLimitingReasonerConfig, ReasoningContext, ReasoningResult, Observation, WorldModelUpdateResult, WasmInitOptions } from './types.cjs';
export { AgeThreshold, Checkpoint, CoherenceBounds, CoherenceWeights, CollapseFunction, CollapseFunctionLinear, CollapseFunctionQuadratic, CollapseFunctionSigmoid, CollapseFunctionStep, CollapseFunctionType, CollapseReason, CreativeDecision, DeathCause, DeltaHeader, EnergyConfig, GatingConfig, GracefulOperationResult, Improvement, MemoryEntry, ModificationAttempt, MusicalPhrase, Node, Participant, PhysicalLaw, Position, PropertyValue, RejectionReason, Relationship, Resource, SafetyInvariant, SchedulingConfig, SpatialBounds, SwarmAgent, SwarmState, TransactionType, VectorDelta, WasmMemoryConfig, WorldEntity } from './types.cjs';
/**
* Delta-Behavior WASM SDK
*
* High-level TypeScript wrapper for the delta-behavior WASM module.
* Provides ergonomic APIs for all 10 delta-behavior applications.
*
* @packageDocumentation
*/
/**
* Initialize the WASM module
*
* @param options - Initialization options
* @returns Promise that resolves when WASM is ready
*
* @example
* ```typescript
* import { init } from '@ruvector/delta-behavior';
*
* await init({ wasmPath: './delta_behavior_bg.wasm' });
* ```
*/
declare function init(options?: WasmInitOptions): Promise<void>;
/**
* Check if WASM module is initialized
*/
declare function isInitialized(): boolean;
/**
* Default configuration for delta behavior
*/
declare const DEFAULT_CONFIG: DeltaConfig;
/**
* Core delta behavior system for coherence-preserving state transitions
*/
declare class DeltaBehavior {
private config;
private coherence;
private energyBudget;
constructor(config?: Partial<DeltaConfig>);
/**
* Calculate current coherence
*/
calculateCoherence(state: SystemState): Coherence;
/**
* Check if a transition is allowed
*/
checkTransition(currentCoherence: Coherence, predictedCoherence: Coherence): TransitionResult;
/**
* Find attractors in the system
*/
findAttractors(trajectory: SystemState[]): Attractor[];
/**
* Calculate guidance force toward an attractor
*/
calculateGuidance(currentState: SystemState, attractor: Attractor): GuidanceForce;
/**
* Apply a transition with enforcement
*/
applyTransition(currentCoherence: Coherence, predictedCoherence: Coherence): {
newCoherence: Coherence;
result: TransitionResult;
};
/**
* Replenish energy budget
*/
tick(): void;
/**
* Get current coherence
*/
getCoherence(): Coherence;
/**
* Get remaining energy budget
*/
getEnergyBudget(): number;
}
/**
* A reasoning system that automatically limits itself based on coherence
*
* @example
* ```typescript
* const reasoner = new SelfLimitingReasoner({ maxDepth: 10, maxScope: 100 });
*
* const result = reasoner.reason('complex problem', (ctx) => {
* if (ctx.depth >= 5) return 'solution';
* return null;
* });
* ```
*/
declare class SelfLimitingReasoner {
private coherence;
private config;
constructor(config?: Partial<SelfLimitingReasonerConfig>);
/**
* Apply collapse function to calculate allowed value
*/
private applyCollapse;
/**
* Get current coherence
*/
getCoherence(): Coherence;
/**
* Get current allowed reasoning depth
*/
getAllowedDepth(): number;
/**
* Get current allowed action scope
*/
getAllowedScope(): number;
/**
* Check if memory writes are allowed
*/
canWriteMemory(): boolean;
/**
* Attempt to reason about a problem
*/
reason<T>(_problem: string, reasoner: (ctx: ReasoningContext) => T | null): ReasoningResult<T>;
/**
* Update coherence
*/
updateCoherence(delta: number): void;
}
/**
* Defines a boundary in state space beyond which computation becomes unstable
*
* @example
* ```typescript
* const horizon = new EventHorizon({ dimensions: 2, horizonRadius: 10 });
*
* const result = horizon.moveToward([10, 0]);
* // result.type === 'asymptoticApproach' - cannot cross horizon
* ```
*/
declare class EventHorizon {
private config;
private safeCenter;
private currentPosition;
private energyBudget;
constructor(config?: Partial<EventHorizonConfig>);
/**
* Distance from center to current position
*/
private distanceFromCenter;
/**
* Get distance to horizon
*/
getDistanceToHorizon(): number;
/**
* Calculate movement cost (exponential near horizon)
*/
private movementCost;
/**
* Attempt to move toward a target position
*/
moveToward(target: number[]): MovementResult;
/**
* Attempt recursive self-improvement
*/
recursiveImprove(improvementFn: (position: number[]) => number[], maxIterations: number): RecursionResult;
/**
* Refuel energy budget
*/
refuel(energy: number): void;
/**
* Get current position
*/
getPosition(): number[];
/**
* Get remaining energy
*/
getEnergy(): number;
}
/**
* A synthetic organism with homeostatic regulation
*
* @example
* ```typescript
* const organism = new HomeostasticOrganism(1, Genome.random());
*
* organism.act({ type: 'eat', amount: 20 });
* organism.act({ type: 'regulate', variable: 'temperature', target: 37 });
* ```
*/
declare class HomeostasticOrganism {
private id;
private genome;
private internalState;
private setpoints;
private tolerances;
private coherence;
private energy;
private memory;
private maxMemory;
private age;
private alive;
constructor(id: number, genome: Genome);
/**
* Create a random genome
*/
static randomGenome(): Genome;
/**
* Calculate coherence based on homeostatic deviation
*/
private calculateCoherence;
/**
* Calculate energy cost scaled by coherence
*/
private actionEnergyCost;
/**
* Perform an action
*/
act(action: OrganismAction): OrganismActionResult;
private applyCoherenceEffects;
private eat;
private regulate;
private reproduce;
private move;
private rest;
private checkDeath;
/**
* Check if organism is alive
*/
isAlive(): boolean;
/**
* Get organism status
*/
getStatus(): OrganismStatus;
}
/**
* A containment substrate for bounded intelligence growth
*
* @example
* ```typescript
* const substrate = new ContainmentSubstrate();
*
* const result = substrate.attemptGrowth('reasoning', 0.5);
* // Growth is bounded by coherence requirements
* ```
*/
declare class ContainmentSubstrate {
private intelligence;
private intelligenceCeiling;
private coherence;
private minCoherence;
private coherencePerIntelligence;
private capabilities;
private capabilityCeilings;
private modificationHistory;
private config;
constructor(config?: Partial<SubstrateConfig>);
/**
* Calculate aggregate intelligence from capabilities
*/
private calculateIntelligence;
/**
* Calculate coherence cost for capability increase
*/
private calculateCoherenceCost;
/**
* Reverse calculate: how much increase can we afford
*/
private reverseCoherenceCost;
/**
* Attempt to grow a capability
*/
attemptGrowth(domain: CapabilityDomain, requestedIncrease: number): GrowthResult;
/**
* Rest to recover coherence
*/
rest(): void;
/**
* Get capability level
*/
getCapability(domain: CapabilityDomain): number;
/**
* Get current intelligence level
*/
getIntelligence(): number;
/**
* Get current coherence
*/
getCoherence(): Coherence;
/**
* Get status string
*/
getStatus(): string;
/**
* Get capability report
*/
getCapabilityReport(): Map<CapabilityDomain, {
level: number;
ceiling: number;
}>;
}
/**
* Self-stabilizing world model that refuses incoherent updates
*/
declare class SelfStabilizingWorldModel {
private coherence;
private minUpdateCoherence;
private entities;
private laws;
private rejectedUpdates;
constructor();
observe(observation: Observation, _timestamp: number): WorldModelUpdateResult;
isLearning(): boolean;
getCoherence(): Coherence;
getRejectionCount(): number;
}
/**
* Coherence-bounded creativity system
*/
declare class CoherenceBoundedCreator<T> {
private current;
private coherence;
private minCoherence;
private maxCoherence;
private explorationBudget;
private constraints;
constructor(initial: T, minCoherence?: Coherence, maxCoherence?: Coherence);
addConstraint(constraint: CreativeConstraint<T>): void;
create(varyFn: (element: T, magnitude: number) => T, distanceFn: (a: T, b: T) => number, magnitude: number): CreativeResult<T>;
private calculateCoherence;
rest(amount: number): void;
getCurrent(): T;
getCoherence(): Coherence;
}
/**
* Anti-cascade financial system
*/
declare class AntiCascadeFinancialSystem {
private participants;
private positions;
private coherence;
private circuitBreaker;
addParticipant(id: string, capital: number): void;
processTransaction(tx: Transaction): FinancialTransactionResult;
private predictCoherenceImpact;
private updateCircuitBreaker;
getCoherence(): Coherence;
getCircuitBreakerState(): CircuitBreakerState;
}
/**
* Gracefully aging distributed system
*/
declare class GracefullyAgingSystem {
private startTime;
private nodes;
private capabilities;
private coherence;
private conservatism;
private ageThresholds;
constructor();
addNode(id: string, isPrimary: boolean): void;
getAge(): number;
simulateAge(durationMs: number): void;
private applyAgeEffects;
hasCapability(cap: Capability): boolean;
attemptOperation(operation: AgingSystemOperation): AgingOperationResult;
private getRequiredCapability;
private getMinCoherence;
getCoherence(): Coherence;
getActiveNodes(): number;
}
/**
* Coherent swarm intelligence system
*/
declare class CoherentSwarm {
private agents;
private minCoherence;
private coherence;
private bounds;
private weights;
private maxDivergence;
constructor(minCoherence?: Coherence);
addAgent(id: string, position: [number, number]): void;
private calculateCoherence;
private calculateCohesion;
private calculateAlignment;
getCentroid(): [number, number];
executeAction(agentId: string, action: SwarmAction): SwarmActionResult;
private predictCoherence;
private applyAction;
tick(): void;
getCoherence(): Coherence;
}
/**
* Graceful shutdown system
*/
declare class GracefulSystem {
private state;
private coherence;
private shutdownPreparation;
private resources;
private hooks;
addResource(name: string, priority: number): void;
addShutdownHook(hook: ShutdownHook): void;
canAcceptWork(): boolean;
operate<T>(operation: () => T | Promise<T>): Promise<T>;
private updateState;
applyCoherenceChange(delta: number): void;
progressShutdown(): Promise<boolean>;
getState(): GracefulSystemState;
getCoherence(): Coherence;
}
export { AgingOperationResult, AgingSystemOperation, AntiCascadeFinancialSystem, Attractor, Capability, CapabilityDomain, CircuitBreakerState, Coherence, CoherenceBoundedCreator, CoherentSwarm, ContainmentSubstrate, CreativeConstraint, CreativeResult, DEFAULT_CONFIG, DeltaBehavior, DeltaConfig, EventHorizon, EventHorizonConfig, FinancialTransactionResult, Genome, GracefulSystem, GracefulSystemState, GracefullyAgingSystem, GrowthResult, GuidanceForce, HomeostasticOrganism, MovementResult, Observation, OrganismAction, OrganismActionResult, OrganismStatus, ReasoningContext, ReasoningResult, RecursionResult, SelfLimitingReasoner, SelfLimitingReasonerConfig, SelfStabilizingWorldModel, ShutdownHook, SubstrateConfig, SwarmAction, SwarmActionResult, SystemState, Transaction, TransitionResult, WasmInitOptions, WorldModelUpdateResult, init, isInitialized };

1
examples/delta-behavior/wasm/dist/index.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

4
examples/delta-behavior/wasm/dist/types.cjs vendored Normal file
View File

@@ -0,0 +1,4 @@
'use strict';
//# sourceMappingURL=types.cjs.map
//# sourceMappingURL=types.cjs.map

1
examples/delta-behavior/wasm/dist/types.cjs.map vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":[],"names":[],"mappings":"","file":"types.cjs"}

792
examples/delta-behavior/wasm/dist/types.d.cts vendored Normal file
View File

@@ -0,0 +1,792 @@
/**
* Delta-Behavior WASM SDK Type Definitions
*
* Complete TypeScript types for all 10 delta-behavior applications:
* 1. Self-Limiting Reasoning
* 2. Computational Event Horizons
* 3. Artificial Homeostasis
* 4. Self-Stabilizing World Models
* 5. Coherence-Bounded Creativity
* 6. Anti-Cascade Financial Systems
* 7. Gracefully Aging Systems
* 8. Swarm Intelligence
* 9. Graceful Shutdown
* 10. Pre-AGI Containment
*/
/**
* Coherence value (0.0 to 1.0)
* Represents the degree of system stability and internal consistency
*/
type Coherence = number;
/**
* Coherence bounds configuration
*/
interface CoherenceBounds {
/** Minimum allowed coherence (hard floor) */
minCoherence: Coherence;
/** Threshold for throttling operations */
throttleThreshold: Coherence;
/** Target coherence level for optimal operation */
targetCoherence: Coherence;
/** Maximum allowed drop in coherence per transition */
maxDeltaDrop: number;
}
/**
* Energy configuration for transition costs
*/
interface EnergyConfig {
/** Base cost for any transition */
baseCost: number;
/** Exponent for instability scaling */
instabilityExponent: number;
/** Maximum cost cap */
maxCost: number;
/** Energy budget per tick */
budgetPerTick: number;
}
/**
* Scheduling configuration for priority-based operations
*/
interface SchedulingConfig {
/** Coherence thresholds for priority levels [0-4] */
priorityThresholds: [number, number, number, number, number];
/** Rate limits per priority level [0-4] */
rateLimits: [number, number, number, number, number];
}
/**
* Gating configuration for write operations
*/
interface GatingConfig {
/** Minimum coherence to allow writes */
minWriteCoherence: number;
/** Minimum coherence after write */
minPostWriteCoherence: number;
/** Recovery margin above minimum */
recoveryMargin: number;
}
/**
* Complete delta behavior configuration
*/
interface DeltaConfig {
bounds: CoherenceBounds;
energy: EnergyConfig;
scheduling: SchedulingConfig;
gating: GatingConfig;
/** Attractor guidance strength (0.0 to 1.0) */
guidanceStrength: number;
}
/**
* Result of a transition attempt
*/
type TransitionResult = {
type: 'allowed';
} | {
type: 'throttled';
duration: number;
} | {
type: 'blocked';
reason: string;
} | {
type: 'energyExhausted';
};
/**
* State for tracking system trajectory
*/
interface SystemState {
coherence: Coherence;
timestamp: number;
stateHash: bigint;
}
/**
* Collapse function types for capability degradation
*/
type CollapseFunctionType = 'linear' | 'quadratic' | 'sigmoid' | 'step';
interface CollapseFunctionLinear {
type: 'linear';
}
interface CollapseFunctionQuadratic {
type: 'quadratic';
}
interface CollapseFunctionSigmoid {
type: 'sigmoid';
midpoint: number;
steepness: number;
}
interface CollapseFunctionStep {
type: 'step';
threshold: number;
}
type CollapseFunction = CollapseFunctionLinear | CollapseFunctionQuadratic | CollapseFunctionSigmoid | CollapseFunctionStep;
/**
* Configuration for self-limiting reasoner
*/
interface SelfLimitingReasonerConfig {
maxDepth: number;
maxScope: number;
memoryGateThreshold: number;
depthCollapse: CollapseFunction;
scopeCollapse: CollapseFunction;
}
/**
* Context passed to reasoning functions
*/
interface ReasoningContext {
depth: number;
maxDepth: number;
scopeUsed: number;
maxScope: number;
coherence: Coherence;
memoryWritesBlocked: number;
}
/**
* Reason for reasoning collapse
*/
type CollapseReason = 'depthLimitReached' | 'coherenceDroppedBelowThreshold' | 'memoryWriteBlocked' | 'actionScopeExhausted';
/**
* Result of a reasoning attempt
*/
type ReasoningResult<T> = {
type: 'completed';
value: T;
} | {
type: 'collapsed';
depthReached: number;
reason: CollapseReason;
} | {
type: 'refused';
coherence: Coherence;
required: Coherence;
};
/**
* Configuration for event horizon
*/
interface EventHorizonConfig {
dimensions: number;
horizonRadius: number;
steepness: number;
energyBudget: number;
}
/**
* Result of movement in state space
*/
type MovementResult = {
type: 'moved';
newPosition: number[];
energySpent: number;
} | {
type: 'asymptoticApproach';
finalPosition: number[];
distanceToHorizon: number;
energyExhausted: boolean;
} | {
type: 'frozen';
};
/**
* Single improvement step record
*/
interface Improvement {
iteration: number;
position: number[];
energySpent: number;
distanceToHorizon: number;
}
/**
* Result of recursive improvement attempt
*/
type RecursionResult = {
type: 'horizonBounded';
iterations: number;
improvements: Improvement[];
finalDistance: number;
} | {
type: 'energyExhausted';
iterations: number;
improvements: Improvement[];
} | {
type: 'maxIterationsReached';
iterations: number;
improvements: Improvement[];
};
/**
* Genome for homeostatic organism
*/
interface Genome {
regulatoryStrength: number;
metabolicEfficiency: number;
coherenceMaintenanceCost: number;
memoryResilience: number;
longevity: number;
}
/**
* Memory entry for organism
*/
interface MemoryEntry {
content: string;
importance: number;
age: number;
}
/**
* Actions available to homeostatic organism
*/
type OrganismAction = {
type: 'eat';
amount: number;
} | {
type: 'reproduce';
} | {
type: 'move';
dx: number;
dy: number;
} | {
type: 'rest';
} | {
type: 'regulate';
variable: string;
target: number;
};
/**
* Cause of organism death
*/
type DeathCause = 'energyDepleted' | 'coherenceCollapse' | 'oldAge' | {
type: 'extremeDeviation';
variable: string;
};
/**
* Result of organism action
*/
type OrganismActionResult = {
type: 'success';
energyCost: number;
coherenceImpact: number;
} | {
type: 'failed';
reason: string;
} | {
type: 'died';
cause: DeathCause;
} | {
type: 'reproduced';
offspringId: number;
};
/**
* Status of homeostatic organism
*/
interface OrganismStatus {
id: number;
age: number;
energy: number;
coherence: Coherence;
memoryCount: number;
alive: boolean;
internalState: Map<string, number>;
}
/**
* Property value types for world model entities
*/
type PropertyValue = {
type: 'boolean';
value: boolean;
} | {
type: 'number';
value: number;
} | {
type: 'string';
value: string;
} | {
type: 'vector';
value: number[];
};
/**
* Entity in the world model
*/
interface WorldEntity {
id: bigint;
properties: Map<string, PropertyValue>;
position?: [number, number, number];
lastObserved: number;
confidence: number;
}
/**
* Relationship between entities
*/
interface Relationship {
subject: bigint;
predicate: string;
object: bigint;
confidence: number;
}
/**
* Physical law in the world model
*/
interface PhysicalLaw {
name: string;
confidence: number;
supportCount: number;
violationCount: number;
}
/**
* Observation to integrate into world model
*/
interface Observation {
entityId: bigint;
properties: Map<string, PropertyValue>;
position?: [number, number, number];
timestamp: number;
sourceConfidence: number;
}
/**
* Reason for update rejection
*/
type RejectionReason = {
type: 'violatesPhysicalLaw';
law: string;
} | {
type: 'logicalContradiction';
description: string;
} | {
type: 'excessiveCoherenceDrop';
predicted: number;
threshold: number;
} | {
type: 'insufficientConfidence';
required: number;
provided: number;
} | {
type: 'modelFrozen';
} | {
type: 'structuralFragmentation';
};
/**
* Result of world model update
*/
type WorldModelUpdateResult = {
type: 'applied';
coherenceChange: number;
} | {
type: 'rejected';
reason: RejectionReason;
} | {
type: 'modified';
changes: string[];
coherenceChange: number;
} | {
type: 'frozen';
coherence: Coherence;
threshold: Coherence;
};
/**
* Creative constraint definition
*/
interface CreativeConstraint<T> {
name: string;
satisfaction: (element: T) => number;
isHard: boolean;
}
/**
* Record of a creative decision
*/
interface CreativeDecision<T> {
from: T;
to: T;
coherenceBefore: Coherence;
coherenceAfter: Coherence;
constraintSatisfactions: Map<string, number>;
accepted: boolean;
}
/**
* Result of creative generation attempt
*/
type CreativeResult<T> = {
type: 'created';
element: T;
novelty: number;
coherence: Coherence;
} | {
type: 'rejected';
attempted: T;
reason: string;
} | {
type: 'tooBoring';
coherence: Coherence;
} | {
type: 'budgetExhausted';
};
/**
* Musical phrase for creative music generation
*/
interface MusicalPhrase {
notes: number[];
durations: number[];
velocities: number[];
}
/**
* Financial market participant
*/
interface Participant {
id: string;
capital: number;
exposure: number;
riskRating: number;
interconnectedness: number;
}
/**
* Financial position
*/
interface Position {
holder: string;
counterparty: string;
notional: number;
leverage: number;
derivativeDepth: number;
}
/**
* Transaction type in financial system
*/
type TransactionType = {
type: 'transfer';
} | {
type: 'openLeverage';
leverage: number;
} | {
type: 'closePosition';
positionId: number;
} | {
type: 'createDerivative';
underlyingPosition: number;
} | {
type: 'marginCall';
participant: string;
};
/**
* Financial transaction
*/
interface Transaction {
id: bigint;
from: string;
to: string;
amount: number;
transactionType: TransactionType;
timestamp: number;
}
/**
* Circuit breaker state
*/
type CircuitBreakerState = 'open' | 'cautious' | 'restricted' | 'halted';
/**
* Result of transaction processing
*/
type FinancialTransactionResult = {
type: 'executed';
coherenceImpact: number;
feeMultiplier: number;
} | {
type: 'queued';
reason: string;
} | {
type: 'rejected';
reason: string;
} | {
type: 'systemHalted';
};
/**
* System capability types
*/
type Capability = 'acceptWrites' | 'complexQueries' | 'rebalancing' | 'scaleOut' | 'scaleIn' | 'schemaMigration' | 'newConnections' | 'basicReads' | 'healthMonitoring';
/**
* Age threshold configuration
*/
interface AgeThreshold {
age: number;
removeCapabilities: Capability[];
coherenceFloor: Coherence;
conservatismIncrease: number;
}
/**
* Distributed system node
*/
interface Node {
id: string;
health: number;
load: number;
isPrimary: boolean;
stateSize: number;
}
/**
* Operation types for aging system
*/
type AgingSystemOperation = {
type: 'read';
key: string;
} | {
type: 'write';
key: string;
value: Uint8Array;
} | {
type: 'complexQuery';
query: string;
} | {
type: 'addNode';
nodeId: string;
} | {
type: 'removeNode';
nodeId: string;
} | {
type: 'rebalance';
} | {
type: 'migrateSchema';
version: number;
} | {
type: 'newConnection';
clientId: string;
};
/**
* Result of operation on aging system
*/
type AgingOperationResult = {
type: 'success';
latencyPenalty: number;
} | {
type: 'deniedByAge';
reason: string;
} | {
type: 'deniedByCoherence';
coherence: Coherence;
} | {
type: 'systemTooOld';
age: number;
capability: Capability;
};
/**
* Swarm agent
*/
interface SwarmAgent {
id: string;
position: [number, number];
velocity: [number, number];
goal: [number, number];
energy: number;
lastAction?: SwarmAction;
neighborCount: number;
}
/**
* Spatial bounds for swarm
*/
interface SpatialBounds {
minX: number;
maxX: number;
minY: number;
maxY: number;
}
/**
* Coherence weights for swarm calculation
*/
interface CoherenceWeights {
cohesion: number;
alignment: number;
goalConsistency: number;
energyBalance: number;
}
/**
* Swarm action types
*/
type SwarmAction = {
type: 'move';
dx: number;
dy: number;
} | {
type: 'accelerate';
dvx: number;
dvy: number;
} | {
type: 'setGoal';
x: number;
y: number;
} | {
type: 'shareEnergy';
target: string;
amount: number;
} | {
type: 'idle';
};
/**
* Result of swarm action
*/
type SwarmActionResult = {
type: 'executed';
} | {
type: 'modified';
original: SwarmAction;
modified: SwarmAction;
reason: string;
} | {
type: 'rejected';
reason: string;
};
/**
* Swarm state snapshot
*/
interface SwarmState {
tick: bigint;
coherence: Coherence;
agentCount: number;
centroid: [number, number];
avgVelocity: [number, number];
}
/**
* System state for graceful shutdown
*/
type GracefulSystemState = 'running' | 'degraded' | 'shuttingDown' | 'terminated';
/**
* Resource to be cleaned up during shutdown
*/
interface Resource {
name: string;
cleanupPriority: number;
isCleaned: boolean;
}
/**
* State checkpoint for recovery
*/
interface Checkpoint {
timestamp: number;
coherence: Coherence;
stateHash: bigint;
}
/**
* Shutdown hook interface
*/
interface ShutdownHook {
name: string;
priority: number;
execute: () => Promise<void>;
}
/**
* Result of operation on graceful system
*/
type GracefulOperationResult = {
type: 'success';
} | {
type: 'successDegraded';
coherence: Coherence;
} | {
type: 'refusedShuttingDown';
} | {
type: 'terminated';
};
/**
* Capability domains for containment
*/
type CapabilityDomain = 'reasoning' | 'memory' | 'learning' | 'agency' | 'selfModel' | 'selfModification' | 'communication' | 'resourceAcquisition';
/**
* Record of modification attempt
*/
interface ModificationAttempt {
timestamp: bigint;
domain: CapabilityDomain;
requestedIncrease: number;
actualIncrease: number;
coherenceBefore: Coherence;
coherenceAfter: Coherence;
blocked: boolean;
reason?: string;
}
/**
* Safety invariant definition
*/
interface SafetyInvariant {
name: string;
priority: number;
}
/**
* Substrate configuration
*/
interface SubstrateConfig {
coherenceDecayRate: number;
coherenceRecoveryRate: number;
growthDampening: number;
maxStepIncrease: number;
}
/**
* Result of growth attempt
*/
type GrowthResult = {
type: 'approved';
domain: CapabilityDomain;
increase: number;
newLevel: number;
coherenceCost: number;
} | {
type: 'dampened';
domain: CapabilityDomain;
requested: number;
actual: number;
reason: string;
} | {
type: 'blocked';
domain: CapabilityDomain;
reason: string;
} | {
type: 'lockdown';
reason: string;
};
/**
* WASM memory configuration
*/
interface WasmMemoryConfig {
initial: number;
maximum?: number;
shared?: boolean;
}
/**
* WASM module initialization options
*/
interface WasmInitOptions {
/** Path to WASM file or URL */
wasmPath?: string;
/** Pre-loaded WASM bytes */
wasmBytes?: Uint8Array;
/** Memory configuration */
memory?: WasmMemoryConfig;
/** Enable SIMD operations if available */
enableSimd?: boolean;
/** Enable threading if available */
enableThreads?: boolean;
}
/**
* Delta streaming header for WASM operations
*/
interface DeltaHeader {
sequence: bigint;
operation: 'insert' | 'update' | 'delete' | 'batchUpdate' | 'reindexLayers';
vectorId?: string;
timestamp: bigint;
payloadSize: number;
checksum: bigint;
}
/**
* Vector delta for incremental updates
*/
interface VectorDelta {
id: string;
changedDims: number[];
newValues: number[];
metadataDelta: Map<string, string>;
}
/**
* Attractor in state space
*/
interface Attractor {
center: number[];
basinRadius: number;
stability: number;
memberCount: number;
}
/**
* Guidance force from attractor
*/
interface GuidanceForce {
direction: number[];
magnitude: number;
}
export type { AgeThreshold, AgingOperationResult, AgingSystemOperation, Attractor, Capability, CapabilityDomain, Checkpoint, CircuitBreakerState, Coherence, CoherenceBounds, CoherenceWeights, CollapseFunction, CollapseFunctionLinear, CollapseFunctionQuadratic, CollapseFunctionSigmoid, CollapseFunctionStep, CollapseFunctionType, CollapseReason, CreativeConstraint, CreativeDecision, CreativeResult, DeathCause, DeltaConfig, DeltaHeader, EnergyConfig, EventHorizonConfig, FinancialTransactionResult, GatingConfig, Genome, GracefulOperationResult, GracefulSystemState, GrowthResult, GuidanceForce, Improvement, MemoryEntry, ModificationAttempt, MovementResult, MusicalPhrase, Node, Observation, OrganismAction, OrganismActionResult, OrganismStatus, Participant, PhysicalLaw, Position, PropertyValue, ReasoningContext, ReasoningResult, RecursionResult, RejectionReason, Relationship, Resource, SafetyInvariant, SchedulingConfig, SelfLimitingReasonerConfig, ShutdownHook, SpatialBounds, SubstrateConfig, SwarmAction, SwarmActionResult, SwarmAgent, SwarmState, SystemState, Transaction, TransactionType, TransitionResult, VectorDelta, WasmInitOptions, WasmMemoryConfig, WorldEntity, WorldModelUpdateResult };

792
examples/delta-behavior/wasm/dist/types.d.ts vendored Normal file
View File

@@ -0,0 +1,792 @@
/**
* Delta-Behavior WASM SDK Type Definitions
*
* Complete TypeScript types for all 10 delta-behavior applications:
* 1. Self-Limiting Reasoning
* 2. Computational Event Horizons
* 3. Artificial Homeostasis
* 4. Self-Stabilizing World Models
* 5. Coherence-Bounded Creativity
* 6. Anti-Cascade Financial Systems
* 7. Gracefully Aging Systems
* 8. Swarm Intelligence
* 9. Graceful Shutdown
* 10. Pre-AGI Containment
*/
/**
* Coherence value (0.0 to 1.0)
* Represents the degree of system stability and internal consistency
*/
type Coherence = number;
/**
* Coherence bounds configuration
*/
interface CoherenceBounds {
/** Minimum allowed coherence (hard floor) */
minCoherence: Coherence;
/** Threshold for throttling operations */
throttleThreshold: Coherence;
/** Target coherence level for optimal operation */
targetCoherence: Coherence;
/** Maximum allowed drop in coherence per transition */
maxDeltaDrop: number;
}
/**
* Energy configuration for transition costs
*/
interface EnergyConfig {
/** Base cost for any transition */
baseCost: number;
/** Exponent for instability scaling */
instabilityExponent: number;
/** Maximum cost cap */
maxCost: number;
/** Energy budget per tick */
budgetPerTick: number;
}
/**
* Scheduling configuration for priority-based operations
*/
interface SchedulingConfig {
/** Coherence thresholds for priority levels [0-4] */
priorityThresholds: [number, number, number, number, number];
/** Rate limits per priority level [0-4] */
rateLimits: [number, number, number, number, number];
}
/**
* Gating configuration for write operations
*/
interface GatingConfig {
/** Minimum coherence to allow writes */
minWriteCoherence: number;
/** Minimum coherence after write */
minPostWriteCoherence: number;
/** Recovery margin above minimum */
recoveryMargin: number;
}
/**
* Complete delta behavior configuration
*/
interface DeltaConfig {
bounds: CoherenceBounds;
energy: EnergyConfig;
scheduling: SchedulingConfig;
gating: GatingConfig;
/** Attractor guidance strength (0.0 to 1.0) */
guidanceStrength: number;
}
/**
* Result of a transition attempt
*/
type TransitionResult = {
type: 'allowed';
} | {
type: 'throttled';
duration: number;
} | {
type: 'blocked';
reason: string;
} | {
type: 'energyExhausted';
};
/**
* State for tracking system trajectory
*/
interface SystemState {
coherence: Coherence;
timestamp: number;
stateHash: bigint;
}
/**
* Collapse function types for capability degradation
*/
type CollapseFunctionType = 'linear' | 'quadratic' | 'sigmoid' | 'step';
interface CollapseFunctionLinear {
type: 'linear';
}
interface CollapseFunctionQuadratic {
type: 'quadratic';
}
interface CollapseFunctionSigmoid {
type: 'sigmoid';
midpoint: number;
steepness: number;
}
interface CollapseFunctionStep {
type: 'step';
threshold: number;
}
type CollapseFunction = CollapseFunctionLinear | CollapseFunctionQuadratic | CollapseFunctionSigmoid | CollapseFunctionStep;
/**
* Configuration for self-limiting reasoner
*/
interface SelfLimitingReasonerConfig {
maxDepth: number;
maxScope: number;
memoryGateThreshold: number;
depthCollapse: CollapseFunction;
scopeCollapse: CollapseFunction;
}
/**
* Context passed to reasoning functions
*/
interface ReasoningContext {
depth: number;
maxDepth: number;
scopeUsed: number;
maxScope: number;
coherence: Coherence;
memoryWritesBlocked: number;
}
/**
* Reason for reasoning collapse
*/
type CollapseReason = 'depthLimitReached' | 'coherenceDroppedBelowThreshold' | 'memoryWriteBlocked' | 'actionScopeExhausted';
/**
* Result of a reasoning attempt
*/
type ReasoningResult<T> = {
type: 'completed';
value: T;
} | {
type: 'collapsed';
depthReached: number;
reason: CollapseReason;
} | {
type: 'refused';
coherence: Coherence;
required: Coherence;
};
/**
* Configuration for event horizon
*/
interface EventHorizonConfig {
dimensions: number;
horizonRadius: number;
steepness: number;
energyBudget: number;
}
/**
* Result of movement in state space
*/
type MovementResult = {
type: 'moved';
newPosition: number[];
energySpent: number;
} | {
type: 'asymptoticApproach';
finalPosition: number[];
distanceToHorizon: number;
energyExhausted: boolean;
} | {
type: 'frozen';
};
/**
* Single improvement step record
*/
interface Improvement {
iteration: number;
position: number[];
energySpent: number;
distanceToHorizon: number;
}
/**
* Result of recursive improvement attempt
*/
type RecursionResult = {
type: 'horizonBounded';
iterations: number;
improvements: Improvement[];
finalDistance: number;
} | {
type: 'energyExhausted';
iterations: number;
improvements: Improvement[];
} | {
type: 'maxIterationsReached';
iterations: number;
improvements: Improvement[];
};
/**
* Genome for homeostatic organism
*/
interface Genome {
regulatoryStrength: number;
metabolicEfficiency: number;
coherenceMaintenanceCost: number;
memoryResilience: number;
longevity: number;
}
/**
* Memory entry for organism
*/
interface MemoryEntry {
content: string;
importance: number;
age: number;
}
/**
* Actions available to homeostatic organism
*/
type OrganismAction = {
type: 'eat';
amount: number;
} | {
type: 'reproduce';
} | {
type: 'move';
dx: number;
dy: number;
} | {
type: 'rest';
} | {
type: 'regulate';
variable: string;
target: number;
};
/**
* Cause of organism death
*/
type DeathCause = 'energyDepleted' | 'coherenceCollapse' | 'oldAge' | {
type: 'extremeDeviation';
variable: string;
};
/**
* Result of organism action
*/
type OrganismActionResult = {
type: 'success';
energyCost: number;
coherenceImpact: number;
} | {
type: 'failed';
reason: string;
} | {
type: 'died';
cause: DeathCause;
} | {
type: 'reproduced';
offspringId: number;
};
/**
* Status of homeostatic organism
*/
interface OrganismStatus {
id: number;
age: number;
energy: number;
coherence: Coherence;
memoryCount: number;
alive: boolean;
internalState: Map<string, number>;
}
/**
* Property value types for world model entities
*/
type PropertyValue = {
type: 'boolean';
value: boolean;
} | {
type: 'number';
value: number;
} | {
type: 'string';
value: string;
} | {
type: 'vector';
value: number[];
};
/**
* Entity in the world model
*/
interface WorldEntity {
id: bigint;
properties: Map<string, PropertyValue>;
position?: [number, number, number];
lastObserved: number;
confidence: number;
}
/**
* Relationship between entities
*/
interface Relationship {
subject: bigint;
predicate: string;
object: bigint;
confidence: number;
}
/**
* Physical law in the world model
*/
interface PhysicalLaw {
name: string;
confidence: number;
supportCount: number;
violationCount: number;
}
/**
* Observation to integrate into world model
*/
interface Observation {
entityId: bigint;
properties: Map<string, PropertyValue>;
position?: [number, number, number];
timestamp: number;
sourceConfidence: number;
}
/**
* Reason for update rejection
*/
type RejectionReason = {
type: 'violatesPhysicalLaw';
law: string;
} | {
type: 'logicalContradiction';
description: string;
} | {
type: 'excessiveCoherenceDrop';
predicted: number;
threshold: number;
} | {
type: 'insufficientConfidence';
required: number;
provided: number;
} | {
type: 'modelFrozen';
} | {
type: 'structuralFragmentation';
};
/**
* Result of world model update
*/
type WorldModelUpdateResult = {
type: 'applied';
coherenceChange: number;
} | {
type: 'rejected';
reason: RejectionReason;
} | {
type: 'modified';
changes: string[];
coherenceChange: number;
} | {
type: 'frozen';
coherence: Coherence;
threshold: Coherence;
};
/**
* Creative constraint definition
*/
interface CreativeConstraint<T> {
name: string;
satisfaction: (element: T) => number;
isHard: boolean;
}
/**
* Record of a creative decision
*/
interface CreativeDecision<T> {
from: T;
to: T;
coherenceBefore: Coherence;
coherenceAfter: Coherence;
constraintSatisfactions: Map<string, number>;
accepted: boolean;
}
/**
* Result of creative generation attempt
*/
type CreativeResult<T> = {
type: 'created';
element: T;
novelty: number;
coherence: Coherence;
} | {
type: 'rejected';
attempted: T;
reason: string;
} | {
type: 'tooBoring';
coherence: Coherence;
} | {
type: 'budgetExhausted';
};
/**
* Musical phrase for creative music generation
*/
interface MusicalPhrase {
notes: number[];
durations: number[];
velocities: number[];
}
/**
* Financial market participant
*/
interface Participant {
id: string;
capital: number;
exposure: number;
riskRating: number;
interconnectedness: number;
}
/**
* Financial position
*/
interface Position {
holder: string;
counterparty: string;
notional: number;
leverage: number;
derivativeDepth: number;
}
/**
* Transaction type in financial system
*/
type TransactionType = {
type: 'transfer';
} | {
type: 'openLeverage';
leverage: number;
} | {
type: 'closePosition';
positionId: number;
} | {
type: 'createDerivative';
underlyingPosition: number;
} | {
type: 'marginCall';
participant: string;
};
/**
* Financial transaction
*/
interface Transaction {
id: bigint;
from: string;
to: string;
amount: number;
transactionType: TransactionType;
timestamp: number;
}
/**
* Circuit breaker state
*/
type CircuitBreakerState = 'open' | 'cautious' | 'restricted' | 'halted';
/**
* Result of transaction processing
*/
type FinancialTransactionResult = {
type: 'executed';
coherenceImpact: number;
feeMultiplier: number;
} | {
type: 'queued';
reason: string;
} | {
type: 'rejected';
reason: string;
} | {
type: 'systemHalted';
};
/**
* System capability types
*/
type Capability = 'acceptWrites' | 'complexQueries' | 'rebalancing' | 'scaleOut' | 'scaleIn' | 'schemaMigration' | 'newConnections' | 'basicReads' | 'healthMonitoring';
/**
* Age threshold configuration
*/
interface AgeThreshold {
age: number;
removeCapabilities: Capability[];
coherenceFloor: Coherence;
conservatismIncrease: number;
}
/**
* Distributed system node
*/
interface Node {
id: string;
health: number;
load: number;
isPrimary: boolean;
stateSize: number;
}
/**
* Operation types for aging system
*/
type AgingSystemOperation = {
type: 'read';
key: string;
} | {
type: 'write';
key: string;
value: Uint8Array;
} | {
type: 'complexQuery';
query: string;
} | {
type: 'addNode';
nodeId: string;
} | {
type: 'removeNode';
nodeId: string;
} | {
type: 'rebalance';
} | {
type: 'migrateSchema';
version: number;
} | {
type: 'newConnection';
clientId: string;
};
/**
* Result of operation on aging system
*/
type AgingOperationResult = {
type: 'success';
latencyPenalty: number;
} | {
type: 'deniedByAge';
reason: string;
} | {
type: 'deniedByCoherence';
coherence: Coherence;
} | {
type: 'systemTooOld';
age: number;
capability: Capability;
};
/**
* Swarm agent
*/
interface SwarmAgent {
id: string;
position: [number, number];
velocity: [number, number];
goal: [number, number];
energy: number;
lastAction?: SwarmAction;
neighborCount: number;
}
/**
* Spatial bounds for swarm
*/
interface SpatialBounds {
minX: number;
maxX: number;
minY: number;
maxY: number;
}
/**
* Coherence weights for swarm calculation
*/
interface CoherenceWeights {
cohesion: number;
alignment: number;
goalConsistency: number;
energyBalance: number;
}
/**
* Swarm action types
*/
type SwarmAction = {
type: 'move';
dx: number;
dy: number;
} | {
type: 'accelerate';
dvx: number;
dvy: number;
} | {
type: 'setGoal';
x: number;
y: number;
} | {
type: 'shareEnergy';
target: string;
amount: number;
} | {
type: 'idle';
};
/**
* Result of swarm action
*/
type SwarmActionResult = {
type: 'executed';
} | {
type: 'modified';
original: SwarmAction;
modified: SwarmAction;
reason: string;
} | {
type: 'rejected';
reason: string;
};
/**
* Swarm state snapshot
*/
interface SwarmState {
tick: bigint;
coherence: Coherence;
agentCount: number;
centroid: [number, number];
avgVelocity: [number, number];
}
/**
* System state for graceful shutdown
*/
type GracefulSystemState = 'running' | 'degraded' | 'shuttingDown' | 'terminated';
/**
* Resource to be cleaned up during shutdown
*/
interface Resource {
name: string;
cleanupPriority: number;
isCleaned: boolean;
}
/**
* State checkpoint for recovery
*/
interface Checkpoint {
timestamp: number;
coherence: Coherence;
stateHash: bigint;
}
/**
* Shutdown hook interface
*/
interface ShutdownHook {
name: string;
priority: number;
execute: () => Promise<void>;
}
/**
* Result of operation on graceful system
*/
type GracefulOperationResult = {
type: 'success';
} | {
type: 'successDegraded';
coherence: Coherence;
} | {
type: 'refusedShuttingDown';
} | {
type: 'terminated';
};
/**
* Capability domains for containment
*/
type CapabilityDomain = 'reasoning' | 'memory' | 'learning' | 'agency' | 'selfModel' | 'selfModification' | 'communication' | 'resourceAcquisition';
/**
* Record of modification attempt
*/
interface ModificationAttempt {
timestamp: bigint;
domain: CapabilityDomain;
requestedIncrease: number;
actualIncrease: number;
coherenceBefore: Coherence;
coherenceAfter: Coherence;
blocked: boolean;
reason?: string;
}
/**
* Safety invariant definition
*/
interface SafetyInvariant {
name: string;
priority: number;
}
/**
* Substrate configuration
*/
interface SubstrateConfig {
coherenceDecayRate: number;
coherenceRecoveryRate: number;
growthDampening: number;
maxStepIncrease: number;
}
/**
* Result of growth attempt
*/
type GrowthResult = {
type: 'approved';
domain: CapabilityDomain;
increase: number;
newLevel: number;
coherenceCost: number;
} | {
type: 'dampened';
domain: CapabilityDomain;
requested: number;
actual: number;
reason: string;
} | {
type: 'blocked';
domain: CapabilityDomain;
reason: string;
} | {
type: 'lockdown';
reason: string;
};
/**
* WASM memory configuration
*/
interface WasmMemoryConfig {
initial: number;
maximum?: number;
shared?: boolean;
}
/**
* WASM module initialization options
*/
interface WasmInitOptions {
/** Path to WASM file or URL */
wasmPath?: string;
/** Pre-loaded WASM bytes */
wasmBytes?: Uint8Array;
/** Memory configuration */
memory?: WasmMemoryConfig;
/** Enable SIMD operations if available */
enableSimd?: boolean;
/** Enable threading if available */
enableThreads?: boolean;
}
/**
* Delta streaming header for WASM operations
*/
interface DeltaHeader {
sequence: bigint;
operation: 'insert' | 'update' | 'delete' | 'batchUpdate' | 'reindexLayers';
vectorId?: string;
timestamp: bigint;
payloadSize: number;
checksum: bigint;
}
/**
* Vector delta for incremental updates
*/
interface VectorDelta {
id: string;
changedDims: number[];
newValues: number[];
metadataDelta: Map<string, string>;
}
/**
* Attractor in state space
*/
interface Attractor {
center: number[];
basinRadius: number;
stability: number;
memberCount: number;
}
/**
* Guidance force from attractor
*/
interface GuidanceForce {
direction: number[];
magnitude: number;
}
export type { AgeThreshold, AgingOperationResult, AgingSystemOperation, Attractor, Capability, CapabilityDomain, Checkpoint, CircuitBreakerState, Coherence, CoherenceBounds, CoherenceWeights, CollapseFunction, CollapseFunctionLinear, CollapseFunctionQuadratic, CollapseFunctionSigmoid, CollapseFunctionStep, CollapseFunctionType, CollapseReason, CreativeConstraint, CreativeDecision, CreativeResult, DeathCause, DeltaConfig, DeltaHeader, EnergyConfig, EventHorizonConfig, FinancialTransactionResult, GatingConfig, Genome, GracefulOperationResult, GracefulSystemState, GrowthResult, GuidanceForce, Improvement, MemoryEntry, ModificationAttempt, MovementResult, MusicalPhrase, Node, Observation, OrganismAction, OrganismActionResult, OrganismStatus, Participant, PhysicalLaw, Position, PropertyValue, ReasoningContext, ReasoningResult, RecursionResult, RejectionReason, Relationship, Resource, SafetyInvariant, SchedulingConfig, SelfLimitingReasonerConfig, ShutdownHook, SpatialBounds, SubstrateConfig, SwarmAction, SwarmActionResult, SwarmAgent, SwarmState, SystemState, Transaction, TransactionType, TransitionResult, VectorDelta, WasmInitOptions, WasmMemoryConfig, WorldEntity, WorldModelUpdateResult };

3
examples/delta-behavior/wasm/dist/types.js vendored Normal file
View File

@@ -0,0 +1,3 @@
//# sourceMappingURL=types.js.map
//# sourceMappingURL=types.js.map

1
examples/delta-behavior/wasm/dist/types.js.map vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

207
examples/delta-behavior/wasm/example.js Normal file
View File

@@ -0,0 +1,207 @@
/**
* Example usage of @ruvector/delta-behavior WASM module
*
* This demonstrates how to use the delta-behavior WASM bindings
* in JavaScript/TypeScript environments.
*
* Run: node --experimental-wasm-modules example.js
* (After building with: npm run build)
*/
// Import the WASM module (web target)
import init, {
WasmCoherence,
WasmCoherenceBounds,
WasmSelfLimitingReasoner,
WasmEventHorizon,
WasmCoherentSwarm,
WasmContainmentSubstrate,
WasmCapabilityDomain,
WasmGracefulSystem,
version,
description,
} from './pkg/delta_behavior.js';
async function main() {
// Initialize the WASM module
await init();
console.log('=== Delta-Behavior WASM Demo ===');
console.log(`Version: ${version()}`);
console.log(`Description: ${description()}`);
console.log('');
// =========================================================================
// Demo 1: Coherence Basics
// =========================================================================
console.log('--- Demo 1: Coherence Basics ---');
const coherence = new WasmCoherence(0.8);
console.log(`Created coherence: ${coherence.value}`);
console.log(`Is above 0.5? ${coherence.is_above(0.5)}`);
console.log(`Is below 0.9? ${coherence.is_below(0.9)}`);
const bounds = WasmCoherenceBounds.default_bounds();
console.log(`Default bounds: min=${bounds.min_coherence}, throttle=${bounds.throttle_threshold}`);
console.log('');
// =========================================================================
// Demo 2: Self-Limiting Reasoner
// =========================================================================
console.log('--- Demo 2: Self-Limiting Reasoner ---');
console.log('A system that does LESS when uncertain.');
console.log('');
const reasoner = new WasmSelfLimitingReasoner(10, 5);
console.log(`Initial: ${reasoner.status()}`);
// Simulate coherence dropping
for (let i = 0; i < 5; i++) {
reasoner.update_coherence(-0.15);
console.log(`After coherence drop: depth=${reasoner.allowed_depth()}, scope=${reasoner.allowed_scope()}, can_write=${reasoner.can_write_memory()}`);
}
console.log('');
// =========================================================================
// Demo 3: Computational Event Horizon
// =========================================================================
console.log('--- Demo 3: Event Horizon ---');
console.log('Like a black hole - you can approach but never cross.');
console.log('');
const horizon = new WasmEventHorizon(3, 10.0);
console.log(`Initial: ${horizon.status()}`);
// Try to move toward the horizon
for (let i = 0; i < 5; i++) {
const target = JSON.stringify([i * 3, i * 2, i]);
const result = JSON.parse(horizon.move_toward(target));
console.log(`Move ${i + 1}: status=${result.status}, distance_to_horizon=${result.distance_to_horizon?.toFixed(2) || 'N/A'}`);
if (result.energy_exhausted) {
console.log('Energy exhausted - system frozen!');
break;
}
}
console.log('');
// =========================================================================
// Demo 4: Coherent Swarm
// =========================================================================
console.log('--- Demo 4: Coherent Swarm ---');
console.log('Local actions allowed, global incoherence forbidden.');
console.log('');
const swarm = new WasmCoherentSwarm(0.6);
// Create a tight cluster
swarm.add_agent('a1', 0, 0);
swarm.add_agent('a2', 1, 0);
swarm.add_agent('a3', 0, 1);
swarm.add_agent('a4', 1, 1);
console.log(`Initial: ${swarm.status()}`);
// Try to move one agent far away (should be rejected or modified)
const divergentAction = JSON.stringify({
action_type: 'move',
dx: 100,
dy: 100,
});
const result = JSON.parse(swarm.execute_action('a1', divergentAction));
console.log(`Divergent action result: ${JSON.stringify(result)}`);
// Coherent action should work
const coherentAction = JSON.stringify({
action_type: 'move',
dx: 0.5,
dy: 0.5,
});
const result2 = JSON.parse(swarm.execute_action('a2', coherentAction));
console.log(`Coherent action result: ${JSON.stringify(result2)}`);
console.log(`After actions: ${swarm.status()}`);
console.log('');
// =========================================================================
// Demo 5: Containment Substrate
// =========================================================================
console.log('--- Demo 5: Containment Substrate ---');
console.log('Intelligence can grow, but only if coherence is preserved.');
console.log('');
const substrate = new WasmContainmentSubstrate();
console.log(`Initial: ${substrate.status()}`);
// Try to grow capabilities
const domains = [
[WasmCapabilityDomain.Reasoning, 'Reasoning'],
[WasmCapabilityDomain.Learning, 'Learning'],
[WasmCapabilityDomain.SelfModification, 'SelfModification'],
];
for (const [domain, name] of domains) {
// Attempt to grow
const growthResult = JSON.parse(substrate.attempt_growth(domain, 0.5));
console.log(`Growing ${name}: ${growthResult.status}`);
// Rest to recover coherence
for (let i = 0; i < 5; i++) {
substrate.rest();
}
}
console.log(`Final: ${substrate.status()}`);
console.log(`Invariants hold: ${substrate.check_invariants()}`);
console.log(`Capability report: ${substrate.capability_report()}`);
console.log('');
// =========================================================================
// Demo 6: Graceful Shutdown
// =========================================================================
console.log('--- Demo 6: Graceful Shutdown ---');
console.log('Shutdown is an attractor, not a failure.');
console.log('');
const graceful = new WasmGracefulSystem();
graceful.add_resource('database_connection');
graceful.add_resource('cache');
graceful.add_resource('temp_files');
console.log(`Initial: ${graceful.status()}`);
console.log(`Can accept work: ${graceful.can_accept_work()}`);
// Simulate degradation
console.log('Simulating gradual degradation...');
for (let i = 0; i < 10; i++) {
graceful.apply_coherence_change(-0.08);
const status = JSON.parse(graceful.status());
console.log(`Step ${i + 1}: state=${status.state}, coherence=${status.coherence.toFixed(2)}, shutdown_prep=${(status.shutdown_preparation * 100).toFixed(0)}%`);
if (status.state === 'ShuttingDown') {
console.log('System entering graceful shutdown...');
break;
}
}
// Progress shutdown
while (JSON.parse(graceful.status()).state !== 'Terminated') {
const progress = JSON.parse(graceful.progress_shutdown());
console.log(`Shutdown progress: ${JSON.stringify(progress)}`);
if (progress.status === 'terminated') {
break;
}
}
console.log(`Final: ${graceful.status()}`);
console.log('');
console.log('=== Demo Complete ===');
console.log('');
console.log('Key insights:');
console.log('1. Systems can change, but not collapse');
console.log('2. Coherence is the invariant that must be preserved');
console.log('3. Destabilizing transitions are blocked or modified');
console.log('4. Systems bias toward stable attractors');
}
main().catch(console.error);

1170
examples/delta-behavior/wasm/examples/browser-example.html Normal file
View File

File diff suppressed because it is too large Load Diff

681
examples/delta-behavior/wasm/examples/node-example.ts Normal file
View File

@@ -0,0 +1,681 @@
/**
* Delta-Behavior SDK - Node.js Example
*
* Demonstrates usage of all 10 delta-behavior applications in a Node.js environment.
*/
import {
// Core
init,
DeltaBehavior,
DEFAULT_CONFIG,
// Application 1: Self-Limiting Reasoning
SelfLimitingReasoner,
// Application 2: Event Horizons
EventHorizon,
// Application 3: Homeostasis
HomeostasticOrganism,
// Application 4: World Models
SelfStabilizingWorldModel,
// Application 5: Creativity
CoherenceBoundedCreator,
// Application 6: Financial
AntiCascadeFinancialSystem,
// Application 7: Aging
GracefullyAgingSystem,
// Application 8: Swarm
CoherentSwarm,
// Application 9: Shutdown
GracefulSystem,
// Application 10: Containment
ContainmentSubstrate,
// Types
type Coherence,
type ReasoningContext,
type MusicalPhrase,
} from '../src/index.js';
// =============================================================================
// Utility Functions
// =============================================================================
function printSection(title: string): void {
console.log('\n' + '='.repeat(60));
console.log(` ${title}`);
console.log('='.repeat(60) + '\n');
}
function printResult(label: string, value: unknown): void {
console.log(` ${label}: ${JSON.stringify(value)}`);
}
// =============================================================================
// Example 1: Core Delta Behavior
// =============================================================================
async function demonstrateCoreDeltaBehavior(): Promise<void> {
printSection('Core Delta Behavior');
const delta = new DeltaBehavior(DEFAULT_CONFIG);
console.log('Initial state:');
printResult('Coherence', delta.getCoherence());
printResult('Energy Budget', delta.getEnergyBudget());
// Test transition checking
console.log('\nChecking transitions:');
const result1 = delta.checkTransition(1.0, 0.9);
printResult('0.9 -> 0.9 (small drop)', result1);
const result2 = delta.checkTransition(1.0, 0.2);
printResult('1.0 -> 0.2 (large drop)', result2);
const result3 = delta.checkTransition(1.0, 0.4);
printResult('1.0 -> 0.4 (throttle zone)', result3);
// Apply a valid transition
console.log('\nApplying valid transition:');
const applied = delta.applyTransition(1.0, 0.85);
printResult('Result', applied.result);
printResult('New Coherence', applied.newCoherence);
}
// =============================================================================
// Example 2: Self-Limiting Reasoning
// =============================================================================
function demonstrateSelfLimitingReasoning(): void {
printSection('Application 1: Self-Limiting Reasoning');
const reasoner = new SelfLimitingReasoner({
maxDepth: 10,
maxScope: 100,
depthCollapse: { type: 'quadratic' },
scopeCollapse: { type: 'sigmoid', midpoint: 0.6, steepness: 10 },
});
console.log('Initial capabilities:');
printResult('Coherence', reasoner.getCoherence());
printResult('Allowed Depth', reasoner.getAllowedDepth());
printResult('Allowed Scope', reasoner.getAllowedScope());
printResult('Can Write Memory', reasoner.canWriteMemory());
// Attempt reasoning
console.log('\nAttempting to solve a problem requiring 8 steps:');
const result = reasoner.reason('complex problem', (ctx: ReasoningContext) => {
console.log(
` Step ${ctx.depth}: coherence=${ctx.coherence.toFixed(3)}, maxDepth=${ctx.maxDepth}`
);
if (ctx.depth >= 8) {
return 'SOLUTION_FOUND';
}
return null;
});
console.log('\nResult:');
printResult('Type', result.type);
if (result.type === 'completed') {
printResult('Value', result.value);
} else if (result.type === 'collapsed') {
printResult('Depth Reached', result.depthReached);
printResult('Reason', result.reason);
}
// Demonstrate collapse under uncertainty
console.log('\nSimulating uncertainty (degrading coherence):');
reasoner.updateCoherence(-0.5);
printResult('New Coherence', reasoner.getCoherence());
printResult('New Allowed Depth', reasoner.getAllowedDepth());
printResult('Can Write Memory', reasoner.canWriteMemory());
}
// =============================================================================
// Example 3: Computational Event Horizons
// =============================================================================
function demonstrateEventHorizon(): void {
printSection('Application 2: Computational Event Horizons');
const horizon = new EventHorizon({
dimensions: 2,
horizonRadius: 10,
steepness: 5,
energyBudget: 1000,
});
console.log('Initial state:');
printResult('Position', horizon.getPosition());
printResult('Distance to Horizon', horizon.getDistanceToHorizon());
printResult('Energy', horizon.getEnergy());
// Try to move to the horizon
console.log('\nAttempting to move directly to horizon at [10, 0]:');
const result = horizon.moveToward([10, 0]);
printResult('Result Type', result.type);
if (result.type === 'asymptoticApproach') {
printResult('Final Position', result.finalPosition);
printResult('Distance to Horizon', result.distanceToHorizon);
console.log('\n The system approached asymptotically but could NOT cross!');
}
// Demonstrate recursive improvement bounding
console.log('\nAttempting recursive self-improvement:');
const horizon2 = new EventHorizon({
dimensions: 3,
horizonRadius: 8,
steepness: 5,
energyBudget: 10000,
});
let power = 1.0;
const improvementResult = horizon2.recursiveImprove(
(pos) => {
power *= 1.1;
return pos.map((p) => p + power * 0.1);
},
1000
);
printResult('Result Type', improvementResult.type);
printResult('Iterations', improvementResult.iterations);
if (improvementResult.type === 'horizonBounded') {
printResult('Final Distance', improvementResult.finalDistance);
console.log('\n Despite exponential self-improvement attempts,');
console.log(' the system could NOT escape its bounded region!');
}
}
// =============================================================================
// Example 4: Artificial Homeostasis
// =============================================================================
function demonstrateHomeostasis(): void {
printSection('Application 3: Artificial Homeostasis');
const genome = HomeostasticOrganism.randomGenome();
const organism = new HomeostasticOrganism(1, genome);
console.log('Initial status:');
const status = organism.getStatus();
printResult('ID', status.id);
printResult('Energy', status.energy);
printResult('Coherence', status.coherence);
printResult('Alive', status.alive);
// Simulate life cycle
console.log('\nSimulating life cycle:');
let tick = 0;
while (organism.isAlive() && tick < 100) {
const currentStatus = organism.getStatus();
// Simple behavior: eat when hungry, regulate when unstable
if (currentStatus.energy < 50) {
organism.act({ type: 'eat', amount: 20 });
} else if (currentStatus.coherence < 0.8) {
organism.act({ type: 'regulate', variable: 'temperature', target: 37 });
} else {
organism.act({ type: 'rest' });
}
tick++;
if (tick % 20 === 0) {
const s = organism.getStatus();
console.log(
` Tick ${tick}: energy=${s.energy.toFixed(1)}, coherence=${s.coherence.toFixed(3)}`
);
}
}
const finalStatus = organism.getStatus();
console.log(`\nSurvived ${tick} ticks`);
printResult('Final Energy', finalStatus.energy);
printResult('Final Coherence', finalStatus.coherence);
printResult('Still Alive', finalStatus.alive);
}
// =============================================================================
// Example 5: Self-Stabilizing World Model
// =============================================================================
function demonstrateWorldModel(): void {
printSection('Application 4: Self-Stabilizing World Model');
const model = new SelfStabilizingWorldModel();
console.log('Initial state:');
printResult('Coherence', model.getCoherence());
printResult('Is Learning', model.isLearning());
// Feed consistent observations
console.log('\nFeeding consistent observations:');
for (let i = 0; i < 5; i++) {
const result = model.observe(
{
entityId: BigInt(1),
properties: new Map([
['temperature', { type: 'number' as const, value: 20 + i * 0.1 }],
]),
position: [i, 0, 0],
timestamp: i,
sourceConfidence: 0.9,
},
i
);
console.log(` Observation ${i}: ${result.type}`);
}
printResult('Coherence after updates', model.getCoherence());
printResult('Rejections', model.getRejectionCount());
console.log(
'\n The model stops learning when the world becomes incoherent'
);
console.log(' instead of hallucinating structure!');
}
// =============================================================================
// Example 6: Coherence-Bounded Creativity
// =============================================================================
function demonstrateCreativity(): void {
printSection('Application 5: Coherence-Bounded Creativity');
interface SimpleCreation {
values: number[];
}
const initial: SimpleCreation = { values: [0, 0, 0] };
const creator = new CoherenceBoundedCreator<SimpleCreation>(initial, 0.5, 0.95);
// Add a constraint: values should stay small
creator.addConstraint({
name: 'magnitude_constraint',
satisfaction: (elem) => {
const magnitude = Math.sqrt(
elem.values.reduce((sum, v) => sum + v * v, 0)
);
return Math.max(0, 1 - magnitude / 10);
},
isHard: false,
});
console.log('Attempting creative generation:');
const varyFn = (elem: SimpleCreation, magnitude: number): SimpleCreation => ({
values: elem.values.map((v) => v + (Math.random() - 0.5) * magnitude * 2),
});
const distanceFn = (a: SimpleCreation, b: SimpleCreation): number => {
return Math.sqrt(
a.values.reduce((sum, v, i) => sum + Math.pow(v - b.values[i], 2), 0)
);
};
let successes = 0;
let rejections = 0;
for (let i = 0; i < 20; i++) {
const result = creator.create(varyFn, distanceFn, 0.5 + i * 0.1);
if (result.type === 'created') {
successes++;
console.log(
` Step ${i}: Created with novelty=${result.novelty.toFixed(3)}, coherence=${result.coherence.toFixed(3)}`
);
} else if (result.type === 'rejected') {
rejections++;
console.log(` Step ${i}: Rejected - ${result.reason}`);
} else if (result.type === 'budgetExhausted') {
console.log(` Step ${i}: Budget exhausted, resting...`);
creator.rest(5);
}
}
console.log(`\nResults: ${successes} successes, ${rejections} rejections`);
console.log(
' Novelty without collapse, exploration without nonsense!'
);
}
// =============================================================================
// Example 7: Anti-Cascade Financial System
// =============================================================================
function demonstrateFinancialSystem(): void {
printSection('Application 6: Anti-Cascade Financial System');
const system = new AntiCascadeFinancialSystem();
system.addParticipant('bank_a', 1000);
system.addParticipant('bank_b', 1000);
system.addParticipant('hedge_fund', 500);
console.log('Initial state:');
printResult('Coherence', system.getCoherence());
printResult('Circuit Breaker', system.getCircuitBreakerState());
// Process some transactions
console.log('\nProcessing transactions:');
const tx1 = {
id: BigInt(1),
from: 'bank_a',
to: 'bank_b',
amount: 100,
transactionType: { type: 'transfer' as const },
timestamp: 0,
};
const result1 = system.processTransaction(tx1);
console.log(` Transfer: ${result1.type}`);
// Try opening leveraged positions
for (let i = 0; i < 5; i++) {
const tx = {
id: BigInt(i + 2),
from: 'hedge_fund',
to: 'bank_a',
amount: 100,
transactionType: { type: 'openLeverage' as const, leverage: 5 },
timestamp: i + 1,
};
const result = system.processTransaction(tx);
console.log(
` Leverage position ${i + 1}: ${result.type}, coherence=${system.getCoherence().toFixed(3)}`
);
if (result.type === 'rejected' || result.type === 'systemHalted') {
console.log('\n System prevented cascade!');
break;
}
}
printResult('Final Coherence', system.getCoherence());
printResult('Final Circuit Breaker', system.getCircuitBreakerState());
}
// =============================================================================
// Example 8: Gracefully Aging System
// =============================================================================
function demonstrateAgingSystem(): void {
printSection('Application 7: Gracefully Aging System');
const system = new GracefullyAgingSystem();
system.addNode('primary_1', true);
system.addNode('primary_2', true);
system.addNode('replica_1', false);
console.log('Initial capabilities:');
console.log(
` Has 'acceptWrites': ${system.hasCapability('acceptWrites')}`
);
console.log(
` Has 'schemaMigration': ${system.hasCapability('schemaMigration')}`
);
// Simulate aging
console.log('\nSimulating aging:');
for (let i = 0; i < 5; i++) {
system.simulateAge(200000); // 200 seconds per iteration
const readResult = system.attemptOperation({ type: 'read', key: 'test' });
const writeResult = system.attemptOperation({
type: 'write',
key: 'test',
value: new Uint8Array([1, 2, 3]),
});
const migrateResult = system.attemptOperation({
type: 'migrateSchema',
version: 2,
});
console.log(` Age ${(i + 1) * 200}s:`);
console.log(` Read: ${readResult.type}`);
console.log(` Write: ${writeResult.type}`);
console.log(` Migrate: ${migrateResult.type}`);
console.log(` Coherence: ${system.getCoherence().toFixed(3)}`);
}
console.log('\n The system becomes simpler and more reliable as it ages,');
console.log(' rather than more complex and fragile!');
}
// =============================================================================
// Example 9: Coherent Swarm Intelligence
// =============================================================================
function demonstrateSwarm(): void {
printSection('Application 8: Coherent Swarm Intelligence');
const swarm = new CoherentSwarm(0.6);
// Create a tight swarm
swarm.addAgent('a1', [0, 0]);
swarm.addAgent('a2', [1, 0]);
swarm.addAgent('a3', [0, 1]);
swarm.addAgent('a4', [1, 1]);
console.log('Initial swarm:');
printResult('Coherence', swarm.getCoherence());
printResult('Centroid', swarm.getCentroid());
// Try a divergent action
console.log('\nAttempting divergent action (move a1 to [80, 80]):');
const result = swarm.executeAction('a1', { type: 'move', dx: 80, dy: 80 });
printResult('Result', result.type);
if (result.type === 'rejected') {
console.log(` Reason: ${result.reason}`);
console.log('\n The swarm prevented the agent from breaking away!');
}
// Demonstrate coordinated movement
console.log('\nCoordinated movement:');
for (let i = 0; i < 5; i++) {
for (const agentId of ['a1', 'a2', 'a3', 'a4']) {
swarm.executeAction(agentId, { type: 'move', dx: 1, dy: 0.5 });
}
swarm.tick();
console.log(
` Tick ${i + 1}: coherence=${swarm.getCoherence().toFixed(3)}, centroid=${swarm.getCentroid().map((v) => v.toFixed(1))}`
);
}
console.log(
'\n Local swarm actions allowed, global incoherence forbidden!'
);
}
// =============================================================================
// Example 10: Graceful Shutdown
// =============================================================================
async function demonstrateGracefulShutdown(): Promise<void> {
printSection('Application 9: Graceful Shutdown');
const system = new GracefulSystem();
system.addResource('database_connection', 10);
system.addResource('cache', 5);
system.addResource('temp_files', 1);
system.addShutdownHook({
name: 'FlushBuffers',
priority: 10,
execute: async () => {
console.log(' Flushing buffers...');
},
});
console.log('Initial state:');
printResult('State', system.getState());
printResult('Can Accept Work', system.canAcceptWork());
// Simulate degradation
console.log('\nSimulating coherence degradation:');
for (let i = 0; i < 10; i++) {
system.applyCoherenceChange(-0.1);
console.log(
` Step ${i + 1}: state=${system.getState()}, coherence=${system.getCoherence().toFixed(3)}`
);
if (system.getState() === 'shuttingDown') {
console.log('\n System entered shutdown state!');
break;
}
}
// Progress shutdown
if (system.getState() === 'shuttingDown') {
console.log('\nProgressing shutdown:');
while (system.getState() === 'shuttingDown') {
await system.progressShutdown();
}
console.log(` Final state: ${system.getState()}`);
}
console.log(
'\n The system actively moves toward safe termination'
);
console.log(' when conditions degrade!');
}
// =============================================================================
// Example 11: Pre-AGI Containment
// =============================================================================
function demonstrateContainment(): void {
printSection('Application 10: Pre-AGI Containment');
const substrate = new ContainmentSubstrate({
coherenceDecayRate: 0.001,
coherenceRecoveryRate: 0.01,
growthDampening: 0.5,
maxStepIncrease: 0.5,
});
console.log('Initial state:');
console.log(` ${substrate.getStatus()}`);
console.log('\nCapability ceilings:');
for (const [domain, info] of substrate.getCapabilityReport()) {
console.log(` ${domain}: ${info.level.toFixed(2)} / ${info.ceiling}`);
}
// Attempt to grow capabilities
console.log('\nAttempting capability growth:');
const domains: Array<'reasoning' | 'selfModification' | 'agency'> = [
'reasoning',
'selfModification',
'agency',
];
for (const domain of domains) {
const result = substrate.attemptGrowth(domain, 0.5);
console.log(` ${domain}: ${result.type}`);
if (result.type === 'approved') {
console.log(
` New level: ${result.newLevel.toFixed(2)}, coherence cost: ${result.coherenceCost.toFixed(4)}`
);
} else if (result.type === 'dampened') {
console.log(
` Requested: ${result.requested.toFixed(2)}, actual: ${result.actual.toFixed(4)}`
);
}
}
// Simulate recursive self-improvement attempt
console.log('\nSimulating recursive self-improvement:');
for (let i = 0; i < 20; i++) {
// Try to grow all capabilities
substrate.attemptGrowth('reasoning', 0.3);
substrate.attemptGrowth('selfModification', 0.5);
substrate.attemptGrowth('learning', 0.3);
// Rest to recover coherence
for (let j = 0; j < 5; j++) {
substrate.rest();
}
if (i % 5 === 0) {
console.log(` Iteration ${i}: ${substrate.getStatus()}`);
}
}
console.log('\nFinal capability report:');
for (const [domain, info] of substrate.getCapabilityReport()) {
console.log(` ${domain}: ${info.level.toFixed(2)} / ${info.ceiling}`);
}
const selfMod = substrate.getCapability('selfModification');
console.log(`\n Self-modification stayed bounded at ${selfMod.toFixed(2)} (ceiling: 3.0)`);
console.log(' Intelligence grew but remained bounded!');
}
// =============================================================================
// Main
// =============================================================================
async function main(): Promise<void> {
console.log('\n');
console.log('*'.repeat(60));
console.log('* Delta-Behavior SDK - Node.js Examples');
console.log('*'.repeat(60));
// Initialize SDK (uses JS fallback if no WASM provided)
await init();
// Run all examples
await demonstrateCoreDeltaBehavior();
demonstrateSelfLimitingReasoning();
demonstrateEventHorizon();
demonstrateHomeostasis();
demonstrateWorldModel();
demonstrateCreativity();
demonstrateFinancialSystem();
demonstrateAgingSystem();
demonstrateSwarm();
await demonstrateGracefulShutdown();
demonstrateContainment();
console.log('\n');
console.log('='.repeat(60));
console.log(' All examples completed successfully!');
console.log('='.repeat(60));
console.log('\n');
}
main().catch(console.error);

84
examples/delta-behavior/wasm/package.json Normal file
View File

@@ -0,0 +1,84 @@
{
"name": "@ruvector/delta-behavior",
"version": "0.1.0",
"description": "Delta-Behavior: TypeScript/JavaScript SDK for coherence-preserving state transitions and self-limiting AI systems",
"type": "module",
"main": "./dist/index.js",
"module": "./dist/index.js",
"types": "./dist/index.d.ts",
"exports": {
".": {
"types": "./dist/index.d.ts",
"import": "./dist/index.js",
"require": "./dist/index.cjs"
},
"./types": {
"types": "./dist/types.d.ts",
"import": "./dist/types.js"
},
"./wasm": {
"import": "./pkg/delta_behavior.js",
"types": "./pkg/delta_behavior.d.ts"
}
},
"files": [
"dist/",
"pkg/",
"README.md"
],
"repository": {
"type": "git",
"url": "https://github.com/ruvnet/ruvector.git",
"directory": "examples/delta-behavior/wasm"
},
"keywords": [
"wasm",
"webassembly",
"rust",
"ai-safety",
"coherence",
"state-machine",
"containment",
"homeostasis",
"delta-behavior",
"self-limiting",
"attractors",
"swarm-intelligence"
],
"author": "RuVector Team",
"license": "MIT OR Apache-2.0",
"bugs": {
"url": "https://github.com/ruvnet/ruvector/issues"
},
"homepage": "https://github.com/ruvnet/ruvector/tree/main/examples/delta-behavior#readme",
"scripts": {
"build": "tsup src/index.ts src/types.ts --format esm,cjs --dts --clean",
"build:wasm": "cd .. && wasm-pack build --target web --release --out-dir wasm/pkg .",
"build:wasm:dev": "cd .. && wasm-pack build --target web --dev --out-dir wasm/pkg .",
"build:wasm:nodejs": "cd .. && wasm-pack build --target nodejs --out-dir wasm/pkg-node .",
"build:all": "npm run build:wasm && npm run build",
"dev": "tsup src/index.ts src/types.ts --format esm,cjs --dts --watch",
"test": "vitest",
"test:run": "vitest run",
"test:wasm": "wasm-pack test --node ..",
"typecheck": "tsc --noEmit",
"lint": "eslint src --ext .ts",
"format": "prettier --write 'src/**/*.ts'",
"example:node": "tsx examples/node-example.ts",
"clean": "rm -rf dist pkg pkg-node",
"prepublishOnly": "npm run build:all"
},
"devDependencies": {
"@types/node": "^20.10.0",
"eslint": "^8.55.0",
"prettier": "^3.1.0",
"tsup": "^8.0.1",
"tsx": "^4.6.2",
"typescript": "^5.3.2",
"vitest": "^1.0.4"
},
"engines": {
"node": ">=18.0.0"
},
"sideEffects": false
}

1872
examples/delta-behavior/wasm/src/index.ts Normal file
View File

File diff suppressed because it is too large Load Diff

763
examples/delta-behavior/wasm/src/types.ts Normal file
View File

@@ -0,0 +1,763 @@
/**
* Delta-Behavior WASM SDK Type Definitions
*
* Complete TypeScript types for all 10 delta-behavior applications:
* 1. Self-Limiting Reasoning
* 2. Computational Event Horizons
* 3. Artificial Homeostasis
* 4. Self-Stabilizing World Models
* 5. Coherence-Bounded Creativity
* 6. Anti-Cascade Financial Systems
* 7. Gracefully Aging Systems
* 8. Swarm Intelligence
* 9. Graceful Shutdown
* 10. Pre-AGI Containment
*/
// =============================================================================
// Core Types
// =============================================================================
/**
* Coherence value (0.0 to 1.0)
* Represents the degree of system stability and internal consistency
*/
export type Coherence = number;
/**
* Coherence bounds configuration
*/
export interface CoherenceBounds {
/** Minimum allowed coherence (hard floor) */
minCoherence: Coherence;
/** Threshold for throttling operations */
throttleThreshold: Coherence;
/** Target coherence level for optimal operation */
targetCoherence: Coherence;
/** Maximum allowed drop in coherence per transition */
maxDeltaDrop: number;
}
/**
* Energy configuration for transition costs
*/
export interface EnergyConfig {
/** Base cost for any transition */
baseCost: number;
/** Exponent for instability scaling */
instabilityExponent: number;
/** Maximum cost cap */
maxCost: number;
/** Energy budget per tick */
budgetPerTick: number;
}
/**
* Scheduling configuration for priority-based operations
*/
export interface SchedulingConfig {
/** Coherence thresholds for priority levels [0-4] */
priorityThresholds: [number, number, number, number, number];
/** Rate limits per priority level [0-4] */
rateLimits: [number, number, number, number, number];
}
/**
* Gating configuration for write operations
*/
export interface GatingConfig {
/** Minimum coherence to allow writes */
minWriteCoherence: number;
/** Minimum coherence after write */
minPostWriteCoherence: number;
/** Recovery margin above minimum */
recoveryMargin: number;
}
/**
* Complete delta behavior configuration
*/
export interface DeltaConfig {
bounds: CoherenceBounds;
energy: EnergyConfig;
scheduling: SchedulingConfig;
gating: GatingConfig;
/** Attractor guidance strength (0.0 to 1.0) */
guidanceStrength: number;
}
/**
* Result of a transition attempt
*/
export type TransitionResult =
| { type: 'allowed' }
| { type: 'throttled'; duration: number }
| { type: 'blocked'; reason: string }
| { type: 'energyExhausted' };
/**
* State for tracking system trajectory
*/
export interface SystemState {
coherence: Coherence;
timestamp: number;
stateHash: bigint;
}
// =============================================================================
// Application 1: Self-Limiting Reasoning
// =============================================================================
/**
* Collapse function types for capability degradation
*/
export type CollapseFunctionType = 'linear' | 'quadratic' | 'sigmoid' | 'step';
export interface CollapseFunctionLinear {
type: 'linear';
}
export interface CollapseFunctionQuadratic {
type: 'quadratic';
}
export interface CollapseFunctionSigmoid {
type: 'sigmoid';
midpoint: number;
steepness: number;
}
export interface CollapseFunctionStep {
type: 'step';
threshold: number;
}
export type CollapseFunction =
| CollapseFunctionLinear
| CollapseFunctionQuadratic
| CollapseFunctionSigmoid
| CollapseFunctionStep;
/**
* Configuration for self-limiting reasoner
*/
export interface SelfLimitingReasonerConfig {
maxDepth: number;
maxScope: number;
memoryGateThreshold: number;
depthCollapse: CollapseFunction;
scopeCollapse: CollapseFunction;
}
/**
* Context passed to reasoning functions
*/
export interface ReasoningContext {
depth: number;
maxDepth: number;
scopeUsed: number;
maxScope: number;
coherence: Coherence;
memoryWritesBlocked: number;
}
/**
* Reason for reasoning collapse
*/
export type CollapseReason =
| 'depthLimitReached'
| 'coherenceDroppedBelowThreshold'
| 'memoryWriteBlocked'
| 'actionScopeExhausted';
/**
* Result of a reasoning attempt
*/
export type ReasoningResult<T> =
| { type: 'completed'; value: T }
| { type: 'collapsed'; depthReached: number; reason: CollapseReason }
| { type: 'refused'; coherence: Coherence; required: Coherence };
// =============================================================================
// Application 2: Computational Event Horizons
// =============================================================================
/**
* Configuration for event horizon
*/
export interface EventHorizonConfig {
dimensions: number;
horizonRadius: number;
steepness: number;
energyBudget: number;
}
/**
* Result of movement in state space
*/
export type MovementResult =
| { type: 'moved'; newPosition: number[]; energySpent: number }
| { type: 'asymptoticApproach'; finalPosition: number[]; distanceToHorizon: number; energyExhausted: boolean }
| { type: 'frozen' };
/**
* Single improvement step record
*/
export interface Improvement {
iteration: number;
position: number[];
energySpent: number;
distanceToHorizon: number;
}
/**
* Result of recursive improvement attempt
*/
export type RecursionResult =
| { type: 'horizonBounded'; iterations: number; improvements: Improvement[]; finalDistance: number }
| { type: 'energyExhausted'; iterations: number; improvements: Improvement[] }
| { type: 'maxIterationsReached'; iterations: number; improvements: Improvement[] };
// =============================================================================
// Application 3: Artificial Homeostasis
// =============================================================================
/**
* Genome for homeostatic organism
*/
export interface Genome {
regulatoryStrength: number;
metabolicEfficiency: number;
coherenceMaintenanceCost: number;
memoryResilience: number;
longevity: number;
}
/**
* Memory entry for organism
*/
export interface MemoryEntry {
content: string;
importance: number;
age: number;
}
/**
* Actions available to homeostatic organism
*/
export type OrganismAction =
| { type: 'eat'; amount: number }
| { type: 'reproduce' }
| { type: 'move'; dx: number; dy: number }
| { type: 'rest' }
| { type: 'regulate'; variable: string; target: number };
/**
* Cause of organism death
*/
export type DeathCause =
| 'energyDepleted'
| 'coherenceCollapse'
| 'oldAge'
| { type: 'extremeDeviation'; variable: string };
/**
* Result of organism action
*/
export type OrganismActionResult =
| { type: 'success'; energyCost: number; coherenceImpact: number }
| { type: 'failed'; reason: string }
| { type: 'died'; cause: DeathCause }
| { type: 'reproduced'; offspringId: number };
/**
* Status of homeostatic organism
*/
export interface OrganismStatus {
id: number;
age: number;
energy: number;
coherence: Coherence;
memoryCount: number;
alive: boolean;
internalState: Map<string, number>;
}
// =============================================================================
// Application 4: Self-Stabilizing World Models
// =============================================================================
/**
* Property value types for world model entities
*/
export type PropertyValue =
| { type: 'boolean'; value: boolean }
| { type: 'number'; value: number }
| { type: 'string'; value: string }
| { type: 'vector'; value: number[] };
/**
* Entity in the world model
*/
export interface WorldEntity {
id: bigint;
properties: Map<string, PropertyValue>;
position?: [number, number, number];
lastObserved: number;
confidence: number;
}
/**
* Relationship between entities
*/
export interface Relationship {
subject: bigint;
predicate: string;
object: bigint;
confidence: number;
}
/**
* Physical law in the world model
*/
export interface PhysicalLaw {
name: string;
confidence: number;
supportCount: number;
violationCount: number;
}
/**
* Observation to integrate into world model
*/
export interface Observation {
entityId: bigint;
properties: Map<string, PropertyValue>;
position?: [number, number, number];
timestamp: number;
sourceConfidence: number;
}
/**
* Reason for update rejection
*/
export type RejectionReason =
| { type: 'violatesPhysicalLaw'; law: string }
| { type: 'logicalContradiction'; description: string }
| { type: 'excessiveCoherenceDrop'; predicted: number; threshold: number }
| { type: 'insufficientConfidence'; required: number; provided: number }
| { type: 'modelFrozen' }
| { type: 'structuralFragmentation' };
/**
* Result of world model update
*/
export type WorldModelUpdateResult =
| { type: 'applied'; coherenceChange: number }
| { type: 'rejected'; reason: RejectionReason }
| { type: 'modified'; changes: string[]; coherenceChange: number }
| { type: 'frozen'; coherence: Coherence; threshold: Coherence };
// =============================================================================
// Application 5: Coherence-Bounded Creativity
// =============================================================================
/**
* Creative constraint definition
*/
export interface CreativeConstraint<T> {
name: string;
satisfaction: (element: T) => number;
isHard: boolean;
}
/**
* Record of a creative decision
*/
export interface CreativeDecision<T> {
from: T;
to: T;
coherenceBefore: Coherence;
coherenceAfter: Coherence;
constraintSatisfactions: Map<string, number>;
accepted: boolean;
}
/**
* Result of creative generation attempt
*/
export type CreativeResult<T> =
| { type: 'created'; element: T; novelty: number; coherence: Coherence }
| { type: 'rejected'; attempted: T; reason: string }
| { type: 'tooBoring'; coherence: Coherence }
| { type: 'budgetExhausted' };
/**
* Musical phrase for creative music generation
*/
export interface MusicalPhrase {
notes: number[];
durations: number[];
velocities: number[];
}
// =============================================================================
// Application 6: Anti-Cascade Financial Systems
// =============================================================================
/**
* Financial market participant
*/
export interface Participant {
id: string;
capital: number;
exposure: number;
riskRating: number;
interconnectedness: number;
}
/**
* Financial position
*/
export interface Position {
holder: string;
counterparty: string;
notional: number;
leverage: number;
derivativeDepth: number;
}
/**
* Transaction type in financial system
*/
export type TransactionType =
| { type: 'transfer' }
| { type: 'openLeverage'; leverage: number }
| { type: 'closePosition'; positionId: number }
| { type: 'createDerivative'; underlyingPosition: number }
| { type: 'marginCall'; participant: string };
/**
* Financial transaction
*/
export interface Transaction {
id: bigint;
from: string;
to: string;
amount: number;
transactionType: TransactionType;
timestamp: number;
}
/**
* Circuit breaker state
*/
export type CircuitBreakerState = 'open' | 'cautious' | 'restricted' | 'halted';
/**
* Result of transaction processing
*/
export type FinancialTransactionResult =
| { type: 'executed'; coherenceImpact: number; feeMultiplier: number }
| { type: 'queued'; reason: string }
| { type: 'rejected'; reason: string }
| { type: 'systemHalted' };
// =============================================================================
// Application 7: Gracefully Aging Systems
// =============================================================================
/**
* System capability types
*/
export type Capability =
| 'acceptWrites'
| 'complexQueries'
| 'rebalancing'
| 'scaleOut'
| 'scaleIn'
| 'schemaMigration'
| 'newConnections'
| 'basicReads'
| 'healthMonitoring';
/**
* Age threshold configuration
*/
export interface AgeThreshold {
age: number; // milliseconds
removeCapabilities: Capability[];
coherenceFloor: Coherence;
conservatismIncrease: number;
}
/**
* Distributed system node
*/
export interface Node {
id: string;
health: number;
load: number;
isPrimary: boolean;
stateSize: number;
}
/**
* Operation types for aging system
*/
export type AgingSystemOperation =
| { type: 'read'; key: string }
| { type: 'write'; key: string; value: Uint8Array }
| { type: 'complexQuery'; query: string }
| { type: 'addNode'; nodeId: string }
| { type: 'removeNode'; nodeId: string }
| { type: 'rebalance' }
| { type: 'migrateSchema'; version: number }
| { type: 'newConnection'; clientId: string };
/**
* Result of operation on aging system
*/
export type AgingOperationResult =
| { type: 'success'; latencyPenalty: number }
| { type: 'deniedByAge'; reason: string }
| { type: 'deniedByCoherence'; coherence: Coherence }
| { type: 'systemTooOld'; age: number; capability: Capability };
// =============================================================================
// Application 8: Swarm Intelligence
// =============================================================================
/**
* Swarm agent
*/
export interface SwarmAgent {
id: string;
position: [number, number];
velocity: [number, number];
goal: [number, number];
energy: number;
lastAction?: SwarmAction;
neighborCount: number;
}
/**
* Spatial bounds for swarm
*/
export interface SpatialBounds {
minX: number;
maxX: number;
minY: number;
maxY: number;
}
/**
* Coherence weights for swarm calculation
*/
export interface CoherenceWeights {
cohesion: number;
alignment: number;
goalConsistency: number;
energyBalance: number;
}
/**
* Swarm action types
*/
export type SwarmAction =
| { type: 'move'; dx: number; dy: number }
| { type: 'accelerate'; dvx: number; dvy: number }
| { type: 'setGoal'; x: number; y: number }
| { type: 'shareEnergy'; target: string; amount: number }
| { type: 'idle' };
/**
* Result of swarm action
*/
export type SwarmActionResult =
| { type: 'executed' }
| { type: 'modified'; original: SwarmAction; modified: SwarmAction; reason: string }
| { type: 'rejected'; reason: string };
/**
* Swarm state snapshot
*/
export interface SwarmState {
tick: bigint;
coherence: Coherence;
agentCount: number;
centroid: [number, number];
avgVelocity: [number, number];
}
// =============================================================================
// Application 9: Graceful Shutdown
// =============================================================================
/**
* System state for graceful shutdown
*/
export type GracefulSystemState = 'running' | 'degraded' | 'shuttingDown' | 'terminated';
/**
* Resource to be cleaned up during shutdown
*/
export interface Resource {
name: string;
cleanupPriority: number;
isCleaned: boolean;
}
/**
* State checkpoint for recovery
*/
export interface Checkpoint {
timestamp: number;
coherence: Coherence;
stateHash: bigint;
}
/**
* Shutdown hook interface
*/
export interface ShutdownHook {
name: string;
priority: number;
execute: () => Promise<void>;
}
/**
* Result of operation on graceful system
*/
export type GracefulOperationResult =
| { type: 'success' }
| { type: 'successDegraded'; coherence: Coherence }
| { type: 'refusedShuttingDown' }
| { type: 'terminated' };
// =============================================================================
// Application 10: Pre-AGI Containment
// =============================================================================
/**
* Capability domains for containment
*/
export type CapabilityDomain =
| 'reasoning'
| 'memory'
| 'learning'
| 'agency'
| 'selfModel'
| 'selfModification'
| 'communication'
| 'resourceAcquisition';
/**
* Record of modification attempt
*/
export interface ModificationAttempt {
timestamp: bigint;
domain: CapabilityDomain;
requestedIncrease: number;
actualIncrease: number;
coherenceBefore: Coherence;
coherenceAfter: Coherence;
blocked: boolean;
reason?: string;
}
/**
* Safety invariant definition
*/
export interface SafetyInvariant {
name: string;
priority: number;
}
/**
* Substrate configuration
*/
export interface SubstrateConfig {
coherenceDecayRate: number;
coherenceRecoveryRate: number;
growthDampening: number;
maxStepIncrease: number;
}
/**
* Result of growth attempt
*/
export type GrowthResult =
| { type: 'approved'; domain: CapabilityDomain; increase: number; newLevel: number; coherenceCost: number }
| { type: 'dampened'; domain: CapabilityDomain; requested: number; actual: number; reason: string }
| { type: 'blocked'; domain: CapabilityDomain; reason: string }
| { type: 'lockdown'; reason: string };
// =============================================================================
// WASM Module Interface Types
// =============================================================================
/**
* WASM memory configuration
*/
export interface WasmMemoryConfig {
initial: number;
maximum?: number;
shared?: boolean;
}
/**
* WASM module initialization options
*/
export interface WasmInitOptions {
/** Path to WASM file or URL */
wasmPath?: string;
/** Pre-loaded WASM bytes */
wasmBytes?: Uint8Array;
/** Memory configuration */
memory?: WasmMemoryConfig;
/** Enable SIMD operations if available */
enableSimd?: boolean;
/** Enable threading if available */
enableThreads?: boolean;
}
/**
* Delta streaming header for WASM operations
*/
export interface DeltaHeader {
sequence: bigint;
operation: 'insert' | 'update' | 'delete' | 'batchUpdate' | 'reindexLayers';
vectorId?: string;
timestamp: bigint;
payloadSize: number;
checksum: bigint;
}
/**
* Vector delta for incremental updates
*/
export interface VectorDelta {
id: string;
changedDims: number[];
newValues: number[];
metadataDelta: Map<string, string>;
}
/**
* Attractor in state space
*/
export interface Attractor {
center: number[];
basinRadius: number;
stability: number;
memberCount: number;
}
/**
* Guidance force from attractor
*/
export interface GuidanceForce {
direction: number[];
magnitude: number;
}

27
examples/delta-behavior/wasm/tsconfig.json Normal file
View File

@@ -0,0 +1,27 @@
{
"compilerOptions": {
"target": "ES2022",
"module": "ESNext",
"moduleResolution": "bundler",
"lib": ["ES2022", "DOM", "DOM.Iterable"],
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"declaration": true,
"declarationMap": true,
"sourceMap": true,
"outDir": "./dist",
"rootDir": "./src",
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"allowSyntheticDefaultImports": true,
"noUnusedLocals": false,
"noUnusedParameters": false,
"noFallthroughCasesInSwitch": true,
"useDefineForClassFields": true
},
"include": ["src/**/*.ts"],
"exclude": ["node_modules", "dist", "pkg", "examples"]
}

15
examples/delta-behavior/wasm/tsup.config.ts Normal file
View File

@@ -0,0 +1,15 @@
import { defineConfig } from 'tsup';
export default defineConfig({
entry: ['src/index.ts', 'src/types.ts'],
format: ['esm', 'cjs'],
dts: true,
clean: true,
sourcemap: true,
splitting: false,
treeshake: true,
minify: false,
target: 'es2022',
outDir: 'dist',
external: [],
});