test fix and update doc wording

Author: isaacsas

docs/src/faqs.md

@@ -333,86 +333,86 @@ nsys = convert(NonlinearSystem, rn; remove_conserved = true)
 # or 
 nprob = NonlinearProblem(rn, u0, p; remove_conserved = true)
 ```
-`remake`'s is currently unable to correctly update all `u0` values when the
-conserved constant(s), `Γ`, are updated. As an example consider the following example
+`remake` is currently unable to correctly update all `u0` values when the
+conserved constant(s), `Γ`, are updated. As an example consider the following
 ```@example faq_remake
 using Catalyst, NonlinearSolve
 rn = @reaction_network begin
-    (k1,k2), X1 <--> X2
-    (k3,k4), X1 + X2 --> 2X3
+    (k₁,k₂), X₁ <--> X₂
+    (k₃,k₄), X₁ + X₂ --> 2X₃
 end
-u0 = [:X1 => 1.0, :X2 => 2.0, :X3 => 3.0]
-ps = [:k1 => 0.1, :k2 => 0.2, :k3 => 0.3, :k4 => 0.4]
+u0 = [:X₁ => 1.0, :X₂ => 2.0, :X₃ => 3.0]
+ps = [:k₁ => 0.1, :k₂ => 0.2, :k₃ => 0.3, :k₄ => 0.4]
 nlsys = convert(NonlinearSystem, rn; remove_conserved = true, conseqs_remake_warn = false)
 nlsys = complete(nlsys)
 equations(nlsys)
 ```
 If we generate a `NonlinearProblem` from this system the conservation constant,
-`Γ[1]`, is automatically set to `X1 + X2 + X3 = 6` and the initial values are
+`Γ[1]`, is automatically set to `X₁ + X₂ + X₃ = 6` and the initial values are
 those in `u0`. i.e if
 ```@example faq_remake
 nlprob1 = NonlinearProblem(nlsys, u0, ps)
 ```
 then
 ```@example faq_remake
-nlprob1[(:X1, :X2, :X3)] == (1.0, 2.0, 3.0)
+nlprob1[(:X₁, :X₂, :X₃)] == (1.0, 2.0, 3.0)
 ```
 and
 ```@example faq_remake
 nlprob1.ps[:Γ][1] == 6.0
 ```
-If we now try to change a value of `X1`, `X2`, or `X3` using `remake`, the
+If we now try to change a value of `X₁`, `X₂`, or `X₃` using `remake`, the
 conserved constant will be recalculated. i.e. if
 ```@example faq_remake
-nlprob2 = remake(nlprob1; u0 = [:X2 => 3.0])
+nlprob2 = remake(nlprob1; u0 = [:X₂ => 3.0])
 ```
 compare  
 ```@example faq_remake
-println("Correct u0 is: ", (1.0, 3.0, 3.0), "\n", "remade value is: ", nlprob2[(:X1, :X2, :X3)]) 
+println("Correct u0 is: ", (1.0, 3.0, 3.0), "\n", "remade value is: ", nlprob2[(:X₁, :X₂, :X₃)]) 
 ```
 and
 ```@example faq_remake
 println("Correct Γ is: ", 7.0, "\n", "remade value is: ", nlprob2.ps[:Γ][1])
 ```
 However, if we try to directly change the value of `Γ` it is not always the case
 that a `u0` value will correctly update so that the conservation law is
-conserved. i.e. if
+conserved. Consider
 ```@example faq_remake
-nlprob3 = remake(nlprob1; u0 = [:X2 => nothing], p = [:Γ => [4.0]])
+nlprob3 = remake(nlprob1; u0 = [:X₂ => nothing], p = [:Γ => [4.0]])
 ```
-setting `[:X2 => nothing]` for other problem types communicates that the
-`u0` value for `X2` should be solved for. However, if we examine the values we
+Setting `[:X₂ => nothing]` for other problem types communicates that the
+`u0` value for `X₂` should be solved for. However, if we examine the values we
 find
 ```@example faq_remake
-println("Correct u0 is: ", (1.0, 0.0, 3.0), "\n", "remade value is: ", nlprob3[(:X1, :X2, :X3)]) 
+println("Correct u0 is: ", (1.0, 0.0, 3.0), "\n", "remade value is: ", nlprob3[(:X₁, :X₂, :X₃)]) 
 ```
 and
 ```@example faq_remake
 println("Correct Γ is: ", 4.0, "\n", "remade value is: ", nlprob3.ps[:Γ][1])
 ```
-As such, the `u0` value for `X2` has not updated, and the conservation law is
+As such, the `u0` value for `X₂` has not updated, and the conservation law is
 now violated by the `u0` values, i.e,
 ```@example faq_remake
-(nlprob3[:X1] + nlprob3[:X2] + nlprob3[:X3]) == nlprob3.ps[:Γ][1] 
+(nlprob3[:X₁] + nlprob3[:X₂] + nlprob3[:X₃]) == nlprob3.ps[:Γ][1] 
 ```
 Currently, the only way to avoid this issue is to manually specify updated
 values for the `u0` components, which will ensure that `Γ` updates appropriately
-as in the first example. i.e. we manually set `X2` to the value it should be and
+as in the first example. i.e. we manually set `X₂` to the value it should be and
 `Γ` will be updated accordingly:
 ```@example faq_remake
-nlprob4 = remake(nlprob1; u0 = [:X2 => 0.0])
+nlprob4 = remake(nlprob1; u0 = [:X₂ => 0.0])
 ```
 so that
 ```@example faq_remake
-println("Correct u0 is: ", (1.0, 0.0, 3.0), "\n", "remade value is: ", nlprob4[(:X1, :X2, :X3)]) 
+println("Correct u0 is: ", (1.0, 0.0, 3.0), "\n", "remade value is: ", nlprob4[(:X₁, :X₂, :X₃)]) 
 ```
 and
 ```@example faq_remake
 println("Correct Γ is: ", 4.0, "\n", "remade value is: ", nlprob4.ps[:Γ][1])
 ```
 
 Finally, we note there is one extra consideration to take into account if using
-`structural_simplify`. In this case one of `X1`, `X2`, or `X3` will be moved to
+`structural_simplify`. In this case one of `X₁`, `X₂`, or `X₃` will be moved to
 being an observed. It will then always correspond to the updated value if one
 tries to manually change `Γ`. Let's see what happens here directly
 ```@example faq_remake
@@ -435,25 +435,24 @@ Let's now remake
 ```@example faq_remake
 nlprob2 = remake(nlprob1; u0 = [obs_unknown => nothing], p = [:Γ => [8.0]])
 ```
-Here we indicate to assume the observed variable is not known during
-initialization. Since the observed variable is not considered an unknown,
-everything works now with the observed variable's assumed initial value adjusted
-to allow `Γ = 8`:
+Here we indicate that the observed variable should be treated as unspecified
+during initialization. Since the observed variable is not considered an unknown,
+everything now works, with the observed variable's assumed initial value
+adjusted to allow `Γ = 8`:
 ```@example faq_remake
 correct_u0 = last.(u0)
 correct_u0[obsidx] = 8 - sum(correct_u0) + correct_u0[obsidx]
-println("Correct u0 is: ", (1.0, 2.0, 5.0), "\n", "remade value is: ", nlprob2[(:X1, :X2, :X3)]) 
+println("Correct u0 is: ", (1.0, 2.0, 5.0), "\n", "remade value is: ", nlprob2[(:X₁, :X₂, :X₃)]) 
 ```
 and `Γ` becomes
 ```@example faq_remake
 println("Correct Γ is: ", 8.0, "\n", "remade value is: ", nlprob2.ps[:Γ][1])
 ```
-Unfortunately, as with our first example, trying to enforce that any other
-variable should have its initial value updated instead of the observed will not
-work.
+Unfortunately, as with our first example, trying to enforce that a
+non-eliminated species should have its initial value updated instead of the
+observed species will not work.
 
 *Summary:* it is not recommended to directly update `Γ` via `remake`, but to
-instead update values of the initial guesses, `u0`, to obtain a desired `Γ`. At
-this time the behavior when updating `Γ` is inconsistent or incorrect in what
-will be modified in `u0`, and as such should not be relied on to generate a
-consistent `u0` that still satisfies the conservation law.
+instead update values of the initial guesses in `u0` to obtain a desired `Γ`. At
+this time the behavior when updating `Γ` can result in `u0` values that do not
+satisfy the conservation law defined by `Γ` as illustrated above. 

test/network_analysis/conservation_laws.jl

@@ -502,7 +502,7 @@ let
     # Create models.
     rn = @reaction_network begin
         (k1,k2), X1 <--> X2
-        (k3,k4), X1 + X2 --> 2X3
+        (k3,k4), X1 + X2 <--> 2X3
     end
     u0 = [:X1 => 1.0, :X2 => 2.0, :X3 => 3.0]
     ps = [:k1 => 0.1, :k2 => 0.2, :k3 => 0.3, :k4 => 0.4]