docs: Expand EQBSL Rust crate README and update root README with crate details

EQBSL_Report.md

@@ -1,7 +1,7 @@
 # EQBSL: Potential Uses and Applications Report
 
 **Date:** February 21, 2026
-**Project:** EQBSL (Evidence-Based Quantum-resistant Belief State Logic)
+**Project:** EQBSL (Evidence-Qualified Subjective Logic)
 
 ---
 
@@ -12,7 +12,7 @@ EQBSL represents a paradigm shift in how digital systems model trust. Unlike tra
 By combining **Subjective Logic** (which explicitly models uncertainty), **Zero-Knowledge Proofs** (which ensure privacy), and **Vectorized Evidence** (which captures context), EQBSL enables decentralized systems to reason about trust in a way that is:
 *   **Expressive:** Distinguishing between "trusted", "distrusted", and "unknown".
 *   **Private:** Proving reputation without revealing sensitive interaction history.
-*   **Resilient:** Resistant to Sybil attacks and quantum decryption threats.
+*   **Resilient:** Better able to separate established evidence from uncertainty about new or weakly observed actors.
 
 ---
 
@@ -29,7 +29,7 @@ This mapping allows systems to calculate trust dynamically:
 $$b = \frac{r}{r+s+K}, \quad d = \frac{s}{r+s+K}, \quad u = \frac{K}{r+s+K}$$
 *(Where $r$ is positive evidence, $s$ is negative evidence, and $K$ is a protocol constant)*
 
-### 2.2 Proof-Carrying Trust (ZK-EBSL)
+### 2.2 Proof-Carrying Trust
 Trust updates are not just computed; they are **proven**. Using Zero-Knowledge Machine Learning (ZKML) techniques, an entity can prove that their new reputation score was correctly calculated from valid evidence without revealing *what* that evidence was (e.g., who they traded with or the specific transaction details).
 
 ### 2.3 Vectorized & Hypergraph Trust
@@ -143,7 +143,7 @@ sequenceDiagram
 | **Transitivity** | Centralized Algorithm | Manual / Short paths | **Mathematical Discounting Operators** |
 | **Privacy** | Low (Centralized DB) | Low (Public Graph) | **High (Zero-Knowledge Proofs)** |
 | **Sybil Resistance**| ID Verification (KYC) | Reliance on Introducers | **Epistemic Uncertainty (High 'u')** |
-| **Quantum Safety** | Low (RSA/ECC) | Low (RSA/ECC) | **High (PQ-Commitments)** |
+| **Cryptographic Verifiability** | Low | Low | **High (via optional proof-carrying constructions)** |
 | **Granularity** | Coarse (Global Score) | Binary | **Context-Aware (Multi-dimensional)** |
 
 ---

README.md

@@ -15,12 +15,12 @@
 
 https://eqbsl-demo.netlify.app/
 
-- **Evidence-Based Subjective Logic (EBSL)** – Move beyond binary trust scores to model uncertainty using evidence tuples (r, s, u)
-- **Zero-Knowledge EBSL (ZK-EBSL)** – Privacy-preserving trust computations using zero-knowledge proofs
-- **EQBSL** – Quantum-resistant extensions for distributed identity and reputation systems
+- **Evidence-Based Subjective Logic (EBSL)** – Map evidence counts `(r, s)` into opinion tuples `(b, d, u, a)` with explicit uncertainty
+- **Proof-carrying trust / ZK demos** – Explore how EQBSL state updates could be constrained or attested with zero-knowledge proofs
+- **EQBSL (Evidence-Qualified Subjective Logic)** – Extend EBSL with vectorized evidence, operator-defined state evolution, hypergraph support, and embedding-oriented outputs
 - **Cathexis** – Emotional/motivational trust dynamics
 
-Built with Angular 21 and TypeScript, this tool transforms complex cryptographic and epistemic concepts into intuitive, visual experiences.
+Built with Angular 21 and TypeScript, this tool turns the papers' trust operators and research ideas into interactive visual experiences. The web app is primarily an exploration/demo environment; the Rust crate in [rust/](rust/) is the concrete library implementation of the EQBSL pipeline.
 
 > **Repository:** [`Steake/EQBSL`](https://github.com/Steake/EQBSL)  
 > **App metadata:** [`metadata.json`](./metadata.json)
@@ -36,49 +36,48 @@ Watch this comprehensive introduction to understand how EQBSL revolutionizes tru
 This video covers:
 - The fundamental limitations of traditional trust scores
 - How Evidence-Based Subjective Logic (EBSL) models uncertainty
-- Zero-knowledge proofs for privacy-preserving trust verification
-- Quantum-resistant extensions for future-proof security
+- How proof-carrying / zero-knowledge trust updates fit into the research direction
 - Real-world applications in decentralized identity and reputation systems
 
 ---
 
 ## 📖 What is EQBSL?
 
-**EQBSL (Evidence-based Quantum-resistant Belief State Logic)** is a mathematical framework for reasoning about trust, reputation, and epistemic uncertainty in distributed systems. Unlike traditional trust scores (e.g., "85% trusted"), EQBSL models the full epistemic state:
+**EQBSL (Evidence-Qualified Subjective Logic)** is a mathematical framework for reasoning about trust, reputation, and epistemic uncertainty in distributed systems. In the terminology used by the papers and primer, EQBSL is **EBSL lifted into vector/tensor evidence, explicit operator-defined state evolution over time, hypergraph-native interactions, and embedding-first outputs, with optional proof-carrying updates**. Unlike traditional trust scores (e.g., "85% trusted"), EQBSL models the full epistemic state:
 
 - **Belief (b)** – Evidence supporting a proposition
 - **Disbelief (d)** – Evidence against a proposition  
-- **Uncertainty (u)** – Absence of evidence (where b + d + u = 1)
+- **Uncertainty (u)** – Absence of evidence (where `b + d + u = 1`)
+- **Base rate (a)** – Prior probability when evidence is absent
 
 ### Why EQBSL Matters
 
 Traditional reputation systems collapse complex trust relationships into a single number, losing critical information about:
 - **How much evidence** supports the rating (2 reviews vs. 2000 reviews)
 - **Uncertainty** when data is sparse or conflicting
-- **Privacy** when revealing trust judgments
-- **Quantum resistance** for future-proof cryptographic security
+- **Typed evidence** across different channels or contexts
+- **Time and structure** when trust evolves over graphs, hypergraphs, and repeated interactions
+- **Privacy** when systems want to attest to trust updates without revealing raw evidence
 
 ### Key Innovations
 
 1. **Evidence-Based Reasoning (EBSL)**  
-   Trust opinions are computed from evidence tuples (r, s) representing positive and negative observations. This enables mathematically rigorous:
+   Trust opinions are computed from evidence counts `(r, s)` representing positive and negative observations, then lifted into opinions `ω = (b, d, u, a)`. This enables mathematically rigorous:
    - Trust transitivity (A trusts B, B trusts C → A's opinion of C)
    - Opinion fusion from multiple sources
    - Uncertainty quantification
 
-2. **Zero-Knowledge Proofs (ZK-EBSL)**  
-   Prove trust properties without revealing:
-   - The exact trust values
-   - The evidence supporting them
-   - The identities involved  
-
-   Example: "I can prove this vendor has >80% trust from 50+ verified buyers, without revealing who those buyers are."
+2. **EQBSL State & Operators**  
+   EQBSL extends basic EBSL by making the update pipeline explicit:
+   - Vectorized / tensor evidence per relationship
+   - Temporal decay and deterministic state evolution
+   - Hyperedge attribution for multi-party interactions
+   - Embedding-oriented outputs for downstream ML or policy systems
 
-3. **Quantum Resistance (EQBSL)**  
-   Built on post-quantum cryptographic primitives to ensure trust systems remain secure against quantum computers, protecting:
-   - Long-term reputation data
-   - Privacy-preserving proofs
-   - Identity attestations
+3. **Proof-Carrying Trust (optional)**  
+   The papers describe how EQBSL updates can be accompanied by zero-knowledge proofs or commitments so a system can attest that it followed the declared operator without revealing the underlying evidence.
+
+   Example: "I can prove this published trust update respects the EQBSL transition rules without revealing the private interaction log behind it."
 
 4. **Cathexis Integration**  
    Models emotional/motivational dimensions of trust:
@@ -90,39 +89,88 @@ Traditional reputation systems collapse complex trust relationships into a singl
 
 - **Decentralized Identity**: Web-of-trust without centralized authorities
 - **Reputation Systems**: Marketplaces, social networks, peer review
-- **Secure Voting**: Verifiable ballot privacy with trust in validators
+- **Secure Voting / Governance**: Reputation-weighted participation and validator selection
 - **Supply Chain**: Track product authenticity with uncertainty modeling
-- **AI Safety**: Quantify and verify trust in AI agent behaviors
+- **AI Safety**: Quantify trust in AI agent behaviors and preserve evidence lineage for downstream verification
 
 ---
 
 ## 🎯 What Can You Do?
 
 - **EBSL Logic Calculator** – Experiment with belief/disbelief/uncertainty operations
 - **EQBSL Graph Visualizer** – Model trust networks with AI-assisted node identity generation
-- **Zero-Knowledge Demos** – Explore privacy-preserving trust proofs
+- **Proof-Carrying Trust Demo** – Explore how private trust updates can be attested
 - **Cathexis Simulator** – Understand emotional dynamics in trust relationships
+- **Reputation-Gated Airdrop Example** – See how reputation scores drive eligibility and payout curves in an applied token distribution flow
 
 ---
 
 ## 🔬 Research Papers
 
-This implementation is grounded in rigorous academic research. The `Papers/` directory contains:
+This implementation is grounded in ongoing academic/research work. The `Papers/` directory contains:
 
-- **EBSL in ZK Reputation Systems** – Foundations of zero-knowledge trust proofs
-- **EQBSL+ZK** – Quantum-resistant extensions to EBSL
-- **Proof-Carrying-Trust** – Verifiable trust computations
+- **EBSL in ZK Reputation Systems** – EBSL integrated into privacy-preserving identity / reputation settings
+- **EQBSL+ZK** – The systems-oriented EQBSL extension: vectorized evidence, explicit operators, embeddings, and the bridge to proof-carrying updates
+- **Proof-Carrying-Trust** – Zero-knowledge constraints for EQBSL state transitions and verifiable trust computation
 
 For formal definitions, proofs, and protocol specifications, explore these papers and the broader [`EQBSL`](https://github.com/Steake/EQBSL) repository.
 
 ---
 
+## 🦀 Rust Crate
+
+A native Rust implementation of the EQBSL library is available in the [rust/](rust/) directory. It provides the EQBSL computational pipeline — from raw evidence to trust embeddings — as a standalone crate suitable for backend services, CLI tools, or embedding in other Rust projects. The current crate focuses on the trust/evidence calculus itself; proof-carrying updates are described in the papers rather than implemented as a proving system here.
+
+### Features
+
+- **Opinion Tuple** `(b, d, u, a)` with Consensus `⊕` and Discounting `⊗` operators
+- **Evidence-to-Opinion mapping** via `calculate_opinion(r, s, k, a)`
+- **m-dimensional evidence tensors** per relationship
+- **Temporal decay** (`β^Δt` per channel), **hyperedge attribution**, and **transitive propagation**
+- **Node trust embeddings** for downstream ML tasks
+- **Full `serde` support** for JSON serialization
+
+### Installation
+
+Add to your `Cargo.toml`:
+
+```toml
+[dependencies]
+eqbsl = { path = "rust" }
+ndarray = "0.15"
+```
+
+### Quick Start
+
+```rust
+use eqbsl::*;
+
+// Map evidence to an opinion (10 positive, 0 negative, K=2, base rate=0.5)
+let op = calculate_opinion(10.0, 0.0, DEFAULT_K, 0.5);
+println!("b={:.3}, u={:.3}, E={:.3}", op.b, op.u, op.expectation());
+// → b=0.833, u=0.167, E=0.917
+
+// Transitive trust: A trusts C via B
+let op_ab = calculate_opinion(10.0, 0.0, DEFAULT_K, 0.5);
+let op_bc = calculate_opinion(5.0, 0.0, DEFAULT_K, 0.5);
+let op_ac = op_ab.discount(&op_bc);
+
+// Fuse two independent witnesses
+let op_w = calculate_opinion(8.0, 1.0, DEFAULT_K, 0.5);
+let fused = op_ac.fuse(&op_w);
+println!("Fused E={:.3}", fused.expectation());
+```
+
+For complete documentation, architecture diagrams, and real-world examples (supply chain provenance, DAO voting, AI agent swarm trust, P2P lending), see [`rust/README.md`](./rust/README.md).
+
+---
+
 ## 🛠️ Technology Stack
 
 - **Angular 21** – Modern reactive framework with zoneless change detection
 - **TypeScript 5.8** – Type-safe development
 - **RxJS** – Reactive data flows and state management
-- **Tailwind CSS** – Utility-first styling for responsive UI
+- **Tailwind CSS** – Utility-first styling for the UI
 - **Google Generative AI** – AI-assisted trust model exploration
 - **Angular CLI** – Build tooling and development server
 
@@ -208,6 +256,12 @@ This serves the app using production configuration (equivalent to `ng serve --co
 
 ```
 EQBSL/
+├── rust/                      # Rust crate — native EQBSL library
+│   ├── src/                   # Library source (opinion, ebsl, model, embedding)
+│   ├── examples/              # Runnable examples
+│   ├── tests/                 # Integration & BDD tests
+│   ├── Cargo.toml
+│   └── README.md              # Full Rust crate documentation
 ├── Papers/                    # Research papers (PDFs)
 ├── src/
 │   ├── app.component.ts       # Main Angular app component
@@ -288,12 +342,12 @@ Visualize trust networks:
 - AI-generated identity profiles for realistic scenarios
 - Real-time trust propagation calculations
 
-### ZK Demo
+### Proof-Carrying Trust Demo
 
-Explore zero-knowledge proofs:
-- Privacy-preserving trust verification
-- Commitment schemes for EBSL opinions
-- Proof generation and verification
+Explore the proof-carrying trust idea at a conceptual level:
+- Privacy-preserving trust verification workflows
+- Commitment / proof flow for EQBSL-style state updates
+- Simulated proof generation and verification in the UI
 
 ### Cathexis
 
@@ -345,6 +399,7 @@ EQBSL is part of a growing ecosystem of Subjective Logic implementations:
 
 | Project | Language | Description |
 |---------|----------|-------------|
+| **[rust/ (this repo)](./rust/)** | **Rust** | **Native EQBSL crate — opinions, decay, propagation, embeddings** |
 | [liamzebedee/retrust](https://github.com/liamzebedee/retrust) | JS/Python | Subjective consensus algorithm with EBSL and sybil control |
 | [waleedqk/subjective-logic](https://github.com/waleedqk/subjective-logic) | Python | Pure subjective logic library with binomial opinions and fusion |
 | [atenearesearchgroup/uncertainty-datatypes-python](https://github.com/atenearesearchgroup/uncertainty-datatypes-python) | Python | Academic SL implementation from University of Málaga |
@@ -358,13 +413,13 @@ See also: [Subjective Logic on GitHub](https://github.com/topics/subjective-logi
 
 ## 📄 License
 
-This project is part of ongoing research by O. C. Hirst [Steake] & Shadowgraph Labs (2025). See the repository for license details.
+MIT. See [LICENSE](LICENSE).
 
 ---
 
 ## 🙏 Acknowledgments
 
-- Based on research in subjective logic, zero-knowledge proofs, and quantum-resistant cryptography
+- Based on research in subjective logic, evidence-based trust, and zero-knowledge / proof-carrying verification
 - Built with modern web technologies for accessible epistemic reasoning
 - Special thanks to the Angular, TypeScript, and open-source communities
 

angular.json

@@ -51,5 +51,8 @@
         }
       }
     }
+  },
+  "cli": {
+    "analytics": false
   }
 }

metadata.json

@@ -1,5 +1,5 @@
 {
   "name": "EQBSL Explorer",
-  "description": "Interactive playground for Evidence-Based Subjective Logic, ZK-EBSL, and EQBSL trust systems.",
+  "description": "Interactive playground for Evidence-Based Subjective Logic, proof-carrying trust, and EQBSL trust systems.",
   "requestFramePermissions": []
 }