fixing tests; walking singed links

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::{motifs, MotifOccurrence, MotifsOptions};
+use super::model_morphism::{MotifOccurrence, MotifsOptions, motifs};
 use super::result::JsResult;
 use super::{analyses::*, model::DblModel, theory::DblTheory};
 

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::{alg::Polynomial, name, rig::Monomial, QualifiedName};
+use crate::zero::{QualifiedName, alg::Polynomial, name, rig::Monomial};
 
 /// Data defining a mass-action ODE problem for a model.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -250,10 +250,21 @@ impl StockFlowMassActionAnalysis {
             })
             .collect();
 
-        for link in model
-            .mor_generators_with_type(&self.pos_link_mor_type)
-            .chain(model.mor_generators_with_type(&self.neg_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) {
+                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.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 {
@@ -331,9 +342,9 @@ mod tests {
     use crate::stdlib::{models::*, theories::*};
 
     #[test]
-    fn backward_link_dynamics() {
+    fn positive_backward_link_dynamics() {
         let th = Rc::new(th_category_links());
-        let model = backward_link(th);
+        let model = positive_backward_link(th);
         let sys = StockFlowMassActionAnalysis::default().build_system(&model);
         let expected = expect!([r#"
             dx = ((-1) f) x y
@@ -342,6 +353,18 @@ mod tests {
         expected.assert_eq(&sys.to_string());
     }
 
+    #[test]
+    fn negative_backward_link_dynamics() {
+        let th = Rc::new(th_category_links());
+        let model = positive_backward_link(th);
+        let sys = StockFlowMassActionAnalysis::default().build_system(&model);
+        let expected = expect!([r#"
+            dx = ((-1) f) x y^{-1}
+            dy = f x y^{-1}
+        "#]);
+        expected.assert_eq(&sys.to_string());
+    }
+
     #[test]
     fn catalysis_dynamics() {
         let th = Rc::new(th_sym_monoidal_category());

packages/catlog/src/stdlib/models.rs

@@ -108,6 +108,44 @@ pub fn backward_link(th: Rc<DiscreteTabTheory>) -> DiscreteTabModel {
     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("PositiveLink")),
+    );
+    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/catlog/src/stdlib/theories.rs

@@ -1,7 +1,7 @@
 //! Standard library of double theories.
 
 use crate::dbl::theory::*;
-use crate::one::{fp_category::FpCategory, Path};
+use crate::one::{Path, fp_category::FpCategory};
 use crate::zero::name;
 
 /// The empty theory, which has a single model, the empty model.

packages/catlog/src/zero/rig.rs

@@ -14,7 +14,7 @@
 //! the same data structure, but with different notation!
 
 use num_traits::{One, Pow, Zero};
-use std::collections::{btree_map, BTreeMap};
+use std::collections::{BTreeMap, btree_map};
 use std::fmt::Display;
 use std::iter::{Product, Sum};
 use std::ops::{Add, AddAssign, Mul, MulAssign, Neg};