CRNNondim 1.0.0__tar.gz

crnnondim-1.0.0/.gitignore

@@ -0,0 +1,90 @@
+# ------------------------------------------------------------------------------
+# OS files
+# ------------------------------------------------------------------------------
+.DS_Store
+Thumbs.db
+
+# ------------------------------------------------------------------------------
+# Python bytecode / cache
+# ------------------------------------------------------------------------------
+__pycache__/
+*.py[cod]
+*$py.class
+
+# ------------------------------------------------------------------------------
+# Virtual environments
+# ------------------------------------------------------------------------------
+.venv/
+venv/
+env/
+ENV/
+
+# Conda
+.conda/
+conda-env/
+*.conda
+
+# ------------------------------------------------------------------------------
+# Build / packaging
+# ------------------------------------------------------------------------------
+build/
+dist/
+*.egg-info/
+.eggs/
+pip-wheel-metadata/
+*.egg
+
+# ------------------------------------------------------------------------------
+# Logs / debugging
+# ------------------------------------------------------------------------------
+*.log
+*.tmp
+
+# ------------------------------------------------------------------------------
+# Test / coverage artifacts
+# ------------------------------------------------------------------------------
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+.cache/
+
+# ------------------------------------------------------------------------------
+# Notebooks
+# ------------------------------------------------------------------------------
+.ipynb_checkpoints/
+
+# ------------------------------------------------------------------------------
+# Editors / IDEs
+# ------------------------------------------------------------------------------
+.vscode/
+.idea/
+*.iml
+
+# ------------------------------------------------------------------------------
+# Documentation builds (if using Sphinx, etc.)
+# ------------------------------------------------------------------------------
+docs/_build/
+site/
+
+# ------------------------------------------------------------------------------
+# Environment / local config
+# ------------------------------------------------------------------------------
+.env
+.env.*
+*.env
+
+# ------------------------------------------------------------------------------
+# uv / Python version files
+# ------------------------------------------------------------------------------
+.python-version
+.uv_cache/
+.uv-cache/
+
+# ------------------------------------------------------------------------------
+# Misc
+# ------------------------------------------------------------------------------
+*.swp
+*.swo

crnnondim-1.0.0/CITATION.cff

@@ -0,0 +1,17 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite the following paper."
+title: "Algorithmic Non-dimensionalisation of Polynomial Dynamical Systems with CRNNondim"
+authors:
+  - family-names: "Hawi"
+    given-names: "Georgio"
+  - family-names: "Wechselberger"
+    given-names: "Martin"
+preferred-citation:
+  type: article
+  authors:
+    - family-names: "Hawi"
+      given-names: "Georgio"
+    - family-names: "Wechselberger"
+      given-names: "Martin"
+  title: "Algorithmic Non-dimensionalisation of Polynomial Dynamical Systems with CRNNondim"
+  year: 2026

crnnondim-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Georgio Hawi and Martin Wechselberger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crnnondim-1.0.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.5
+Name: CRNNondim
+Version: 1.0.0
+Summary: Automated non-dimensionalisation of polynomial dynamical systems via chemical reaction networks
+Project-URL: Homepage, https://github.com/georgio-hawi/crnnondim
+Project-URL: Repository, https://github.com/georgio-hawi/crnnondim
+Author-email: Georgio Hawi <georgio.hawi@sydney.edu.au>, Martin Wechselberger <martin.wechselberger@sydney.edu.au>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: CRN,non-dimensionalisation,polynomial dynamical system
+Requires-Python: <3.13,>=3.11.7
+Requires-Dist: numpy<2,>=1.26.4
+Requires-Dist: scipy<2,>=1.14.0
+Requires-Dist: sympy<2,>=1.13.1
+Description-Content-Type: text/markdown
+
+# CRNNondim
+CRNNondim is a Python library for automating the non-dimensionalisation of polynomial dynamical systems via chemical reaction networks (CRNs). It was developed by Georgio Hawi and Martin Wechselberger, with an accompanying paper available soon. Please direct all enquiries to georgio.hawi (at) sydney.edu.au.
+
+Given a polynomial CRN, CRNNondim helps you move from human-readable reaction lists to carefully chosen dimensionless variables and parameters. You can analyse a proposed non-dimensionalisation, or ask the library to search for one that is optimal under a precise objective (for example, keeping parameters O(1) over a chosen time window).
+
+CRNNondim provides tools to automate analysing and non-dimensionalising chemical reaction networks (CRNs). 
+CRNNondim includes functions that let you:
+- parse readable reaction network descriptions or a polynomial ODE system into a symbolic CRN-like ODE system (stoichiometry matrix `S`, reaction vector `V`, species vector `X`, and rate constants),
+- analyse CRNs to derive algebraic constraints on concentration and time scales and construct non-dimensionalisations that minimise the number of free parameters,
+- non-dimensionalise a CRN given an explicit choice of species scales, so you can test or refine hand-crafted scalings,
+- search for optimal non-dimensionalisations using typical initial conditions and rate constants, targeting O(1) parameters over a specified time window

crnnondim-1.0.0/README.md

@@ -0,0 +1,11 @@
+# CRNNondim
+CRNNondim is a Python library for automating the non-dimensionalisation of polynomial dynamical systems via chemical reaction networks (CRNs). It was developed by Georgio Hawi and Martin Wechselberger, with an accompanying paper available soon. Please direct all enquiries to georgio.hawi (at) sydney.edu.au.
+
+Given a polynomial CRN, CRNNondim helps you move from human-readable reaction lists to carefully chosen dimensionless variables and parameters. You can analyse a proposed non-dimensionalisation, or ask the library to search for one that is optimal under a precise objective (for example, keeping parameters O(1) over a chosen time window).
+
+CRNNondim provides tools to automate analysing and non-dimensionalising chemical reaction networks (CRNs). 
+CRNNondim includes functions that let you:
+- parse readable reaction network descriptions or a polynomial ODE system into a symbolic CRN-like ODE system (stoichiometry matrix `S`, reaction vector `V`, species vector `X`, and rate constants),
+- analyse CRNs to derive algebraic constraints on concentration and time scales and construct non-dimensionalisations that minimise the number of free parameters,
+- non-dimensionalise a CRN given an explicit choice of species scales, so you can test or refine hand-crafted scalings,
+- search for optimal non-dimensionalisations using typical initial conditions and rate constants, targeting O(1) parameters over a specified time window

crnnondim-1.0.0/examples/5D_SEIRV_example.py

@@ -0,0 +1,78 @@
+"""
+Examples showing how to use poly_system_to_CRN to convert the
+5D SEIRV epidemic model to a mass-action CRN representation (S, V, X, etc),
+and use process_CRN to analyse it.
+"""
+import sympy as sp
+from crnnondim import poly_system_to_CRN, process_CRN, analyse_results
+
+# ---------------------------------------------------------------------------
+# Example: 5D SEIRV epidemic model
+# ---------------------------------------------------------------------------
+# STATE VARIABLES (species):
+#   S(t): Susceptible individuals
+#   E(t): Exposed (infected but not yet infectious)
+#   I(t): Infectious
+#   R(t): Recovered with immunity
+#   V(t): Vaccinated and currently protected
+#
+# PARAMETERS:
+#   Lambda   : recruitment rate (birth/immigration) into S
+#   mu       : natural per-capita death rate (applies to all compartments)
+#   beta     : infection rate (S becomes E via contact with I)
+#   sigma    : progression rate from exposed to infectious (E -> I)
+#   gamma    : recovery rate from infectious to recovered (I -> R)
+#   nu       : vaccination rate of susceptibles (S -> V)
+#   omega    : waning immunity rate in recovered (R -> S)
+#   omega_V  : waning vaccine protection rate (V -> S)
+#
+# MODEL EQUATIONS:
+#
+#   dS/dt = Lambda - beta*S*I - nu*S + omega*R + omega_V*V - mu*S
+#   dE/dt = beta*S*I - sigma*E - mu*E
+#   dI/dt = sigma*E - gamma*I - mu*I
+#   dR/dt = gamma*I - omega*R - mu*R
+#   dV/dt = nu*S - omega_V*V - mu*V
+# ---------------------------------------------------------------------------
+
+# Define species (state variables) as SymPy symbols
+S, E, I, R, V = sp.symbols("S E I R V", nonnegative=True)
+X_syms = [S, E, I, R, V]
+
+# Define parameters as SymPy symbols (positive)
+Lambda, mu, beta, sigma, gamma, nu, omega, omega_V = sp.symbols(
+    "Lambda mu beta sigma gamma nu omega omega_V", positive=True
+)
+
+# ODE right-hand sides
+dXdt = [
+    Lambda - beta*S*I - nu*S + omega*R + omega_V*V - mu*S,
+    beta*S*I - sigma*E - mu*E,
+    sigma*E - gamma*I - mu*I,
+    gamma*I - omega*R - mu*R,
+    nu*S - omega_V*V - mu*V]
+
+# Convert the ODE system into objects usable by CRNNondim and print a small summary of the parsed CRN.
+parsed_out = poly_system_to_CRN(
+    _X=X_syms,
+    ode_rhs=dXdt,
+    verbose=True
+)
+
+species_names = parsed_out["species"]
+_S = parsed_out['_S']
+_X = parsed_out['_X']
+_V = parsed_out['_V']
+rate_constants = parsed_out['rate_constants']
+
+# Map species -> scale symbols. These scale symbols are held fixed when analysing the CRN.
+S_0, I_0 = sp.symbols('S_0 I_0', positive=True)
+fixed_K = {S: S_0, I: I_0}
+
+# Analyse the CRN, optionally asking it to construct an explicit example 
+# non-dimensionalisation that attains the minimum possible number of 
+# free parameters (find_example_nondim=True).
+all_results = process_CRN(_S, _V, _X, fixed_K=fixed_K, find_example_nondim=True, verbose=True, basis_type="Laurent")
+
+# Analyse the results and print the analysis (if verbose=True).
+all_transformed_results = analyse_results(all_results, verbose=True)

crnnondim-1.0.0/examples/find_optimal_nondim_example.py

@@ -0,0 +1,53 @@
+"""
+Example showing how to use find_optimal_nondim to find
+the optimal non-dimensionalisation given numerical values for
+typical initial conditions and rate constants.
+"""
+
+from crnnondim import find_optimal_nondim, analyse_results, Kim_ForgerExample
+import sympy as sp
+
+def Kim_Forger_example():
+    # Instantiate the Kim-Forger example.
+    kf_example = Kim_ForgerExample()
+
+    # Example dimensional initial conditions for the species.
+    x_0_num = {kf_example.X: 1.0, kf_example.Y: 1.0, kf_example.Z: 0.06128, kf_example.S: 0.06128, kf_example.C: 0.0}
+
+    # Characteristic concentration scales for each species with non-zero initial condition.
+    x0, y0, z0, s0 = sp.symbols('x_0 y_0 z_0 s_0', positive=True)
+
+    # Map species -> scale symbols. These scale symbols are held fixed when searching for
+    # optimal non-dimensionalisations.
+    fixed_K = {kf_example.X: x0, kf_example.Y: y0, kf_example.Z: z0, kf_example.S: s0}
+
+    # Example dimensional rate constants used to evaluate O(1) deviation penalty.
+    k_num = {kf_example.k1: 0.07, kf_example.k2: 0.07, kf_example.k3: 0.05, kf_example.k4: 0.05, kf_example.k5: 0.05, kf_example.k6: 0.05, kf_example.kf: 1.0, kf_example.kb: 1.0, kf_example.ku: 0.05}
+
+    # Time window (in dimensional time) over which we want to consider a penalty.
+    T_max = 12
+    T_min = T_max/2
+
+    # Non-dimensionalisation metric
+    nondim_metric = "deviation" #"maximum"
+
+	# Dimensioanlly consistent sets
+	# Optional: list of sets of dimensionally consistent state variables
+	# default=None assumes all state variables have the same dimensions.
+    dimensionally_consistent_sets=None
+	
+    # Compute the optimal non-dimensionalisation for this CRN.
+    solver_opts=dict(method="Radau", atol=1e-12, rtol=1e-9)
+    res = find_optimal_nondim(kf_example._S, kf_example._V, kf_example._X, fixed_K=fixed_K, 
+        dimensionally_consistent_sets=dimensionally_consistent_sets,
+        k_numeric=k_num, x0_numeric=x_0_num, T_min=T_min, T_max=T_max, nondim_metric=nondim_metric, solver_opts=solver_opts, basis_type="Polynomial", n_jobs=None,
+        # export results to a pickle format.
+        export_results=True,
+        output_path=f"out/Kim_Forger_{nondim_metric}_nondim.pkl")
+    return res
+
+# Run the example.
+all_results = Kim_Forger_example()
+
+# Analyse the results and print the analysis (if verbose=True).
+all_transformed_results = analyse_results(all_results, verbose=True)

crnnondim-1.0.0/examples/parse_reactions_examples.py

@@ -0,0 +1,90 @@
+"""
+Examples showing how to use build_mass_action_system to convert
+a list of reactions to a mass-action CRN representation (S, V, X, etc).
+"""
+from crnnondim import reaction, reversible, build_mass_action_system
+
+def Michaelis_Menten_example():
+    """
+    Defines the reaction list for the reversible Michaelis-Menten scheme.
+
+    Returns
+    -------
+    rxns : list
+        List of reaction objects (forward + reverse) that can be passed to
+        build_mass_action_system.
+    """
+    rxns = []
+    # E + S <-> C with forward rate k1 and reverse rate km1
+    rxns += reversible("E + S <-> C", kf="k1",  kr="km1")
+    # C <-> P + E with forward rate k2 and reverse rate km2
+    rxns += reversible("C <-> P + E", kf="k2",  kr="km2")
+    return rxns
+
+def Kim_Forger_example():
+    """
+    Defines the reaction list for the Kim-Forger (KF) model, a simplified
+    circadian clock model.
+    """
+    rxns = [
+        # S -> X + S : basal production of X driven by S (rate constant k1)
+        reaction("S -> X + S", k="k1"),
+        # X -> 0 : degradation/removal of X (rate constant k2)
+        reaction("X -> 0", k="k2"),
+        # X -> X + Y : production of Y catalysed by X (rate constant k3)
+        reaction("X -> X + Y", k="k3"),
+        # Y -> 0 : degradation/removal of Y (rate constant k4)
+        reaction("Y -> 0",     k="k4"),
+        # Y -> Y + Z : production of Z catalysed by Y (rate constant k5)
+        reaction("Y -> Y + Z", k="k5"),
+        # Z -> 0 : degradation/removal of Z (rate constant k6)
+        reaction("Z -> 0",     k="k6"),
+        # C -> S : conversion/decay of complex C back to free S
+        reaction("C -> S",     k="ku")]
+    # Reversible binding/unbinding between S and Z to form complex C.
+    # Forward binding S + Z -> C has rate constant kf,
+    # reverse unbinding C -> S + Z has rate constant kb.
+    rxns+= reversible("S + Z <-> C", kf="kf", kr="kb")
+    return rxns
+
+def McKeithan_example(n=6):
+    """
+    Defines the reaction list for the McKeithan TCR proofreading chain with n
+    intermediate ligand-receptor complexes.
+
+    Parameters
+    ----------
+    n : int
+        Number of proofreading steps (C0 -> C1 -> ... -> Cn).
+    """
+    rxns = []
+    # Association/dissociation of the first complex C0.
+    rxns.extend(reversible("T + M <-> C0", kf="k1", kr="km1"))
+    # Forward proofreading step through the chain of complexes.
+    for i in range(n):
+        rxns.append(reaction(f"C{i} -> C{i+1}", k=f"k2"))  # forward proofreading step
+    # Each complex can dissociate back to T + M with the same rate km1.
+    for i in range(1,n+1):
+        rxns.append(reaction(f"C{i} -> T + M", k=f"km1"))
+    return rxns
+
+# Select which example to parse and convert into a mass-action CRN.
+example_name = "McKeithan"
+
+match example_name:
+    case "Michaelis-Menten":
+        reactions = Michaelis_Menten_example()
+    case "Kim-Forger":
+        reactions = Kim_Forger_example()
+    case _:
+        reactions = McKeithan_example()
+
+# Convert the reaction list into objects usable by CRNNondim and print a small summary of the parsed CRN.
+parsed_out = build_mass_action_system(reactions, verbose=True)
+
+species_names = parsed_out["species"]
+_S = parsed_out['_S']
+_X = parsed_out['_X']
+_V = parsed_out['_V']
+rate_constants = parsed_out['rate_constants']
+expanded_ODEs = parsed_out['expanded_ODEs']

crnnondim-1.0.0/examples/process_CRN_examples.py

@@ -0,0 +1,69 @@
+"""
+Examples showing how to use process_CRN to analyse CRNs, derive restrictions 
+on scaling factors so that the number of free parameters in the resulting non-dimensional 
+system is minimised, and construct an example non-dimensionalisation that attains this minimum.
+"""
+from crnnondim import process_CRN, analyse_results, Michaelis_MentenExample, Kim_ForgerExample, McKeithanExample
+import sympy as sp
+
+def Michaelis_Menten_example(find_example_nondim=False):
+    # Instantiate the Michaelis-Menten example.
+    mm_example = Michaelis_MentenExample()
+
+    # Characteristic concentration scales for S and E.
+    s0, e0 = sp.symbols('s_0 e_0', positive=True)
+
+    # Map species -> scale symbols. These scale symbols are held fixed when analysing the CRN.
+    fixed_K = {mm_example.S: s0, mm_example.E: e0}
+
+    # Analyse the CRN, optionally asking it to construct an explicit example 
+    # non-dimensionalisation that attains the minimum possible number of 
+    # free parameters (find_example_nondim=True).
+    res = process_CRN(mm_example._S, mm_example._V, mm_example._X, fixed_K=fixed_K, find_example_nondim=find_example_nondim, verbose=True, basis_type="Laurent")
+    return res
+
+def Kim_Forger_example(find_example_nondim=False):
+    # Instantiate the Kim-Forger example.
+    kf_example = Kim_ForgerExample()
+
+    # Characteristic concentration scales for X, Y, Z, S.
+    x0, y0, z0, s0 = sp.symbols('x_0 y_0 z_0 s_0', positive=True)
+
+    # Map species -> scale symbols. These scale symbols are held fixed when analysing the CRN.
+    fixed_K = {kf_example.X: x0, kf_example.Y: y0, kf_example.Z: z0, kf_example.S: s0}
+
+    # Analyse the CRN, optionally asking it to construct an explicit example 
+    # non-dimensionalisation that attains the minimum possible number of 
+    # free parameters (find_example_nondim=True).
+    res = process_CRN(kf_example._S, kf_example._V, kf_example._X, fixed_K=fixed_K, find_example_nondim=find_example_nondim, verbose=True, basis_type="Laurent")
+    return res
+
+def McKeithan_example(find_example_nondim=False):
+    # Instantiate the McKeithan TCR proofreading example.
+    m_example = McKeithanExample()
+
+    # Characteristic concentration scales for T and M.
+    T_0, M_0 = sp.symbols('T_0 M_0', positive=True)
+
+    # Map species -> scale symbols. These scale symbols are held fixed when analysing the CRN.
+    fixed_K = {m_example.T: T_0, m_example.M: M_0}
+
+    # Analyse the CRN, optionally asking it to construct an explicit example 
+    # non-dimensionalisation that attains the minimum possible number of 
+    # free parameters (find_example_nondim=True).
+    res = process_CRN(m_example._S, m_example._V, m_example._X, fixed_K=fixed_K, find_example_nondim=find_example_nondim, verbose=True, basis_type="Laurent")
+    return res
+
+# Choose which example to run.
+example_name = "McKeithan"
+find_example_nondim = True
+match example_name:
+    case "Michaelis-Menten":
+        all_results = Michaelis_Menten_example(find_example_nondim=find_example_nondim)
+    case "Kim-Forger":
+        all_results = Kim_Forger_example(find_example_nondim=find_example_nondim)
+    case _:
+        all_results = McKeithan_example(find_example_nondim=find_example_nondim)
+
+# Analyse the results and print the analysis (if verbose=True).
+all_transformed_results = analyse_results(all_results, verbose=True)

crnnondim-1.0.0/examples/process_CRN_given_nondimensionalisation_examples.py

@@ -0,0 +1,81 @@
+"""
+Examples showing how to use process_CRN_given_nondimensionalisation to 
+non-dimensionalise a CRN given a specific non-dimensionalisation.
+"""
+from crnnondim import process_CRN_given_nondimensionalisation, analyse_results, Michaelis_MentenExample, Kim_ForgerExample, McKeithanExample
+import sympy as sp
+
+def Michaelis_Menten_example(return_all_families=False):
+    # Instantiate the Michaelis-Menten example.
+    mm_example = Michaelis_MentenExample()
+
+    # Characteristic concentration scales for S and E.
+    s_0, e_0 = sp.symbols('s_0 e_0', positive=True)
+
+    #Give an explicit choice of non-dimensionalisation.
+    nondim = {mm_example.S: s_0, mm_example.E: e_0, mm_example.C: e_0, mm_example.P: e_0}
+
+    # Non-dimensionalise the CRN given this particular non-dimensionalisation. 
+    # Time scaling, via K_T, can be provided if desired.
+    res = process_CRN_given_nondimensionalisation(
+        mm_example._S,
+        mm_example._V,
+        mm_example._X,
+        nondim=nondim,
+        basis_type="Laurent",
+        return_all_families=return_all_families
+    )
+    return res
+
+def Kim_Forger_example(return_all_families=False):
+    # Instantiate the Kim-Forger example.
+    kf_example = Kim_ForgerExample()
+
+    # Characteristic concentration scales for X, Y, Z, S.
+    x_0, y_0, z_0, s_0 = sp.symbols('x_0 y_0 z_0 s_0', positive=True)
+
+    #Give an explicit choice of non-dimensionalisation.
+    nondim1 = {kf_example.X: x_0, kf_example.Y: y_0, kf_example.Z: z_0, kf_example.S: s_0, kf_example.C:z_0}
+
+    # Non-dimensionalise the CRN given this particular non-dimensionalisation. 
+    # Time scaling, via K_T, can be provided if desired.
+    res1 = process_CRN_given_nondimensionalisation(kf_example._S, kf_example._V, kf_example._X, nondim=nondim1, basis_type="Laurent", return_all_families=return_all_families)
+
+    # Second choice of non-dimensionalisation.
+    nondim2 = {kf_example.X: x_0, kf_example.Y: y_0, kf_example.Z: z_0, kf_example.S: s_0, kf_example.C:x_0}   # species-keyed
+    res2 = process_CRN_given_nondimensionalisation(kf_example._S, kf_example._V, kf_example._X, nondim=nondim2, basis_type="Laurent", return_all_families=return_all_families)
+
+    return [res1, res2]
+
+def McKeithan_example(return_all_families=False):
+    # Instantiate the McKeithan TCR proofreading example.
+    m_example = McKeithanExample()
+
+    # Characteristic concentration scales for T and M.
+    T_0, M_0 = sp.symbols('T_0 M_0', positive=True)
+
+    # consider a dimensionalisation where the scaling factors for C0, C1, C2, C3, C4, C5, C6 are T_0.
+    nondim = {m_example.T: T_0, m_example.M: M_0}
+    for sym in [m_example.C0, m_example.C1, m_example.C2, m_example.C3, m_example.C4, m_example.C5, m_example.C6]:
+        # All complexes share the same concentration scale T_0.
+        nondim[sym] = T_0
+
+    # Non-dimensionalise the CRN given this particular non-dimensionalisation. 
+    # Time scaling, via K_T, can be provided if desired.
+    res = process_CRN_given_nondimensionalisation(m_example._S, m_example._V, m_example._X, nondim=nondim, basis_type="Laurent", return_all_families=return_all_families)
+    return res
+
+# Choose which example to run and whether to return all families. If return_all_families is true,
+# all families where K_T is chosen to minimise the number of free parameters will be printed.
+example_name = "Michaelis-Menten"
+return_all_families = True
+match example_name:
+    case "Michaelis-Menten":
+        all_results = Michaelis_Menten_example(return_all_families=return_all_families)
+    case "Kim-Forger":
+        all_results = Kim_Forger_example(return_all_families=return_all_families)
+    case _:
+        all_results = McKeithan_example(return_all_families=return_all_families)
+
+# Analyse the results and print the analysis (if verbose=True).
+all_transformed_results = analyse_results(all_results, verbose=True)