positive and negative links for stock-flow diagrams

Author: tim-at-topos

packages/catlog-wasm/src/theories.rs

@@ -12,7 +12,7 @@ use catlog::one::Path;
 use catlog::stdlib::{analyses, models, theories, theory_morphisms};
 use catlog::zero::name;
 
-use super::model_morphism::{MotifOccurrence, MotifsOptions, motifs};
+use super::model_morphism::{motifs, MotifOccurrence, MotifsOptions};
 use super::result::JsResult;
 use super::{analyses::*, model::DblModel, theory::DblTheory};
 
@@ -304,6 +304,39 @@ impl ThCategoryLinks {
     }
 }
 
+/// The theory of categories with signed links.
+#[wasm_bindgen]
+pub struct ThCategorySignedLinks(Rc<theory::DiscreteTabTheory>);
+
+#[wasm_bindgen]
+impl ThCategorySignedLinks {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self(Rc::new(theories::th_category_signed_links()))
+    }
+
+    #[wasm_bindgen]
+    pub fn theory(&self) -> DblTheory {
+        DblTheory(self.0.clone().into())
+    }
+
+    /// Simulates the mass-action ODE system derived from a model.
+    #[wasm_bindgen(js_name = "massAction")]
+    pub fn mass_action(
+        &self,
+        model: &DblModel,
+        data: analyses::ode::MassActionProblemData,
+    ) -> Result<ODEResult, String> {
+        Ok(ODEResult(
+            analyses::ode::StockFlowMassActionAnalysis::default()
+                .build_numerical_system(model.discrete_tab()?, data)
+                .solve_with_defaults()
+                .map_err(|err| format!("{err:?}"))
+                .into(),
+        ))
+    }
+}
+
 /// The theory of strict symmetric monoidal categories.
 #[wasm_bindgen]
 pub struct ThSymMonoidalCategory(Rc<theory::ModalDblTheory>);

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

@@ -22,7 +22,7 @@ use crate::dbl::{
 };
 use crate::one::FgCategory;
 use crate::simulate::ode::{NumericalPolynomialSystem, ODEProblem, PolynomialSystem};
-use crate::zero::{QualifiedName, alg::Polynomial, name, rig::Monomial};
+use crate::zero::{alg::Polynomial, name, rig::Monomial, QualifiedName};
 
 /// Data defining a mass-action ODE problem for a model.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -218,7 +218,9 @@ pub struct StockFlowMassActionAnalysis {
     /// Morphism types for flows between stocks.
     pub flow_mor_type: TabMorType,
     /// Morphism types for links for stocks to flows.
-    pub link_mor_type: TabMorType,
+    pub pos_link_mor_type: TabMorType,
+    /// Morphism types for links for stocks to flows.
+    pub neg_link_mor_type: TabMorType,
 }
 
 impl Default for StockFlowMassActionAnalysis {
@@ -228,7 +230,8 @@ impl Default for StockFlowMassActionAnalysis {
         Self {
             stock_ob_type,
             flow_mor_type,
-            link_mor_type: TabMorType::Basic(name("Link")),
+            pos_link_mor_type: TabMorType::Basic(name("PositiveLink")),
+            neg_link_mor_type: TabMorType::Basic(name("NegativeLink")),
         }
     }
 }
@@ -247,7 +250,20 @@ impl StockFlowMassActionAnalysis {
             })
             .collect();
 
-        for link in model.mor_generators_with_type(&self.link_mor_type) {
+        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) {
+                *term = std::mem::take(term) * Monomial::generator(dom);
+            } else {
+                panic!("Codomain of link does not belong to model");
+            };
+        }
+
+        for link in model.mor_generators_with_type(&self.neg_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 {

packages/catlog/src/stdlib/theories.rs

@@ -1,7 +1,7 @@
 //! Standard library of double theories.
 
 use crate::dbl::theory::*;
-use crate::one::{Path, fp_category::FpCategory};
+use crate::one::{fp_category::FpCategory, Path};
 use crate::zero::name;
 
 /// The empty theory, which has a single model, the empty model.
@@ -119,6 +119,27 @@ pub fn th_category_links() -> DiscreteTabTheory {
     th
 }
 
+/// The theory of categories with signed links.
+///
+/// It can be useful to consider a version of stock and flow diagrams where the
+/// links are labelled with a sign: positive or negative
+pub fn th_category_signed_links() -> DiscreteTabTheory {
+    let mut th = DiscreteTabTheory::new();
+    th.add_ob_type(name("Object"));
+    let ob_type = TabObType::Basic(name("Object"));
+    th.add_mor_type(
+        name("PositiveLink"),
+        ob_type.clone(),
+        th.tabulator(th.hom_type(ob_type.clone())),
+    );
+    th.add_mor_type(
+        name("NegativeLink"),
+        ob_type.clone(),
+        th.tabulator(th.hom_type(ob_type.clone())),
+    );
+    th
+}
+
 /// The theory of strict monoidal categories.
 pub fn th_monoidal_category() -> ModalDblTheory {
     th_list_algebra(List::Plain)

packages/frontend/src/stdlib/theories.ts

@@ -78,7 +78,7 @@ stdTheories.add(
     {
         id: "primitive-stock-flow",
         name: "Stock and flow",
-        description: "Model accumulation (stocks) and change (flows)",
+        description: "Accumulation (stocks) and change (flows)",
         group: "System Dynamics",
     },
     async () => (await import("./theories/primitive-stock-flow")).default,

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

@@ -1,11 +1,11 @@
-import { ThCategoryLinks } from "catlog-wasm";
+import { ThCategorySignedLinks } from "catlog-wasm";
 import { Theory, type TheoryMeta } from "../../theory";
 import * as analyses from "../analyses";
 import styles from "../styles.module.css";
 import svgStyles from "../svg_styles.module.css";
 
 export default function createPrimitiveStockFlowTheory(theoryMeta: TheoryMeta): Theory {
-    const thCategoryLinks = new ThCategoryLinks();
+    const thCategoryLinks = new ThCategorySignedLinks();
 
     return new Theory({
         ...theoryMeta,
@@ -34,12 +34,22 @@ export default function createPrimitiveStockFlowTheory(theoryMeta: TheoryMeta):
             },
             {
                 tag: "MorType",
-                morType: { tag: "Basic", content: "Link" },
-                name: "Link",
-                description: "Influence of a stock on a flow",
+                morType: { tag: "Basic", content: "PositiveLink" },
+                name: "Positive link",
+                description: "Positive influence of a stock on a flow",
+                arrowStyle: "plus",
                 preferUnnamed: true,
                 shortcut: ["L"],
             },
+            {
+                tag: "MorType",
+                morType: { tag: "Basic", content: "NegativeLink" },
+                name: "Negative link",
+                description: "Negative influence of a stock on a flow",
+                arrowStyle: "minus",
+                preferUnnamed: true,
+                shortcut: ["K"],
+            },
         ],
         modelAnalyses: [
             analyses.stockFlowDiagram({