Repository: SciML/Catalyst.jl
Pull request #1197: [WIP] Minor docfixes
Author: login: TorkelE
Created: 2025-03-19T17:46:25Z | Merged: 2025-03-20T20:48:03Z

Fixes some minor doc problems I have noted. Still need to figure out how to make this bit
 ```
 @JuliaRegistrator register branch=release-15.0.0
 ```
appear well here (https://docs.sciml.ai/Catalyst/dev/devdocs/dev_guide/#Release-Process). Works in my markdown previewer, but the website will not have it.


Diff:
diff --git a/README.md b/README.md
index 24ea40db0f..7f95a72858 100644
--- a/README.md
+++ b/README.md
@@ -137,9 +137,9 @@ model. Here we instead show how various Catalyst features can compose to create
 a much more advanced model. Our model describes how the volume of a cell ($V$)
 is affected by a growth factor ($G$). The growth factor only promotes growth
 while in its phosphorylated form ($G^P$). The phosphorylation of $G$ ($G \to G^P$)
-is promoted by sunlight (modeled as the cyclic sinusoid $k_a (\sin(t) + 1)$),
-which phosphorylates the growth factor (producing $G^P$). When the cell reaches a
-critical volume ($V_m$) it undergoes cell division. First, we declare our model:
+is promoted by sunlight, which is modeled as the cyclic sinusoid $k_a (\sin(t) + 1)$. 
+When the cell reaches a critical volume ($V_m$) it undergoes cell division. First, we 
+declare our model:
 ```julia
 using Catalyst
 cell_model = @reaction_network begin
diff --git a/docs/src/devdocs/dev_guide.md b/docs/src/devdocs/dev_guide.md
index 13034518fc..7607ef504e 100644
--- a/docs/src/devdocs/dev_guide.md
+++ b/docs/src/devdocs/dev_guide.md
@@ -1,28 +1,23 @@
 # Catalyst Developer Documentation
 
-## Release Process
+## [Release Process](@id devdocs_releaseprocess)
 Beginning with v15, Catalyst is using a new release process to try to ensure
 continuing stability of releases. Before making a release one should
 
-1. Create a new release branch, i.e. "release-15.0.0"
+1. Create a new release branch, i.e. "release-15.0.0".
 2. On this branch, cap major dependencies to their latest version that works and
    for which tests pass.
    - Caps need to be included in both Project.toml and docs/Project.toml.
    - Do not cap the master branch as this can prevent upstream libraries from
      properly testing against Catalyst, and hide breaking changes that impact
      Catalyst.
-3. Check docs build with the capped dependencies. Visually verify via checking
-   the artifact in the doc build that the docs actually look ok (since sometimes
-   issues can arise that do not lead to actual errors in the doc CI).
-4. Release via the [registration
+3. [Check docs build](@ref devdocs_advice_doc_inspection) with the capped dependencies. 
+   Visually verify via checking the artifact in the doc build that the docs actually
+   look ok (since sometimes issues can arise that do not lead to actual errors in the doc CI).
+5. Release via the [registration
    issue](https://github.com/SciML/Catalyst.jl/issues/127) with the
-   command:
-   
-    ```
-    @JuliaRegistrator register branch=release-15.0.0
-    ```
-    
-    modifying as appropriate for the version you are releasing.
+   command: `@JuliaRegistrator register branch=release-15.0.0`, modifying as appropriate
+   for the version you are releasing.
 
 If there is subsequently a need to increment the version of a dependency, this
 should be done via a new release that follows the above process, and modifies
@@ -34,15 +29,17 @@ should be preferred. If the new release branch is branched from master, *it
 needs to ensure Project.toml caps are all ≥ to those listed in the previous
 Catalyst release branch*.
 
-## Development advice
+## [Development advice](@id devdocs_advice)
 
-### Checking doc builds for errors
+### [Checking doc builds for errors](@id devdocs_advice_doc_error_checks)
 When updating documentation, Catalyst will run any Julia code provided within example blocks to dynamically create figures and outputs. In addition to automatically creating these for us, it also provides an automatic check that all code in documentation is correct. Here, if any of the documentation code throws an error, the build job will fail. The documentation build job can be found at the bottom of a PRs conversation, here is an example of a failed one:
+
 ![Failed builddocs link](../assets/devdocs/failed_builddocs_link.png)
+
 To check what errors were produced, click on the "Details" link of the job. Next, any errors can be found at the bottom of the "Build and deploy" section (which should be opened automatically).
 
-### Inspecting documentation of a PR or branch
-When updating documentation it is typically useful to view the updated documentation in HTML format (which is the format users will see). Here, some errors are much easier to spot in html format as compared with the raw text files from which these are generated. There are two primary ways to view updated documentation, either by downloading them from the PR or by building the docs locally.
+### [Inspecting the built documentation of a PR or branch](@id devdocs_advice_doc_inspection)
+When updating documentation it is typically useful to view the updated documentation in HTML format (which is the format users will see). Here, some errors are much easier to spot in .html format as compared with the raw text files from which these are generated. There are two primary ways to view updated documentation, either by downloading them from the PR or by building the docs locally.
 
 Whenever a PR to Catalyst is created, CI will create a corresponding documenter build job. If the build job passes, you can access the built documentation (which will be the new Catalyst documentation if the PR is merged) through the following steps:
 1. Click on "Details" in the documentation build job (at the bottom of the PR conversation tab). 
@@ -54,5 +51,5 @@ To build the Catalyst documentation locally:
 1. Navigate to the ".julia/dev/Catalyst/docs/" folder and run the "make.jl" file using ">julia make.jl". Alternatively, open a Julia session, activate the "docs" environment, and run the file using `include("make.jl").
 2. Open the ".julia/dev/Catalyst/docs/build/index.html" file.
 
-### Spellchecking in your code
+### [Spellchecking in your code](@id devdocs_advice_codespellchecker)
 Especially when writing documentation, but also when writing normal code, it can be useful to have a spellchecker running through your texts. While code can be copied into a spellchecker and checked there (which is still useful to check grammar), it can also be very useful to (for users of VSCode) run the [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker) extension. This will automatically provide simple spell-checking for code and documentation as you write it.
diff --git a/docs/src/index.md b/docs/src/index.md
index c30cd42ca3..078838d709 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -164,9 +164,9 @@ model. Here we instead show how various Catalyst features can compose to create
 a much more advanced model. Our model describes how the volume of a cell ($V$)
 is affected by a growth factor ($G$). The growth factor only promotes growth
 while in its phosphorylated form ($G^P$). The phosphorylation of $G$ ($G \to G^P$)
-is promoted by sunlight (modeled as the cyclic sinusoid $k_a (\sin(t) + 1)$),
-which phosphorylates the growth factor (producing $G^P$). When the cell reaches a
-critical volume ($V_m$) it undergoes cell division. First, we declare our model:
+is promoted by sunlight, which is modeled as the cyclic sinusoid $k_a (\sin(t) + 1)$.
+When the cell reaches a critical volume ($V_m$) it undergoes cell division. First, we 
+declare our model:
 ```@example home_elaborate_example
 using Catalyst
 cell_model = @reaction_network begin
diff --git a/docs/src/inverse_problems/behaviour_optimisation.md b/docs/src/inverse_problems/behaviour_optimisation.md
index 75ac07f5c3..ce6912019b 100644
--- a/docs/src/inverse_problems/behaviour_optimisation.md
+++ b/docs/src/inverse_problems/behaviour_optimisation.md
@@ -1,4 +1,4 @@
-# [Optimization for non-data fitting purposes](@id behaviour_optimisation)
+# [Optimization for Non-data Fitting Purposes](@id behaviour_optimisation)
 In previous tutorials we have described how to use [PEtab.jl](@ref petab_parameter_fitting) and [Optimization.jl](@ref optimization_parameter_fitting) for parameter fitting. This involves solving an optimisation problem (to find the parameter set yielding the best model-to-data fit). There are, however, other situations that require solving optimisation problems. Typically, these involve the creation of a custom objective function, which minimizer can then be found using Optimization.jl. In this tutorial we will describe this process, demonstrating how parameter space can be searched to find values that achieve a desired system behaviour. Many options used here are described in more detail in [the tutorial on using Optimization.jl for parameter fitting](@ref optimization_parameter_fitting). A more throughout description of how to solve these problems is provided by [Optimization.jl's documentation](https://docs.sciml.ai/Optimization/stable/) and the literature[^1].
 
 ## [Maximising the pulse amplitude of an incoherent feed forward loop](@id behaviour_optimisation_IFFL_example)
diff --git a/docs/src/model_creation/chemistry_related_functionality.md b/docs/src/model_creation/chemistry_related_functionality.md
index 5064208a9b..b80d8bae0f 100644
--- a/docs/src/model_creation/chemistry_related_functionality.md
+++ b/docs/src/model_creation/chemistry_related_functionality.md
@@ -1,4 +1,4 @@
-# [Chemistry-related functionality](@id chemistry_functionality)
+# [Chemistry-related Functionality](@id chemistry_functionality)
 
 While Catalyst has primarily been designed around the modelling of biological systems, reaction network models are also common in chemistry. This section describes two types of functionality, that while of general interest, should be especially useful in the modelling of chemical systems.
 - The `@compound` option, which enables the user to designate that a specific species is composed of certain subspecies.
diff --git a/docs/src/model_creation/conservation_laws.md b/docs/src/model_creation/conservation_laws.md
index c3cffa1840..0fe504d372 100644
--- a/docs/src/model_creation/conservation_laws.md
+++ b/docs/src/model_creation/conservation_laws.md
@@ -1,4 +1,4 @@
-# [Working with conservation laws](@id conservation_laws)
+# [Working with Conservation Laws](@id conservation_laws)
 Catalyst can detect, and eliminate for differential-equation based models, *conserved quantities*, i.e. linear combinations of species which are conserved via the chemistry. This functionality is both automatically utilised by Catalyst (e.g. to [remove singular Jacobians during steady state computations](@ref homotopy_continuation_conservation_laws)), but is also available for users to utilise directly (e.g. to potentially [improve simulation performance](@ref ode_simulation_performance_conservation_laws)).
 
 To illustrate conserved quantities, let us consider the following [two-state](@ref basic_CRN_library_two_states) model:
diff --git a/docs/src/model_creation/dsl_basics.md b/docs/src/model_creation/dsl_basics.md
index b1b5e6d889..64925c663b 100644
--- a/docs/src/model_creation/dsl_basics.md
+++ b/docs/src/model_creation/dsl_basics.md
@@ -39,7 +39,7 @@ Finally, `rn = ` is used to store the model in the variable `rn` (a normal Julia
 ## [Defining parameters and species in the DSL](@id dsl_description_parameters_basics)
 Typically, the rates are not constants, but rather parameters (which values can be set e.g. at [the beginning of each simulation](@ref simulation_intro_ODEs)). To set parametric rates, simply use whichever symbol you wish to represent your parameter with. E.g. to set the above rates to `a` and `b`, we use:
 ```@example dsl_basics
-rn1 = @reaction_network begin
+rn = @reaction_network begin
     a, X --> Y
     b, Y --> X
 end
@@ -47,7 +47,7 @@ end
 
 Here we have used single-character symbols to designate all species and parameters. Multi-character symbols, however, are also permitted. E.g. we could call the rates `kX` and `kY`:
 ```@example dsl_basics
-rn1 = @reaction_network begin
+rn = @reaction_network begin
     kX, X --> Y
     kY, Y --> X
 end
@@ -59,14 +59,14 @@ Generally, anything that is a [permitted Julia variable name](https://docs.julia
 ### [Reactions with multiple substrates or products](@id dsl_description_reactions_multiples)
 Previously, our reactions have had a single substrate and a single product. However, reactions with multiple substrates and/or products are possible. Here, all the substrates (or products) are listed and separated by a `+`. E.g. to create a model where `X` and `Y` bind (at rate `kB`) to form `XY` (which then can dissociate, at rate `kD`, to form `XY`) we use:
 ```@example dsl_basics
-rn2 = @reaction_network begin
+rn = @reaction_network begin
     kB, X + Y --> XY
     kD, XY --> X + Y
 end
 ```
 Reactions can have any number of substrates and products, and their names do not need to have any relationship to each other, as demonstrated by the following mock model:
 ```@example dsl_basics
-rn3 = @reaction_network begin
+rn = @reaction_network begin
     k, X + Y + Z --> A + B + C + D
 end
 ```
@@ -74,7 +74,7 @@ end
 ### [Reactions with degradation or production](@id dsl_description_reactions_degradation_and_production)
 Some reactions have no products, in which case the substrate(s) are degraded (i.e. removed from the system). To denote this, set the reaction's right-hand side to `0`. Similarly, some reactions have no substrates, in which case the product(s) are produced (i.e. added to the system). This is denoted by setting the left-hand side to `0`. E.g. to create a model where a single species `X` is both created (in the first reaction) and degraded (in a second reaction), we use:
 ```@example dsl_basics
-rn4 = @reaction_network begin
+rn = @reaction_network begin
     p, 0 --> X
     d, X --> 0
 end
@@ -83,7 +83,7 @@ end
 ### [Reactions with non-unitary stoichiometries](@id dsl_description_reactions_stoichiometries)
 Reactions may include multiple copies of the same reactant (i.e. a substrate or a product). To specify this, the reactant is preceded by a number indicating its number of copies (also called the reactant's *stoichiometry*). E.g. to create a model where two copies of `X` dimerise to form `X2` (which then dissociate back to two `X` copies) we use:
 ```@example dsl_basics
-rn5 = @reaction_network begin
+rn = @reaction_network begin
     kB, 2X --> X2
     kD, X2 --> 2X
 end
@@ -92,7 +92,7 @@ Reactants whose stoichiometries are not defined are assumed to have stoichiometr
 
 Stoichiometries can be combined with `()` to define them for multiple reactants. Here, the following (mock) model declares the same reaction twice, both with and without this notation:
 ```@example dsl_basics
-rn6 = @reaction_network begin
+rn = @reaction_network begin
     k, 2X + 3(Y + 2Z) --> 5(V + W)
     k, 2X + 3Y + 6Z --> 5V + 5W
 end
@@ -103,14 +103,14 @@ end
 ### [Bi-directional (or reversible) reactions](@id dsl_description_reaction_bundling_reversible)
 As is the case for the following two-state model:
 ```@example dsl_basics
-rn7 = @reaction_network begin
+rn_bidir = @reaction_network begin
     k1, X1 --> X2
     k2, X2 --> X1
 end
 ```
 it is common that reactions occur in both directions (so-called *bi-directional* reactions). Here, it is possible to bundle the reactions into a single line by using the `<-->` arrow. When we do this, the rate term must include two separate rates (one for each direction, these are enclosed by a `()` and separated by a `,`). I.e. the two-state model can be declared using:
 ```@example dsl_basics
-rn7 = @reaction_network begin
+rn_bidir = @reaction_network begin
     (k1,k2), X1 <--> X2
 end
 ```
@@ -118,13 +118,13 @@ Here, the first rate (`k1`) denotes the *forward rate* and the second rate (`k2`
 
 Catalyst also permits writing pure backwards reactions. These use identical syntax to forward reactions, but with the `<--` arrow:
 ```@example dsl_basics
-rn8 = @reaction_network begin
+rn_ytox = @reaction_network begin
     k, X <-- Y
 end
 ```
 Here, the substrate(s) are on the right-hand side and the product(s) are on the left-hand side. Hence, the above model can be written identically using:
 ```@example dsl_basics
-rn8 = @reaction_network begin
+rn_ytox = @reaction_network begin
     k, Y --> X
 end
 ```
@@ -133,41 +133,41 @@ Generally, using forward reactions is clearer than backwards ones, with the latt
 ### [Bundling similar reactions on a single line](@id dsl_description_reaction_bundling_similar)
 There exist additional situations where models contain similar reactions (e.g. systems where all system components degrade at identical rates). Reactions which share either rates, substrates, or products can be bundled into a single line. Here, the parts which are different for the reactions are written using `(,)` (containing one separate expression for each reaction). E.g., let us consider the following model where species `X` and `Y` both degrade at the rate `d`:
 ```@example dsl_basics
-rn8 = @reaction_network begin
+rn_deg = @reaction_network begin
     d, X --> 0
     d, Y --> 0
 end
 ```
 These share both their rates (`d`) and products (`0`), however, the substrates are different (`X` and `Y`). Hence, the reactions can be bundled into a single line using the common rate and product expression while providing separate substrate expressions:
 ```@example dsl_basics
-rn8 = @reaction_network begin
+rn_deg = @reaction_network begin
     d, (X,Y) --> 0
 end
 ```
 This declaration of the model is identical to the previous one. Reactions can share any subset of the rate, substrate, and product expression (the cases where they share all or none, however, do not make sense to use). I.e. if the two reactions also have different degradation rates:
 ```@example dsl_basics
-rn9 = @reaction_network begin
+rn_deg2 = @reaction_network begin
     dX, X --> 0
     dY, Y --> 0
 end
 ```
 This can be represented using:
 ```@example dsl_basics
-rn9 = @reaction_network begin
+rn_deg2 = @reaction_network begin
     (dX,dY), (X,Y) --> 0
 end
 ```
 
 It is possible to use bundling for any number of reactions. E.g. in the following model we bundle the conversion of a species $X$ between its various forms (where all reactions use the same rate $k$):
 ```@example dsl_basics
-rn10 = @reaction_network begin
+rn = @reaction_network begin
     k, (X0,X1,X2,X3) --> (X1,X2,X3,X4)
 end
 ```
 
 It is possible to combine bundling with bi-directional reactions. In this case, the rate is first split into the forward and backwards rates. These may then (or may not) indicate several rates. We exemplify this using the two following two (identical) networks, created with and without bundling.
 ```@example dsl_basics
-rn11 = @reaction_network begin
+rn_sp = @reaction_network begin
     kf, S --> P1
     kf, S --> P2
     kb_1, P1 --> S
@@ -175,14 +175,14 @@ rn11 = @reaction_network begin
 end
 ```
 ```@example dsl_basics
-rn11 = @reaction_network begin
+rn_sp = @reaction_network begin
     (kf, (kb_1, kb_2)), S <--> (P1,P2)
 end
 ```
 
 Like when we designated stoichiometries, reaction bundling can be applied very generally to create some truly complicated reactions:
 ```@example dsl_basics
-rn12 = @reaction_network begin
+rn = @reaction_network begin
     ((pX, pY, pZ),d), (0, Y0, Z0) <--> (X, Y, Z1+Z2)
 end
 ```
@@ -193,7 +193,7 @@ So far we have assumed that all reaction rates are constant (being either a numb
 
 Let us consider a model with an activator (`A`, which degraded at a constant rate) and a protein (`P`). The production rate of `P` depends both on `A` and a parameter (`kP`). We model this through:
 ```@example dsl_basics
-rn_13 = @reaction_network begin
+rn_ap = @reaction_network begin
     d, A --> 0
     kP*A, 0 --> P
 end
@@ -201,30 +201,30 @@ end
 Here, `P`'s production rate will be reduced as `A` decays. We can [print the ODE this model produces with `Latexify`](@ref visualisation_latex):
 ```@example dsl_basics
 using Latexify
-latexify(rn_13; form = :ode)
+latexify(rn_ap; form = :ode)
 ```
 
 In this case, we can generate an equivalent model by instead adding `A` as both a substrate and a product to `P`'s production reaction:
 ```@example dsl_basics
-rn_13_alt = @reaction_network begin
+rn_ap_alt = @reaction_network begin
     d, A --> 0
     kp, A --> A + P
 end
 ```
 We can confirm that this generates the same ODE:
 ```@example dsl_basics
-latexify(rn_13_alt; form = :ode)
+latexify(rn_ap_alt; form = :ode)
 ```
 Here, while these models will generate identical ODE, SDE, and jump simulations, the chemical reaction network models themselves are not equivalent. Generally, as pointed out in the two notes below, using the second form is preferable.
 !!! warning
-    While `rn_13` and `rn_13_alt` will generate equivalent simulations, for jump simulations, the first model will have reduced performance as it generates a less performant representation of the system in JumpProcesses. It is generally recommended to write pure mass action reactions such that there is just a single constant within the rate constant expression for optimal performance of jump process simulations.
+    While `rn_ap` and `rn_ap_alt` will generate equivalent simulations, for jump simulations, the first model will have reduced performance as it generates a less performant representation of the system in JumpProcesses. It is generally recommended to write pure mass action reactions such that there is just a single constant within the rate constant expression for optimal performance of jump process simulations.
 
 !!! danger
     Catalyst automatically infers whether quantities appearing in the DSL are species or parameters (as described [here](@ref dsl_advanced_options_declaring_species_and_parameters)). Generally, anything that does not appear as a reactant is inferred to be a parameter. This means that if you want to model a reaction activated by a species (e.g. `kp*A, 0 --> P`), but that species does not occur as a reactant, it will be interpreted as a parameter. This can be handled by [manually declaring the system species](@ref dsl_advanced_options_declaring_species_and_parameters).
 
 Above we used a simple example where the rate was the product of a species and a parameter. However, any valid Julia expression of parameters, species, and values can be used. E.g the following is a valid model:
 ```@example dsl_basics
-rn_14 = @reaction_network begin
+rn = @reaction_network begin
     2.0 + X^2, 0 --> X + Y
     k1 + k2^k3, X --> ∅
     pi * X/(sqrt(2) + Y), Y → ∅
@@ -234,7 +234,7 @@ end
 ### [Using functions in rates](@id dsl_description_nonconstant_rates_functions)
 It is possible for the rate to contain Julia functions. These can either be functions from Julia's standard library:
 ```@example dsl_basics
-rn_16 = @reaction_network begin
+rn = @reaction_network begin
     d, A --> 0
     kp*sqrt(A), 0 --> P
 end
@@ -242,7 +242,7 @@ end
 or ones defined by the user:
 ```@example dsl_basics
 custom_function(p1, p2, X) = (p1 + X) / (p2 + X)
-rn_17 = @reaction_network begin
+rn = @reaction_network begin
     d, A --> 0
     custom_function(k1,k2,E), 0 --> P
 end
@@ -251,7 +251,7 @@ end
 ### [Pre-defined functions](@id dsl_description_nonconstant_rates_available_functions)
 Two functions frequently used within systems biology are the [*Michaelis-Menten*](https://en.wikipedia.org/wiki/Michaelis%E2%80%93Menten_kinetics) and [*Hill*](https://en.wikipedia.org/wiki/Hill_equation_(biochemistry)) functions. These are pre-defined in Catalyst and can be called using `mm(X,v,K)` and `hill(X,v,K,n)`. E.g. a self-activation loop where `X` activates its own production through a Hill function can be created using:
 ```@example dsl_basics
-rn_18 = @reaction_network begin
+rn = @reaction_network begin
     hill(X,v,K,n), 0 --> P
     d, X --> 0
 end
@@ -267,7 +267,7 @@ Catalyst comes with the following predefined functions:
 ### [Time-dependant rates](@id dsl_description_nonconstant_rates_time)
 Previously we have assumed that the rates are independent of the time variable, $t$. However, time-dependent reactions are also possible. Here, simply use `t` to represent the time variable. E.g., to create a production/degradation model where the production rate decays as time progresses, we can use:
 ```@example dsl_basics
-rn_14 = @reaction_network begin
+rn = @reaction_network begin
     kp/(1 + t), 0 --> P
     d, P --> 0
 end
@@ -275,7 +275,7 @@ end
 
 Like previously, `t` can be part of any valid expression. E.g. to create a reaction with a cyclic rate (e.g. to represent a [circadian system](https://en.wikipedia.org/wiki/Circadian_rhythm)) we can use:
 ```@example dsl_basics
-rn_15 = @reaction_network begin
+rn = @reaction_network begin
     A*(sin(2π*f*t - ϕ)+1)/2, 0 --> P
     d, P --> 0
 end
@@ -293,7 +293,7 @@ end
 ### [Non-integer stoichiometries](@id dsl_description_stoichiometries_decimal)
 Previously all stoichiometric constants have been integer numbers, however, decimal numbers are also permitted. Here we create a birth-death model where each production reaction produces 1.5 units of `X`:
 ```@example dsl_basics
-rn_16 = @reaction_network begin
+rn = @reaction_network begin
     p, 0 --> 1.5X
     d, X --> 0
 end
@@ -303,7 +303,7 @@ It is also possible to have non-integer stoichiometric coefficients for substrat
 ### [Parametric stoichiometries](@id dsl_description_stoichiometries_parameters)
 It is possible for stoichiometric coefficients to be parameters. E.g. here we create a generic polymerisation system where `n` copies of `X` bind to form `Xn`:
 ```@example dsl_basics
-rn_17 = @reaction_network begin
+rn = @reaction_network begin
     (kB,kD), n*X <--> Xn
 end
 ```
@@ -311,7 +311,7 @@ Now we can designate the value of `n` through a parameter when we e.g. create an
 ```@example dsl_basics
 u0 = [:X => 5.0, :Xn => 1.0]
 ps = [:kB => 1.0, :kD => 0.1, :n => 4]
-oprob = ODEProblem(rn_17, u0, (0.0, 1.0), ps)
+oprob = ODEProblem(rn, u0, (0.0, 1.0), ps)
 nothing # hide
 ```
 
@@ -321,7 +321,7 @@ Julia permits any Unicode characters to be used in variable names, thus Catalyst
 ### [Using ∅ in degradation/production reactions](@id dsl_description_symbols_empty_set)
 Previously, we described how `0` could be used to [create degradation or production reactions](@ref dsl_description_reactions_degradation_and_production). Catalyst permits the user to instead use the `∅` symbol. E.g. the production/degradation system can alternatively be written as:
 ```@example dsl_basics
-rn4 = @reaction_network begin
+rn_pd = @reaction_network begin
     p, ∅ --> X
     d, X --> ∅
 end
@@ -335,7 +335,7 @@ Catalyst uses `-->`, `<-->`, and `<--` to denote forward, bi-directional, and ba
 
 E.g. the production/degradation system can alternatively be written as:
 ```@example dsl_basics
-rn4 = @reaction_network begin
+rn_pd = @reaction_network begin
     p, ∅ → X
     d, X → ∅
 end
@@ -361,7 +361,7 @@ nothing # hide
 
 This functionality can also be used to create less serious models:
 ```@example dsl_basics
-rn_13 = @reaction_network begin
+rn = @reaction_network begin
     🍦, 😢 --> 😃
 end
 ```
diff --git a/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md b/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md
index 5826071c50..1007131ec2 100644
--- a/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md
+++ b/docs/src/model_creation/examples/programmatic_generative_linear_pathway.md
@@ -1,4 +1,4 @@
-# [Programmatic, generative, modelling of a linear pathway](@id programmatic_generative_linear_pathway)
+# [Programmatic, Generative, Modelling of a Linear Pathway](@id programmatic_generative_linear_pathway)
 This example will show how to use programmatic, generative, modelling to model a system implicitly. I.e. rather than listing all system reactions explicitly, the reactions are implicitly generated from a simple set of rules. This example is specifically designed to show how [programmatic modelling](@ref programmatic_CRN_construction) enables *generative workflows* (demonstrating one of its advantages as compared to [DSL-based modelling](@ref dsl_description)). In our example, we will model linear pathways, so we will first introduce these. Next, we will model them first using the DSL, and then using a generative programmatic workflow.
 
 ## [Linear pathways](@id programmatic_generative_linear_pathway_intro)
diff --git a/docs/src/model_creation/parametric_stoichiometry.md b/docs/src/model_creation/parametric_stoichiometry.md
index 65e6cde31b..989cd40f5e 100644
--- a/docs/src/model_creation/parametric_stoichiometry.md
+++ b/docs/src/model_creation/parametric_stoichiometry.md
@@ -1,4 +1,4 @@
-# [Symbolic Stochiometries](@id parametric_stoichiometry)
+# [Symbolic Stoichiometries](@id parametric_stoichiometry)
 Catalyst supports stoichiometric coefficients that involve parameters, species,
 or even general expressions. In this tutorial we show several examples of how to
 use symbolic stoichiometries, and discuss several caveats to be aware of.
diff --git a/docs/src/model_creation/reactionsystem_content_accessing.md b/docs/src/model_creation/reactionsystem_content_accessing.md
index b54666015d..bd92e436b6 100644
--- a/docs/src/model_creation/reactionsystem_content_accessing.md
+++ b/docs/src/model_creation/reactionsystem_content_accessing.md
@@ -1,4 +1,4 @@
-# [Accessing model properties](@id model_accessing)
+# [Accessing Model Properties](@id model_accessing)
 Catalyst is based around the creation, analysis, and simulation of chemical reaction network models. Catalyst stores these models in [`ReactionSystem`](@ref) structures. This page describes some basic functions for accessing the content of these structures. This includes retrieving lists of species, parameters, or reactions that a model consists of. An extensive list of relevant functions for working with `ReactionSystem` models can be found in Catalyst's [API](@ref api).
 
 !!! warning
diff --git a/docs/src/model_simulation/ensemble_simulations.md b/docs/src/model_simulation/ensemble_simulations.md
index d897a0b5d5..98ba10470f 100644
--- a/docs/src/model_simulation/ensemble_simulations.md
+++ b/docs/src/model_simulation/ensemble_simulations.md
@@ -39,7 +39,7 @@ Here, each simulation is displayed as an individual trajectory.
 !!! note
     While not used here, the [`la` plotting option](@ref simulation_plotting_options) (which modifies line transparency) can help improve the plot visual when a large number of (overlapping) lines are plotted.
 
-Various convenience functions are available for analysing and plotting ensemble simulations (a full list can be found [here]). Here, we use these to first create an `EnsembleSummary` (retrieving each simulation's value at time points `0.0, 1.0, 2.0, ... 1000.0`). Next, we use this as an input to the `plot` command, which automatically plots the mean $X$ activity across the ensemble, while also displaying the 5% and 95% quantiles as the shaded area:
+Various convenience functions are available for analysing and plotting ensemble simulations (a full list can be found [here](https://docs.sciml.ai/DiffEqDocs/dev/features/ensemble/#Analyzing-an-Ensemble-Experiment)). Here, we use these to first create an `EnsembleSummary` (retrieving each simulation's value at time points `0.0, 1.0, 2.0, ... 1000.0`). Next, we use this as an input to the `plot` command, which automatically plots the mean $X$ activity across the ensemble, while also displaying the 5% and 95% quantiles as the shaded area:
 ```@example ensemble
 e_sumary = EnsembleAnalysis.EnsembleSummary(sols, 0.0:1.0:1000.0)
 plot(e_sumary)
diff --git a/docs/src/model_simulation/examples/periodic_events_simulation.md b/docs/src/model_simulation/examples/periodic_events_simulation.md
index 37cd3bddbb..bdfafcbd31 100644
--- a/docs/src/model_simulation/examples/periodic_events_simulation.md
+++ b/docs/src/model_simulation/examples/periodic_events_simulation.md
@@ -1,4 +1,4 @@
-# [Modelling a periodic event during ODE and jump simulations](@id periodic_event_simulation_example)
+# [Modelling a Periodic Event During ODE and Jump Simulations](@id periodic_event_simulation_example)
 This tutorial will describe how to simulate systems with periodic events in ODEs and jump simulations (SDEs use identical syntax). We will consider a model with a [circadian rhythm](https://en.wikipedia.org/wiki/Circadian_rhythm), where a parameter represents the level of light. While outdoor light varies smoothly, in experimental settings a lamp is often simply turned on/off every 12 hours. Here we will model this toggling of the light using a periodic event that is triggered every 12 hours.
 
 ## [Modelling a circadian periodic event in an ODE simulation](@id periodic_event_simulation_example_ode)
diff --git a/docs/src/model_simulation/ode_simulation_performance.md b/docs/src/model_simulation/ode_simulation_performance.md
index 9e546a5732..b0f1a87ded 100644
--- a/docs/src/model_simulation/ode_simulation_performance.md
+++ b/docs/src/model_simulation/ode_simulation_performance.md
@@ -1,4 +1,4 @@
-# [Advice for performant ODE simulations](@id ode_simulation_performance)
+# [Advice for Performant ODE Simulations](@id ode_simulation_performance)
 We have previously described how to perform ODE simulations of *chemical reaction network* (CRN) models. These simulations are typically fast and require little additional consideration. However, when a model is simulated many times (e.g. as a part of solving an inverse problem), or is very large, simulation run
 times may become noticeable. Here we will give some advice on how to improve performance for these cases [^1].
 
diff --git a/docs/src/model_simulation/sde_simulation_performance.md b/docs/src/model_simulation/sde_simulation_performance.md
index d32861ae69..603ee53852 100644
--- a/docs/src/model_simulation/sde_simulation_performance.md
+++ b/docs/src/model_simulation/sde_simulation_performance.md
@@ -1,4 +1,4 @@
-# [Advice for performant SDE simulations](@id sde_simulation_performance)
+# [Advice for Performant SDE Simulations](@id sde_simulation_performance)
 While there exist relatively straightforward approaches to manage performance for [ODE](@ref ode_simulation_performance) and jump simulations, this is generally not the case for SDE simulations. Below, we briefly describe some options. However, as one starts to investigate these, one quickly reaches what is (or could be) active areas of research.
 
 ## [SDE solver selection](@id sde_simulation_performance_solvers)
diff --git a/docs/src/model_simulation/simulation_plotting.md b/docs/src/model_simulation/simulation_plotting.md
index e48e10bac1..89fe89a484 100644
--- a/docs/src/model_simulation/simulation_plotting.md
+++ b/docs/src/model_simulation/simulation_plotting.md
@@ -1,4 +1,4 @@
-# [Simulation plotting](@id simulation_plotting)
+# [Simulation Plotting](@id simulation_plotting)
 Catalyst uses the [Plots.jl](https://github.com/JuliaPlots/Plots.jl) package for performing all plots. This section provides a brief summary of some useful plotting options, while [Plots.jl's documentation](https://docs.juliaplots.org/stable/) provides a more throughout description of how to tune your plots.
 
 !!! note
diff --git a/docs/src/model_simulation/simulation_structure_interfacing.md b/docs/src/model_simulation/simulation_structure_interfacing.md
index 063f9f61ed..dd8f2b034c 100644
--- a/docs/src/model_simulation/simulation_structure_interfacing.md
+++ b/docs/src/model_simulation/simulation_structure_interfacing.md
@@ -1,4 +1,4 @@
-# [Interfacing problems, integrators, and solutions](@id simulation_structure_interfacing)
+# [Interfacing Problems, Integrators, and Solutions](@id simulation_structure_interfacing)
 When simulating a model, one begins with creating a [problem](https://docs.sciml.ai/DiffEqDocs/stable/basics/problem/). Next, a simulation is performed on the problem, during which the simulation's state is recorded through an [integrator](https://docs.sciml.ai/DiffEqDocs/stable/basics/integrator/). Finally, the simulation output is returned as a [solution](https://docs.sciml.ai/DiffEqDocs/stable/basics/solution/). This tutorial describes how to access (or modify) the state (or parameter) values of problem, integrator, and solution structures.
 
 Generally, when we have a structure `simulation_struct` and want to interface with the unknown (or parameter) `x`, we use `simulation_struct[:x]` to access the value. For situations where a value is accessed (or changed) a large number of times, it can *improve performance* to first create a [specialised getter/setter function](@ref simulation_structure_interfacing_functions).
diff --git a/docs/src/spatial_modelling/spatial_jump_simulations.md b/docs/src/spatial_modelling/spatial_jump_simulations.md
index c28551932a..a7879003ce 100644
--- a/docs/src/spatial_modelling/spatial_jump_simulations.md
+++ b/docs/src/spatial_modelling/spatial_jump_simulations.md
@@ -1,4 +1,4 @@
-# [Spatial jump simulations](@id spatial_lattice_jump_simulations)
+# [Spatial Jump Simulations](@id spatial_lattice_jump_simulations)
 Our [introduction to spatial lattice simulations](@ref spatial_lattice_modelling_intro) has already described how to simulate [`LatticeReactionSystem`](@ref)s using ODEs. Jump simulations of [`LatticeReactionSystem`](@ref) are carried out using an almost identical approach. However, just like for non-spatial models, we must first create a `DiscreteProblem`, which is then used as input to our `JumpProblem`. Furthermore, a spatial [jump aggregator](@ref simulation_intro_jumps_solver_designation) (like `NSM`) can be used. Spatial jump simulations in Catalyst are built on top of JumpProcesses.jl's spatial jump simulators, more details on which can be found [here](https://docs.sciml.ai/JumpProcesses/stable/tutorials/spatial/).
 
 Below we perform a spatial jump simulation of a simple [birth-death process](@ref basic_CRN_library_bd). Note that we use our [`LatticeReactionSystem`](@ref) as input to both our `DiscreteProblem` and `JumpProblem`, and that we [provide](@ref simulation_intro_jumps_solver_designation) the spatial `NSM` jump aggregator to `JumpProblem`.
diff --git a/docs/src/steady_state_functionality/dynamical_systems.md b/docs/src/steady_state_functionality/dynamical_systems.md
index 8be5065afc..b7e5034650 100644
--- a/docs/src/steady_state_functionality/dynamical_systems.md
+++ b/docs/src/steady_state_functionality/dynamical_systems.md
@@ -1,4 +1,4 @@
-# [Analysing model steady state properties with DynamicalSystems.jl](@id dynamical_systems)
+# [Analysing Model Steady State Properties with DynamicalSystems.jl](@id dynamical_systems)
 The [DynamicalSystems.jl package](https://github.com/JuliaDynamics/DynamicalSystems.jl) implements a wide range of methods for analysing dynamical systems[^1][^2]. This includes both continuous-time systems (i.e. ODEs) and discrete-times ones (difference equations, however, these are not relevant to chemical reaction network modelling). Here we give two examples of how DynamicalSystems.jl can be used, with the package's [documentation describing many more features](https://juliadynamics.github.io/DynamicalSystemsDocs.jl/dynamicalsystems/dev/tutorial/). Finally, it should also be noted that DynamicalSystems.jl contain several tools for [analysing data measured from dynamical systems](https://juliadynamics.github.io/DynamicalSystemsDocs.jl/dynamicalsystems/dev/contents/#Exported-submodules).
 
 ## [Finding basins of attraction](@id dynamical_systems_basins_of_attraction)


Reviews:
user: login: TorkelE
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-19T17:48:16Z
user: login: TorkelE
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-19T17:58:26Z
user: login: TorkelE
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-19T17:58:56Z
user: login: isaacsas
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-19T19:32:17Z
user: login: isaacsas
state: APPROVED
author_association: MEMBER
submitted_at: 2025-03-19T19:33:00Z
user: login: TorkelE
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-20T10:25:29Z

Review comments:
diff_hunk: @@ -103,28 +103,28 @@ end
 ### [Bi-directional (or reversible) reactions](@id dsl_description_reaction_bundling_reversible)
 As is the case for the following two-state model:
 ```@example dsl_basics
-rn7 = @reaction_network begin
+rn_bidir = @reaction_network begin
     k1, X1 --> X2
     k2, X2 --> X1
 end
 ```
 it is common that reactions occur in both directions (so-called *bi-directional* reactions). Here, it is possible to bundle the reactions into a single line by using the `<-->` arrow. When we do this, the rate term must include two separate rates (one for each direction, these are enclosed by a `()` and separated by a `,`). I.e. the two-state model can be declared using:
 ```@example dsl_basics
-rn7 = @reaction_network begin
+rn_bidir = @reaction_network begin
path: docs/src/model_creation/dsl_basics.md
user: login: TorkelE
body: In some cases these names are nice to show that two models are identical. Now I just tried appending descriptors to their names instead.
(could also do a `rn_this == rn_that` check, but preferred to keep things very straightforward here)
created_at: 2025-03-19T17:48:16Z
author_association: MEMBER
diff_hunk: @@ -1,4 +1,4 @@
-# [Optimization for non-data fitting purposes](@id behaviour_optimisation)
+# [Optimization for Non-data Fitting Purposes](@id behaviour_optimisation)
path: docs/src/inverse_problems/behaviour_optimisation.md
user: login: TorkelE
body: I realised that almost all pages have capitalisation throughout the titles, but there were a couple where I hadn't done this. Don't really know, but figured I'd change the ones I hadn't done this to be consistent.
created_at: 2025-03-19T17:58:26Z
author_association: MEMBER
diff_hunk: @@ -1,4 +1,4 @@
-# [Symbolic Stochiometries](@id parametric_stoichiometry)
+# [Symbolic Stoichiometries](@id parametric_stoichiometry)
path: docs/src/model_creation/parametric_stoichiometry.md
user: login: TorkelE
body: don't recognise the other spelling, but I could be wrong
created_at: 2025-03-19T17:58:56Z
author_association: MEMBER
diff_hunk: @@ -16,13 +16,13 @@ continuing stability of releases. Before making a release one should
    issues can arise that do not lead to actual errors in the doc CI).
 4. Release via the [registration
    issue](https://github.com/SciML/Catalyst.jl/issues/127) with the
-   command:
+   command:  
    
-    ```
-    @JuliaRegistrator register branch=release-15.0.0
-    ```
+   ```
+   @JuliaRegistrator register branch=release-15.0.0
+   ```
path: docs/src/devdocs/dev_guide.md
user: login: isaacsas
body: Maybe use a raw block?

https://documenter.juliadocs.org/stable/man/syntax/#@raw-format-block
created_at: 2025-03-19T19:32:17Z
author_association: MEMBER
diff_hunk: @@ -16,13 +16,13 @@ continuing stability of releases. Before making a release one should
    issues can arise that do not lead to actual errors in the doc CI).
 4. Release via the [registration
    issue](https://github.com/SciML/Catalyst.jl/issues/127) with the
-   command:
+   command:  
    
-    ```
-    @JuliaRegistrator register branch=release-15.0.0
-    ```
+   ```
+   @JuliaRegistrator register branch=release-15.0.0
+   ```
path: docs/src/devdocs/dev_guide.md
user: login: TorkelE
body: nope. trying just a `@JuliaRegistrator register branch=release-15.0.0` and checking how that looks
created_at: 2025-03-20T10:25:29Z
author_association: MEMBER

PR comments:
user: login: JuliaRegistrator
created_at: 2025-03-19T17:46:28Z
body: Comments on pull requests will not trigger Registrator, as it is disabled. Please try commenting on a commit or issue.
author_association: NONE
user: login: TorkelE
created_at: 2025-03-19T17:49:36Z
body: > Comments on pull requests will not trigger Registrator, as it is disabled. Please try commenting on a commit or issue.

Well this could have become a funny incident...
author_association: MEMBER