first draft; no tests

Author: tim-at-topos

packages/catlog/src/stdlib/analyses/mod.rs

@@ -4,3 +4,4 @@
 pub mod ode;
 
 pub mod reachability;
+pub mod signed_links_to_signed_cat;

packages/catlog/src/stdlib/analyses/ode/mass_action.rs

@@ -215,11 +215,11 @@ impl PetriNetMassActionAnalysis {
 pub struct StockFlowMassActionAnalysis {
     /// Object type for stocks.
     pub stock_ob_type: TabObType,
-    /// Morphism type for flows between stocks.
+    /// Morphism types for flows between stocks.
     pub flow_mor_type: TabMorType,
-    /// Morphism type for positive links from stocks to flows.
+    /// Morphism types for links for stocks to flows.
     pub pos_link_mor_type: TabMorType,
-    /// Morphism type for negative links from stocks to flows.
+    /// Morphism types for links for stocks to flows.
     pub neg_link_mor_type: TabMorType,
 }
 
@@ -250,25 +250,32 @@ impl StockFlowMassActionAnalysis {
             })
             .collect();
 
-        let mut multiply_for_link = |link: QualifiedName, exponent: i8| {
+        for link in model.mor_generators_with_type(&self.pos_link_mor_type) {
             let dom = model.mor_generator_dom(&link).unwrap_basic();
             let path = model.mor_generator_cod(&link).unwrap_tabulated();
             let Some(TabEdge::Basic(cod)) = path.only() else {
                 panic!("Codomain of link should be basic morphism");
             };
             if let Some(term) = terms.get_mut(&cod) {
-                let mon: Monomial<_, i8> = [(dom, exponent)].into_iter().collect();
+                let mon: Monomial<_, i8> = [(dom, 1)].into_iter().collect();
                 *term = std::mem::take(term) * mon;
             } else {
                 panic!("Codomain of link does not belong to model");
             };
-        };
-
-        for link in model.mor_generators_with_type(&self.pos_link_mor_type) {
-            multiply_for_link(link, 1);
         }
+
         for link in model.mor_generators_with_type(&self.neg_link_mor_type) {
-            multiply_for_link(link, -1);
+            let dom = model.mor_generator_dom(&link).unwrap_basic();
+            let path = model.mor_generator_cod(&link).unwrap_tabulated();
+            let Some(TabEdge::Basic(cod)) = path.only() else {
+                panic!("Codomain of link should be basic morphism");
+            };
+            if let Some(term) = terms.get_mut(&cod) {
+                let mon: Monomial<_, i8> = [(dom, -1)].into_iter().collect();
+                *term = std::mem::take(term) * mon;
+            } else {
+                panic!("Codomain of link does not belong to model");
+            };
         }
 
         let terms: Vec<_> = terms

packages/catlog/src/stdlib/analyses/signed_links_to_signed_cat.rs

@@ -0,0 +1,91 @@
+//! Migration for going from categories with signed links to signed categories
+//  (e.g. from signed stock-flow diagrams to causal loop diagrams)
+
+use crate::dbl::discrete_tabulator::theory::TabMorType;
+use crate::dbl::discrete_tabulator::theory::TabObType;
+use std::rc::Rc;
+
+use crate::dbl::discrete::model::DiscreteDblModel;
+use crate::dbl::discrete_tabulator::model::DiscreteTabModel;
+use crate::dbl::model::{FgDblModel, MutDblModel};
+use crate::one::category::FgCategory;
+use crate::one::path::Path;
+use crate::stdlib::theories;
+use crate::zero::name;
+
+/** Span-migration for categories with signed links.
+ *  
+ *  We create a CLD from a category with signed links from the query defined on
+ *  objects as
+ *  
+ *  V  |-> stock : S | flow : F
+ *  E+ |-> out : F   | link : L+
+ *  E- |-> in : F    | link : L-
+ *
+ *  and on morphisms as (...) something that will be written up eventually, but
+ *  in short can be described quite simply in words:
+ *
+ *    - For each stock, create a vertex
+ *    - For each flow, create a (+,-)-span, where the apex is a new vertex
+ *      corresponding to the flow, and there is a negative arrow to the (vertex
+ *      corresponding to the) source of the flow, and a positive arrow to the
+ *      (vertex corresponding to the) target of the flow
+ *    - For each (signed) link, create an arrow (of the same sign) from the
+ *      (vertex corresponding to the) source stock to the (vertex corresponding
+ *      to the) target flow
+ */
+pub fn migrate(model: DiscreteTabModel) -> DiscreteDblModel {
+    let mut migrated_model: DiscreteDblModel =
+        DiscreteDblModel::new(Rc::new(theories::th_signed_category()));
+
+    let stock_type = TabObType::Basic(name("Object"));
+    let flow_type = TabMorType::Hom(Box::new(stock_type.clone()));
+    let pos_link_type = TabMorType::Basic(name("Link"));
+    let neg_link_type = TabMorType::Basic(name("NegativeLink"));
+
+    // Create an object for each stock (a "stock-object")
+    for s in model.ob_generators() {
+        migrated_model.add_ob(s.clone(), name("Object"));
+    }
+
+    // Create a span for each flow
+    for f in model.mor_generators_with_type(&flow_type) {
+        // An object for each flow (a "flow-object")
+        migrated_model.add_ob(f.clone(), name("Object"));
+        // A negative link from the flow object to the flow-source object
+        migrated_model.add_mor(
+            format!("{}_in", f).as_str().into(),
+            f.clone(),
+            model.mor_generator_dom(&f).unwrap_basic(),
+            Path::Id(name("Object")),
+        );
+        // A positive link from the flow object to the flow-target object
+        migrated_model.add_mor(
+            format!("{}_in", f).as_str().into(),
+            f.clone(),
+            model.mor_generator_cod(&f).unwrap_basic(),
+            name("Negative").into(),
+        );
+    }
+
+    // Create a positive arrow for each positive link
+    for pl in model.mor_generators_with_type(&pos_link_type) {
+        migrated_model.add_mor(
+            pl.clone(),
+            model.mor_generator_dom(&pl).unwrap_basic(),
+            model.mor_generator_cod(&pl).unwrap_basic(),
+            Path::Id(name("Object")),
+        );
+    }
+    // Create a negative arrow for each negative link
+    for nl in model.mor_generators_with_type(&neg_link_type) {
+        migrated_model.add_mor(
+            nl.clone(),
+            model.mor_generator_dom(&nl).unwrap_basic(),
+            model.mor_generator_cod(&nl).unwrap_basic(),
+            name("Negative").into(),
+        );
+    }
+
+    migrated_model
+}

packages/catlog/src/stdlib/models.rs

@@ -124,6 +124,44 @@ fn backward_link_of_type(th: Rc<DiscreteTabTheory>, link_type: TabMorType) -> Di
     model
 }
 
+/// The "walking" backward positive link.
+///
+/// This is the free category with signed links that has a positive link from
+/// the codomain of a morphism back to the morphism itself.
+pub fn positive_backward_link(th: Rc<DiscreteTabTheory>) -> DiscreteTabModel {
+    let ob_type = TabObType::Basic(name("Object"));
+    let mut model = DiscreteTabModel::new(th.clone());
+    model.add_ob(name("x"), ob_type.clone());
+    model.add_ob(name("y"), ob_type.clone());
+    model.add_mor(name("f"), name("x").into(), name("y").into(), th.hom_type(ob_type));
+    model.add_mor(
+        name("link"),
+        name("y").into(),
+        model.tabulated_gen(name("f")),
+        TabMorType::Basic(name("Link")),
+    );
+    model
+}
+
+/// The "walking" backward negative link.
+///
+/// This is the free category with signed links that has a negative link from
+/// the codomain of a morphism back to the morphism itself.
+pub fn negative_backward_link(th: Rc<DiscreteTabTheory>) -> DiscreteTabModel {
+    let ob_type = TabObType::Basic(name("Object"));
+    let mut model = DiscreteTabModel::new(th.clone());
+    model.add_ob(name("x"), ob_type.clone());
+    model.add_ob(name("y"), ob_type.clone());
+    model.add_mor(name("f"), name("x").into(), name("y").into(), th.hom_type(ob_type));
+    model.add_mor(
+        name("link"),
+        name("y").into(),
+        model.tabulated_gen(name("f")),
+        TabMorType::Basic(name("NegativeLink")),
+    );
+    model
+}
+
 /// A reaction involving three species, one playing the role of a catalyst.
 ///
 /// A free symmetric monoidal category, viewed as a reaction network.

packages/frontend/src/stdlib/theories.ts

@@ -8,7 +8,6 @@ stdTheories.add(
         id: "empty",
         name: "Informal",
         description: "The empty logic, allowing only informal content",
-        iconLetters: ["I", "n"],
         isDefault: true,
         group: "Base",
     },
@@ -20,7 +19,6 @@ stdTheories.add(
         id: "simple-olog",
         name: "Olog",
         description: "Ontology log, a simple conceptual model",
-        iconLetters: ["O", "l"],
         group: "Knowledge and Data",
     },
     async () => (await import("./theories/simple-olog")).default,
@@ -31,7 +29,6 @@ stdTheories.add(
         id: "simple-schema",
         name: "Schema",
         description: "Schema for a categorical database",
-        iconLetters: ["S", "c"],
         group: "Knowledge and Data",
     },
     async () => (await import("./theories/simple-schema")).default,
@@ -42,7 +39,6 @@ stdTheories.add(
         id: "petri-net",
         name: "Petri net",
         description: "Place/transition networks",
-        iconLetters: ["P", "n"],
         group: "Systems",
     },
     async () => (await import("./theories/petri-net")).default,
@@ -53,7 +49,6 @@ stdTheories.add(
         id: "causal-loop",
         name: "Causal loop diagram",
         description: "Positive and negative causal relationships",
-        iconLetters: ["C", "l"],
         group: "System Dynamics",
     },
     async () => (await import("./theories/causal-loop")).default,
@@ -64,7 +59,6 @@ stdTheories.add(
         id: "causal-loop-delays",
         name: "Causal loop diagram with delays",
         description: "Causal relationships: positive or negative, fast or slow",
-        iconLetters: ["C", "d"],
         group: "System Dynamics",
     },
     async () => (await import("./theories/causal-loop-delays")).default,
@@ -75,7 +69,6 @@ stdTheories.add(
         id: "indeterminate-causal-loop",
         name: "Causal loop diagram with indeterminates",
         description: "Positive, negative, and indeterminate causal relationships",
-        iconLetters: ["C", "i"],
         group: "System Dynamics",
     },
     async () => (await import("./theories/indeterminate-causal-loop")).default,
@@ -86,7 +79,6 @@ stdTheories.add(
         id: "primitive-stock-flow",
         name: "Stock and flow",
         description: "Accumulation (stocks) and change (flows)",
-        iconLetters: ["S", "F"],
         group: "System Dynamics",
     },
     async () => (await import("./theories/primitive-stock-flow")).default,
@@ -97,7 +89,6 @@ stdTheories.add(
         id: "primitive-signed-stock-flow",
         name: "Stock and flow with signed links",
         description: "Accumulation (stocks) and change (flows), with signed links",
-        iconLetters: ["S", "F"],
         group: "System Dynamics",
     },
     async () => (await import("./theories/primitive-signed-stock-flow")).default,
@@ -108,7 +99,6 @@ stdTheories.add(
         id: "reg-net",
         name: "Regulatory network",
         description: "Biochemical species that promote or inhibit each other",
-        iconLetters: ["R", "n"],
         group: "Biology",
     },
     async () => (await import("./theories/reg-net")).default,
@@ -119,7 +109,6 @@ stdTheories.add(
         id: "unary-dec",
         name: "Discrete exterior calculus (DEC)",
         description: "DEC operators on a geometrical space",
-        iconLetters: ["D", "c"],
         group: "Experimental",
     },
     async () => (await import("./theories/unary-dec")).default,
@@ -130,7 +119,6 @@ stdTheories.add(
         id: "power-system",
         name: "Power system",
         description: "Power systems in the style of PyPSA",
-        iconLetters: ["P", "s"],
         group: "Experimental",
     },
     async () => (await import("./theories/power-system")).default,

packages/frontend/src/stdlib/theories/primitive-signed-stock-flow.ts

@@ -4,7 +4,7 @@ import * as analyses from "../analyses";
 import styles from "../styles.module.css";
 import svgStyles from "../svg_styles.module.css";
 
-export default function createPrimitiveSignedStockFlowTheory(theoryMeta: TheoryMeta): Theory {
+export default function createPrimitiveStockFlowTheory(theoryMeta: TheoryMeta): Theory {
     const thCategorySignedLinks = new ThCategorySignedLinks();
 
     return new Theory({
@@ -39,7 +39,7 @@ export default function createPrimitiveSignedStockFlowTheory(theoryMeta: TheoryM
                 description: "Positive influence of a stock on a flow",
                 arrowStyle: "plus",
                 preferUnnamed: true,
-                shortcut: ["P"],
+                shortcut: ["L"],
             },
             {
                 tag: "MorType",
@@ -48,7 +48,7 @@ export default function createPrimitiveSignedStockFlowTheory(theoryMeta: TheoryM
                 description: "Negative influence of a stock on a flow",
                 arrowStyle: "minus",
                 preferUnnamed: true,
-                shortcut: ["N"],
+                shortcut: ["K"],
             },
         ],
         modelAnalyses: [