Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

examples/prime-radiant/src/category/topos.rs

@@ -0,0 +1,294 @@
+//! Topos implementation
+
+use super::{Category, Morphism};
+use crate::{Error, Result};
+use nalgebra::DMatrix;
+use std::collections::HashMap;
+
+/// A topos - a category with logical structure
+///
+/// A topos is a category that:
+/// 1. Has all finite limits (terminal object, products, equalizers)
+/// 2. Has exponentials (function objects)
+/// 3. Has a subobject classifier Ω
+///
+/// Topoi provide a foundation for constructive logic and type theory.
+#[derive(Debug, Clone)]
+pub struct Topos {
+    /// Underlying category
+    category: Category,
+    /// Terminal object
+    terminal: Option<String>,
+    /// Subobject classifier
+    subobject_classifier: Option<SubobjectClassifier>,
+    /// Product objects
+    products: HashMap<(String, String), Product>,
+    /// Exponential objects
+    exponentials: HashMap<(String, String), Exponential>,
+}
+
+/// The subobject classifier Ω
+#[derive(Debug, Clone)]
+pub struct SubobjectClassifier {
+    /// Object name
+    pub object: String,
+    /// Truth morphism true: 1 -> Ω
+    pub truth: Morphism,
+}
+
+/// A product object A × B
+#[derive(Debug, Clone)]
+pub struct Product {
+    /// Product object name
+    pub object: String,
+    /// First projection π₁: A × B -> A
+    pub proj1: Morphism,
+    /// Second projection π₂: A × B -> B
+    pub proj2: Morphism,
+}
+
+/// An exponential object B^A (internal hom)
+#[derive(Debug, Clone)]
+pub struct Exponential {
+    /// Exponential object name
+    pub object: String,
+    /// Evaluation morphism eval: B^A × A -> B
+    pub eval: Morphism,
+}
+
+impl Topos {
+    /// Create a new topos from a category
+    pub fn new(category: Category) -> Self {
+        Self {
+            category,
+            terminal: None,
+            subobject_classifier: None,
+            products: HashMap::new(),
+            exponentials: HashMap::new(),
+        }
+    }
+
+    /// Get the underlying category
+    pub fn category(&self) -> &Category {
+        &self.category
+    }
+
+    /// Get mutable reference to underlying category
+    pub fn category_mut(&mut self) -> &mut Category {
+        &mut self.category
+    }
+
+    /// Set the terminal object
+    pub fn set_terminal(&mut self, object: impl Into<String>) {
+        self.terminal = Some(object.into());
+    }
+
+    /// Get the terminal object
+    pub fn terminal(&self) -> Option<&str> {
+        self.terminal.as_deref()
+    }
+
+    /// Set the subobject classifier
+    pub fn set_subobject_classifier(&mut self, object: impl Into<String>, truth: Morphism) {
+        self.subobject_classifier = Some(SubobjectClassifier {
+            object: object.into(),
+            truth,
+        });
+    }
+
+    /// Get the subobject classifier
+    pub fn subobject_classifier(&self) -> Option<&SubobjectClassifier> {
+        self.subobject_classifier.as_ref()
+    }
+
+    /// Define a product A × B
+    pub fn define_product(
+        &mut self,
+        a: impl Into<String>,
+        b: impl Into<String>,
+        product: impl Into<String>,
+        proj1: Morphism,
+        proj2: Morphism,
+    ) {
+        let a = a.into();
+        let b = b.into();
+        self.products.insert(
+            (a.clone(), b.clone()),
+            Product {
+                object: product.into(),
+                proj1,
+                proj2,
+            },
+        );
+    }
+
+    /// Get a product
+    pub fn product(&self, a: &str, b: &str) -> Option<&Product> {
+        self.products.get(&(a.to_string(), b.to_string()))
+    }
+
+    /// Define an exponential B^A
+    pub fn define_exponential(
+        &mut self,
+        a: impl Into<String>,
+        b: impl Into<String>,
+        exp: impl Into<String>,
+        eval: Morphism,
+    ) {
+        let a = a.into();
+        let b = b.into();
+        self.exponentials.insert(
+            (a.clone(), b.clone()),
+            Exponential {
+                object: exp.into(),
+                eval,
+            },
+        );
+    }
+
+    /// Get an exponential
+    pub fn exponential(&self, a: &str, b: &str) -> Option<&Exponential> {
+        self.exponentials.get(&(a.to_string(), b.to_string()))
+    }
+
+    /// Check if this is a valid topos
+    pub fn is_valid(&self) -> Result<bool> {
+        // Check terminal object exists
+        if self.terminal.is_none() {
+            return Ok(false);
+        }
+
+        // Check subobject classifier exists
+        if self.subobject_classifier.is_none() {
+            return Ok(false);
+        }
+
+        // More checks would be needed for a complete verification
+        Ok(true)
+    }
+
+    /// Compute the characteristic morphism for a subobject
+    ///
+    /// Given a monomorphism m: A >-> B, compute χ_m: B -> Ω
+    pub fn characteristic_morphism(&self, _mono: &Morphism) -> Result<Morphism> {
+        let omega = self
+            .subobject_classifier
+            .as_ref()
+            .ok_or_else(|| Error::CategoryViolation("No subobject classifier".to_string()))?;
+
+        // Placeholder: return morphism to Ω
+        // Actual computation requires pullback
+        Ok(Morphism::new(
+            "chi",
+            "B",
+            omega.object.clone(),
+            DMatrix::zeros(1, 1),
+        ))
+    }
+
+    /// Internal logic: conjunction A ∧ B
+    pub fn conjunction(&self, a: &str, b: &str) -> Result<Morphism> {
+        // In a topos, conjunction is computed via pullback along (true, true)
+        let omega = self
+            .subobject_classifier
+            .as_ref()
+            .ok_or_else(|| Error::CategoryViolation("No subobject classifier".to_string()))?;
+
+        Ok(Morphism::new(
+            "and",
+            format!("{}x{}", omega.object, omega.object),
+            omega.object.clone(),
+            DMatrix::identity(1, 1),
+        ))
+    }
+
+    /// Internal logic: implication A ⟹ B
+    pub fn implication(&self, a: &str, b: &str) -> Result<Morphism> {
+        let omega = self
+            .subobject_classifier
+            .as_ref()
+            .ok_or_else(|| Error::CategoryViolation("No subobject classifier".to_string()))?;
+
+        Ok(Morphism::new(
+            "implies",
+            format!("{}x{}", omega.object, omega.object),
+            omega.object.clone(),
+            DMatrix::identity(1, 1),
+        ))
+    }
+}
+
+/// Build a topos from scratch
+#[derive(Debug, Default)]
+pub struct ToposBuilder {
+    category: Category,
+    terminal: Option<String>,
+    subobject_classifier: Option<(String, Morphism)>,
+}
+
+impl ToposBuilder {
+    /// Create a new builder
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            category: Category::new(name),
+            terminal: None,
+            subobject_classifier: None,
+        }
+    }
+
+    /// Add an object
+    pub fn object(mut self, name: impl Into<String>, dim: usize) -> Self {
+        self.category.add_object(name, dim);
+        self
+    }
+
+    /// Set terminal object
+    pub fn terminal(mut self, name: impl Into<String>) -> Self {
+        self.terminal = Some(name.into());
+        self
+    }
+
+    /// Set subobject classifier
+    pub fn subobject_classifier(mut self, name: impl Into<String>, truth: Morphism) -> Self {
+        self.subobject_classifier = Some((name.into(), truth));
+        self
+    }
+
+    /// Build the topos
+    pub fn build(self) -> Topos {
+        let mut topos = Topos::new(self.category);
+        if let Some(t) = self.terminal {
+            topos.set_terminal(t);
+        }
+        if let Some((name, truth)) = self.subobject_classifier {
+            topos.set_subobject_classifier(name, truth);
+        }
+        topos
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_topos_creation() {
+        let cat = Category::new("Test");
+        let topos = Topos::new(cat);
+        assert!(topos.terminal().is_none());
+    }
+
+    #[test]
+    fn test_topos_builder() {
+        let truth = Morphism::new("true", "1", "Omega", DMatrix::from_element(2, 1, 1.0));
+
+        let topos = ToposBuilder::new("Set")
+            .object("1", 1)
+            .object("Omega", 2)
+            .terminal("1")
+            .subobject_classifier("Omega", truth)
+            .build();
+
+        assert!(topos.is_valid().unwrap());
+    }
+}