From 63c5e9a6a604d8adb33543973808f24209618a69 Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Wed, 4 Oct 2023 10:34:58 +0000 Subject: [PATCH] build based on f611c26 --- dev/assets/Manifest.toml | 2 +- dev/assets/Project.toml | 1 + dev/export/export/index.html | 2 +- dev/identifiability/identifiability/index.html | 8 ++++---- dev/index.html | 4 ++-- dev/input/input/index.html | 2 +- dev/ioequations/ioequations/index.html | 2 +- dev/search/index.html | 2 +- dev/tutorials/creating_ode/index.html | 2 +- dev/tutorials/identifiability/index.html | 2 +- dev/tutorials/identifiable_functions/index.html | 2 +- dev/utils/elimination/index.html | 2 +- dev/utils/global_identifiability/index.html | 2 +- dev/utils/local_identifiability/index.html | 2 +- dev/utils/ode/index.html | 6 +++--- dev/utils/power_series_utils/index.html | 2 +- dev/utils/primality/index.html | 2 +- dev/utils/util/index.html | 4 ++-- dev/utils/wronskian/index.html | 2 +- 19 files changed, 26 insertions(+), 25 deletions(-) diff --git a/dev/assets/Manifest.toml b/dev/assets/Manifest.toml index f8709ffed..7c9a87ac0 100644 --- a/dev/assets/Manifest.toml +++ b/dev/assets/Manifest.toml @@ -2,7 +2,7 @@ julia_version = "1.9.3" manifest_format = "2.0" -project_hash = "225c06d655cf28e9df276cd42a3df7d36907bd89" +project_hash = "205d4769b7eb3ca762fb5c2434348139498cb04c" [[deps.ADTypes]] git-tree-sha1 = "5d2e21d7b0d8c22f67483ef95ebdc39c0e6b6003" diff --git a/dev/assets/Project.toml b/dev/assets/Project.toml index 6998d3954..101d56127 100644 --- a/dev/assets/Project.toml +++ b/dev/assets/Project.toml @@ -8,3 +8,4 @@ StructuralIdentifiability = "220ca800-aa68-49bb-acd8-6037fa93a544" BenchmarkTools = "1.3" Documenter = "0.27" ModelingToolkit = "8.34" +StructuralIdentifiability = "0.4" diff --git a/dev/export/export/index.html b/dev/export/export/index.html index 3d8f6ad3b..f1d81569a 100644 --- a/dev/export/export/index.html +++ b/dev/export/export/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

Exporting to Other Systems

Here we put some helpful utilities to export your code to other identifiability software.

StructuralIdentifiability.print_for_maple — Function
print_for_maple(ode, package)

Prints the ODE in the format accepted by maple packages

  • SIAN (https://github.com/pogudingleb/SIAN) if package=:SIAN
  • DifferentialAlgebra if package=:DifferentialAlgebra
  • DifferentialThomas if package=:DifferentialThomas
source
+
Edit on GitHub

Exporting to Other Systems

Here we put some helpful utilities to export your code to other identifiability software.

StructuralIdentifiability.print_for_maple — Function
print_for_maple(ode, package)

Prints the ODE in the format accepted by maple packages

  • SIAN (https://github.com/pogudingleb/SIAN) if package=:SIAN
  • DifferentialAlgebra if package=:DifferentialAlgebra
  • DifferentialThomas if package=:DifferentialThomas
source
diff --git a/dev/identifiability/identifiability/index.html b/dev/identifiability/identifiability/index.html index 340c067bf..38e31c8f4 100644 --- a/dev/identifiability/identifiability/index.html +++ b/dev/identifiability/identifiability/index.html @@ -3,12 +3,12 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

ָFunctions to Assess Identifiability

Assessing All Types of Identifiability

StructuralIdentifiability.assess_identifiability — Function
assess_identifiability(ode; funcs_to_check = [], p=0.99)

Input:

  • ode - the ODE model
  • funcs_to_check - list of functions to check identifiability for; if empty, all parameters and states are taken
  • p - probability of correctness.

Assesses identifiability of a given ODE model. The result is guaranteed to be correct with the probability at least p. The function returns a dictionary from the functions to check to their identifiability properties (one of :nonidentifiable, :locally, :globally).

source
assess_identifiability(ode::ModelingToolkit.ODESystem; measured_quantities=Array{ModelingToolkit.Equation}[], funcs_to_check=[], p = 0.99)

Input:

  • ode - the ModelingToolkit.ODESystem object that defines the model
  • measured_quantities - the output functions of the model
  • funcs_to_check - functions of parameters for which to check the identifiability
  • p - probability of correctness.

Assesses identifiability (both local and global) of a given ODE model (parameters detected automatically). The result is guaranteed to be correct with the probability at least p.

source

Assessing Local Identifiability

StructuralIdentifiability.assess_local_identifiability — Function
function assess_local_identifiability(ode::ModelingToolkit.ODESystem; measured_quantities=Array{ModelingToolkit.Equation}[], funcs_to_check=Array{}[], p::Float64=0.99, type=:SE)

Input:

  • ode - the ODESystem object from ModelingToolkit
  • measured_quantities - the measurable outputs of the model
  • funcs_to_check - functions of parameters for which to check identifiability
  • p - probability of correctness
  • type - identifiability type (:SE for single-experiment, :ME for multi-experiment)

Output:

  • for type=:SE, the result is a dictionary from each parameter to boolean;
  • for type=:ME, the result is a tuple with the dictionary as in :SE case and array of number of experiments.

The function determines local identifiability of parameters in funcs_to_check or all possible parameters if funcs_to_check is empty

The result is correct with probability at least p.

type can be either :SE (single-experiment identifiability) or :ME (multi-experiment identifiability). The return value is a tuple consisting of the array of bools and the number of experiments to be performed.

source
assess_local_identifiability(ode::ODE{P}; funcs_to_check::Array{<: Any, 1}, p::Float64=0.99, type=:SE) where P <: MPolyElem{Nemo.fmpq}

Checks the local identifiability/observability of the functions in funcs_to_check. The result is correct with probability at least p.

Call this function if you have a specific collection of parameters of which you would like to check local identifiability.

type can be either :SE (single-experiment identifiability) or :ME (multi-experiment identifiability). If the type is :ME, states are not allowed to appear in the funcs_to_check.

source
function assess_local_identifiability(
+
Edit on GitHub
ָFunctions to Assess Identifiability
Assessing All Types of Identifiability
StructuralIdentifiability.assess_identifiability — Function
assess_identifiability(ode; funcs_to_check = [], p=0.99)
Input:
  • ode - the ODE model
  • funcs_to_check - list of functions to check identifiability for; if empty, all parameters  and states are taken
  • p - probability of correctness.
Assesses identifiability of a given ODE model. The result is guaranteed to be correct with the probability at least p. The function returns a dictionary from the functions to check to their identifiability properties  (one of :nonidentifiable, :locally, :globally).
source
assess_identifiability(ode::ModelingToolkit.ODESystem; measured_quantities=Array{ModelingToolkit.Equation}[], funcs_to_check=[], p = 0.99)
Input:
  • ode - the ModelingToolkit.ODESystem object that defines the model
  • measured_quantities - the output functions of the model
  • funcs_to_check - functions of parameters for which to check the identifiability
  • p - probability of correctness.
Assesses identifiability (both local and global) of a given ODE model (parameters detected automatically). The result is guaranteed to be correct with the probability at least p.
source
Assessing Local Identifiability
StructuralIdentifiability.assess_local_identifiability — Function
function assess_local_identifiability(ode::ModelingToolkit.ODESystem; measured_quantities=Array{ModelingToolkit.Equation}[], funcs_to_check=Array{}[], p::Float64=0.99, type=:SE)
Input:
  • ode - the ODESystem object from ModelingToolkit
  • measured_quantities - the measurable outputs of the model
  • funcs_to_check - functions of parameters for which to check identifiability
  • p - probability of correctness
  • type - identifiability type (:SE for single-experiment, :ME for multi-experiment)
Output:
  • for type=:SE, the result is a dictionary from each parameter to boolean;
  • for type=:ME, the result is a tuple with the dictionary as in :SE case and array of number of experiments.
The function determines local identifiability of parameters in funcs_to_check or all possible parameters if funcs_to_check is empty
The result is correct with probability at least p.
type can be either :SE (single-experiment identifiability) or :ME (multi-experiment identifiability). The return value is a tuple consisting of the array of bools and the number of experiments to be performed.
source
assess_local_identifiability(ode::ODE{P}; funcs_to_check::Array{<: Any, 1}, p::Float64=0.99, type=:SE) where P <: MPolyElem{Nemo.fmpq}
Checks the local identifiability/observability of the functions in funcs_to_check. The result is correct with probability at least p.
Call this function if you have a specific collection of parameters of which you would like to check local identifiability.
type can be either :SE (single-experiment identifiability) or :ME (multi-experiment identifiability). If the type is :ME, states are not allowed to appear in the funcs_to_check.
source
function assess_local_identifiability(
     dds::ModelingToolkit.DiscreteSystem; 
     measured_quantities=Array{ModelingToolkit.Equation}[], 
     funcs_to_check=Array{}[], 
     known_ic=Array{}[],
-    p::Float64=0.99)
Input:
  • dds - the DiscreteSystem object from ModelingToolkit
  • measured_quantities - the measurable outputs of the model
  • funcs_to_check - functions of parameters for which to check identifiability (all parameters and states if not specified)
  • known_ic - functions (of states and parameter) whose initial conditions are assumed to be known
  • p - probability of correctness
Output:
  • the result is a dictionary from each function to to boolean;
The result is correct with probability at least p.
source
Assessing Global Identifiability
StructuralIdentifiability.assess_global_identifiability — Function
assess_global_identifiability(ode::ODE{P}, p::Float64=0.99; var_change=:default) where P <: MPolyElem{fmpq}
Input:
  • ode - the ODE model
  • known - a list of functions in states which are assumed to be known and generic
  • p - probability of correctness
  • var_change - a policy for variable change (:default, :yes, :no), affects only the runtime
Output:
  • a dictionary mapping each parameter to a boolean.
Checks global identifiability for parameters of the model provided in ode. Call this function to check global identifiability of all parameters automatically.
source
assess_global_identifiability(ode, [funcs_to_check, p=0.99, var_change=:default])
Input:
  • ode - the ODE model
  • funcs_to_check - rational functions in parameters
  • known - function in parameters that are assumed to be known and generic
  • p - probability of correctness
  • var_change - a policy for variable change (:default, :yes, :no),               affects only the runtime
Output:
  • array of length length(funcs_to_check) with true/false values for global identifiability       or dictionary param => Bool if funcs_to_check are not given
Checks global identifiability of functions of parameters specified in funcs_to_check.
source
Finding Identifiable Functions
StructuralIdentifiability.find_identifiable_functions — Function
find_identifiable_functions(ode::ODE; options...)
Finds all functions of parameters/states that are identifiable in the given ODE system.
Options
This functions takes the following optional arguments:
  • with_states: When true, also reports the identifiabile functions in the   ODE states. Default is false.
  • simplify: The extent to which the output functions are simplified. Stronger simplification may require more time. Possible options are:
    • :standard: Default simplification.
    • :weak: Weak simplification. This option is the fastest, but the output functions can be quite complex.
    • :strong: Strong simplification. This option is the slowest, but the output
    functions are nice and simple.
    • :absent: No simplification.
  • p: A float in the range from 0 to 1, the probability of correctness. Default is 0.99.
  • seed: The rng seed. Default value is 42.
Example
using StructuralIdentifiability
+    p::Float64=0.99)
Input:
  • dds - the DiscreteSystem object from ModelingToolkit
  • measured_quantities - the measurable outputs of the model
  • funcs_to_check - functions of parameters for which to check identifiability (all parameters and states if not specified)
  • known_ic - functions (of states and parameter) whose initial conditions are assumed to be known
  • p - probability of correctness
Output:
  • the result is a dictionary from each function to to boolean;
The result is correct with probability at least p.
source
Assessing Global Identifiability
StructuralIdentifiability.assess_global_identifiability — Function
assess_global_identifiability(ode::ODE{P}, p::Float64=0.99; var_change=:default) where P <: MPolyElem{fmpq}
Input:
  • ode - the ODE model
  • known - a list of functions in states which are assumed to be known and generic
  • p - probability of correctness
  • var_change - a policy for variable change (:default, :yes, :no), affects only the runtime
Output:
  • a dictionary mapping each parameter to a boolean.
Checks global identifiability for parameters of the model provided in ode. Call this function to check global identifiability of all parameters automatically.
source
assess_global_identifiability(ode, [funcs_to_check, p=0.99, var_change=:default])
Input:
  • ode - the ODE model
  • funcs_to_check - rational functions in parameters
  • known - function in parameters that are assumed to be known and generic
  • p - probability of correctness
  • var_change - a policy for variable change (:default, :yes, :no),               affects only the runtime
Output:
  • array of length length(funcs_to_check) with true/false values for global identifiability       or dictionary param => Bool if funcs_to_check are not given
Checks global identifiability of functions of parameters specified in funcs_to_check.
source
Finding Identifiable Functions
StructuralIdentifiability.find_identifiable_functions — Function
find_identifiable_functions(ode::ODE; options...)
Finds all functions of parameters/states that are identifiable in the given ODE system.
Options
This functions takes the following optional arguments:
  • with_states: When true, also reports the identifiabile functions in the   ODE states. Default is false.
  • simplify: The extent to which the output functions are simplified. Stronger simplification may require more time. Possible options are:
    • :standard: Default simplification.
    • :weak: Weak simplification. This option is the fastest, but the output functions can be quite complex.
    • :strong: Strong simplification. This option is the slowest, but the output
    functions are nice and simple.
    • :absent: No simplification.
  • p: A float in the range from 0 to 1, the probability of correctness. Default is 0.99.
  • seed: The rng seed. Default value is 42.
Example
using StructuralIdentifiability
 
 ode = @ODEmodel(
     x0'(t) = -(a01 + a21) * x0(t) + a12 * x1(t),
@@ -21,7 +21,7 @@
 # prints
 3-element Vector{AbstractAlgebra.Generic.Frac{Nemo.fmpq_mpoly}}:
  a12 + a01 + a21
- a12*a01
source
find_identifiable_functions(ode::ModelingToolkit.ODESystem; measured_quantities=[], options...)
Finds all functions of parameters/states that are identifiable in the given ODE system.
Options
This functions takes the following optional arguments:
  • measured_quantities - the output functions of the model.
Example
using StructuralIdentifiability
+ a12*a01
source
find_identifiable_functions(ode::ModelingToolkit.ODESystem; measured_quantities=[], options...)
Finds all functions of parameters/states that are identifiable in the given ODE system.
Options
This functions takes the following optional arguments:
  • measured_quantities - the output functions of the model.
Example
using StructuralIdentifiability
 using ModelingToolkit
 
 @parameters a01 a21 a12
@@ -39,4 +39,4 @@
 # prints
 2-element Vector{Num}:
          a01*a12
- a01 + a12 + a21
source

+ a01 + a12 + a21
source
diff --git a/dev/index.html b/dev/index.html index b8fa5a405..9a59ab86d 100644 --- a/dev/index.html +++ b/dev/index.html @@ -24,7 +24,7 @@ Official https://julialang.org/ release Platform Info: OS: Linux (x86_64-linux-gnu) - CPU: 2 × Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz + CPU: 2 × Intel(R) Xeon(R) Platinum 8171M CPU @ 2.60GHz WORD_SIZE: 64 LIBM: libopenlibm LLVM: libLLVM-14.0.6 (ORCJIT, skylake-avx512) @@ -254,4 +254,4 @@ [3f19e933] p7zip_jll v17.4.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`You can also download the manifest file and the -project file. +project file. diff --git a/dev/input/input/index.html b/dev/input/input/index.html index 829933a64..b93e76e69 100644 --- a/dev/input/input/index.html +++ b/dev/input/input/index.html @@ -9,4 +9,4 @@ x1'(t) = a * x1(t) + u(t), x2'(t) = b * x2(t) + c*x1(t)*x2(t), y(t) = x1(t) -)

Here,

source
StructuralIdentifiability.ODE — Type

The main structure that represents input ODE system.

Stores information about states (x_vars), outputs (y_vars), inputs (u_vars), parameters (parameters) and the equations.

This structure is constructed via @ODEmodel macro.

source
StructuralIdentifiability.set_parameter_values — Function
set_parameter_values(ode, param_values)

Input:

  • ode - an ODE as above
  • param_values - values for (possibly, some of) the parameters as dictionary parameter => value

Output:

  • new ode with the parameters in param_values plugged with the given numbers
source

Create Compartmental Model

StructuralIdentifiability.linear_compartment_model — Function
linear_compartment_model(graph, inputs, outputs, leaks)

Input: defines a linear compartment model with nodes numbered from 1 to n by

  • graph - and array of integer arrays representing the adjacency lists of the graph
  • inputs - array of input nodes
  • outputs - array of output nodes
  • leaks - array of sink nodes

Output:

  • the corresponding ODE system in the notation of https://doi.org/10.1007/s11538-015-0098-0
source
+)

Here,

source
StructuralIdentifiability.ODE — Type

The main structure that represents input ODE system.

Stores information about states (x_vars), outputs (y_vars), inputs (u_vars), parameters (parameters) and the equations.

This structure is constructed via @ODEmodel macro.

source
StructuralIdentifiability.set_parameter_values — Function
set_parameter_values(ode, param_values)

Input:

  • ode - an ODE as above
  • param_values - values for (possibly, some of) the parameters as dictionary parameter => value

Output:

  • new ode with the parameters in param_values plugged with the given numbers
source

Create Compartmental Model

StructuralIdentifiability.linear_compartment_model — Function
linear_compartment_model(graph, inputs, outputs, leaks)

Input: defines a linear compartment model with nodes numbered from 1 to n by

  • graph - and array of integer arrays representing the adjacency lists of the graph
  • inputs - array of input nodes
  • outputs - array of output nodes
  • leaks - array of sink nodes

Output:

  • the corresponding ODE system in the notation of https://doi.org/10.1007/s11538-015-0098-0
source
diff --git a/dev/ioequations/ioequations/index.html b/dev/ioequations/ioequations/index.html index f7e653c67..314257c13 100644 --- a/dev/ioequations/ioequations/index.html +++ b/dev/ioequations/ioequations/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

Finding Input-Output Equations

StructuralIdentifiability.find_ioequations — Function
find_ioequations(ode, [var_change_policy=:default])

Finds the input-output equations of an ODE system Input:

  • ode - the ODE system
  • var_change_policy - whether to perform automatic variable change, can be one of :default, :yes, :no

Output:

  • a dictionary from “leaders” to the corresponding input-output equations; if an extra projection is needed, it will be the value corresponding to rand_proj_var
source

Reducing with respect to Input-Output Equations

StructuralIdentifiability.PBRepresentation — Type

The structure for storing a projection-based representation of differential ideal (see Section 2.3 https://arxiv.org/abs/2111.00991). Contains the following fields:

  • y_names - the names of the variables with finite order in the profile (typically, outputs)
  • u_names - the names of the variables with infinite order in the profile (typically, inputs)
  • param_names - the names of the parameters
  • profile - the profile of the PB-representation (see Definition 2.13) as a dict from y_names with finite orders to the orders
  • projections - the corresponding projections (see Definition 2.15) as a dict from y_names to the projections
source
StructuralIdentifiability.pseudodivision — Function
pseudodivision(f, g, x)

Computes the result of pseudodivision of f by g as univariate polynomials in x Input:

  • f - the polynomial to be divided
  • g - the polynomial to divide by
  • x - the variable for the division

Output: the pseudoremainder of f divided by g w.r.t. x

source
StructuralIdentifiability.diffreduce — Function
diffreduce(diffpoly, pbr)

Computes the result of differential reduction of a differential polynomial diffpoly with respect to the charset defined by a PB-representation pbr Input:

  • diffpoly - a polynomial representing a differential polynomial to be reduced
  • pbr - a projection-based representation

Output: the result of differential reduction of diffpoly by pbr considered as a characteristic set (see Remark 2.20 in the paper)

source
+
Edit on GitHub

Finding Input-Output Equations

StructuralIdentifiability.find_ioequations — Function
find_ioequations(ode, [var_change_policy=:default])

Finds the input-output equations of an ODE system Input:

  • ode - the ODE system
  • var_change_policy - whether to perform automatic variable change, can be one of :default, :yes, :no

Output:

  • a dictionary from “leaders” to the corresponding input-output equations; if an extra projection is needed, it will be the value corresponding to rand_proj_var
source

Reducing with respect to Input-Output Equations

StructuralIdentifiability.PBRepresentation — Type

The structure for storing a projection-based representation of differential ideal (see Section 2.3 https://arxiv.org/abs/2111.00991). Contains the following fields:

  • y_names - the names of the variables with finite order in the profile (typically, outputs)
  • u_names - the names of the variables with infinite order in the profile (typically, inputs)
  • param_names - the names of the parameters
  • profile - the profile of the PB-representation (see Definition 2.13) as a dict from y_names with finite orders to the orders
  • projections - the corresponding projections (see Definition 2.15) as a dict from y_names to the projections
source
StructuralIdentifiability.pseudodivision — Function
pseudodivision(f, g, x)

Computes the result of pseudodivision of f by g as univariate polynomials in x Input:

  • f - the polynomial to be divided
  • g - the polynomial to divide by
  • x - the variable for the division

Output: the pseudoremainder of f divided by g w.r.t. x

source
StructuralIdentifiability.diffreduce — Function
diffreduce(diffpoly, pbr)

Computes the result of differential reduction of a differential polynomial diffpoly with respect to the charset defined by a PB-representation pbr Input:

  • diffpoly - a polynomial representing a differential polynomial to be reduced
  • pbr - a projection-based representation

Output: the result of differential reduction of diffpoly by pbr considered as a characteristic set (see Remark 2.20 in the paper)

source
diff --git a/dev/search/index.html b/dev/search/index.html index 582e20ecf..c0c21fa1f 100644 --- a/dev/search/index.html +++ b/dev/search/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -

Loading search...

    +

    Loading search...

      diff --git a/dev/tutorials/creating_ode/index.html b/dev/tutorials/creating_ode/index.html index cd96552a0..3286b16ac 100644 --- a/dev/tutorials/creating_ode/index.html +++ b/dev/tutorials/creating_ode/index.html @@ -57,4 +57,4 @@ chi2 => :globally x1(t) => :globally c1 => :globally - u(t) => :globally
      + u(t) => :globally
      diff --git a/dev/tutorials/identifiability/index.html b/dev/tutorials/identifiability/index.html index 5fd6c2194..1f7855cae 100644 --- a/dev/tutorials/identifiability/index.html +++ b/dev/tutorials/identifiability/index.html @@ -48,4 +48,4 @@ alpha => :nonidentifiable x3 => :nonidentifiable

      As a result, each parameter/state is assigned one of the labels :globally (globally identifiable), :locally (locally but not globally identifiable), or :nonidentifiable (not identifiable, even locally). The algorithm behind this computation follows [4].

      Similarly to assess_local_identifiability, this function has optional parameters:

      Using funcs_to_check parameter, one can further inverstigate the nature of the lack of identifiability in the model at hand. For example, for the Goodwin oscillator, we can check if beta + delta and beta * delta are identifiable:

      assess_identifiability(ode, funcs_to_check = [beta + delta, beta * delta])
      Dict{Any, Symbol} with 2 entries:
   delta*beta   => :globally
-  delta + beta => :globally

      And we see that they indeed are. This means, in particular, that the reason why beta and delta are not identifiable is because their values can be exchanged. One may wonder how could we guess these functions beta + delta, beta * delta. In fact, they can be just computed using find_identifiable_functions function as we will explain in the next tutorial. Stay tuned!

      + delta + beta => :globally

      And we see that they indeed are. This means, in particular, that the reason why beta and delta are not identifiable is because their values can be exchanged. One may wonder how could we guess these functions beta + delta, beta * delta. In fact, they can be just computed using find_identifiable_functions function as we will explain in the next tutorial. Stay tuned!

      diff --git a/dev/tutorials/identifiable_functions/index.html b/dev/tutorials/identifiable_functions/index.html index 808de4e7a..617c8a101 100644 --- a/dev/tutorials/identifiable_functions/index.html +++ b/dev/tutorials/identifiable_functions/index.html @@ -22,4 +22,4 @@ p2*p4 p3 + p1 p2*x2 + p4*x1 - (p2*x2 - p4*x1)//(p3 - p1)

      By default, find_identifiable_functions tries to simplify the output functions as much as possible, and it has simplify keyword responsible for the degree of simplification. The default value is :standard but one could use :string to try to simplify further (at the expense of heavier computation) or use :weak to simplify less (but compute faster).

      + (p2*x2 - p4*x1)//(p3 - p1)

      By default, find_identifiable_functions tries to simplify the output functions as much as possible, and it has simplify keyword responsible for the degree of simplification. The default value is :standard but one could use :string to try to simplify further (at the expense of heavier computation) or use :weak to simplify less (but compute faster).

      diff --git a/dev/utils/elimination/index.html b/dev/utils/elimination/index.html index e7353d97d..3ef1fde4e 100644 --- a/dev/utils/elimination/index.html +++ b/dev/utils/elimination/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Elimination

      StructuralIdentifiability.Bezout_matrix — Method
      Bezout_matrix(f, g, var_elim)

      Compute the Bezout matrix of two polynomials f, g with respect to var_elim

      Inputs:

      • f - first polynomial
      • g - second polynomial
      • var_elim - variable, of which f and g are considered as polynomials

      Output:

      • M::MatrixElem - The Bezout matrix
      source
      StructuralIdentifiability.Sylvester_matrix — Method
      Sylvester_matrix(f, g, var_elim)

      Compute the Sylvester matrix of two polynomials f, g with respect to var_elim Inputs:

      • f - first polynomial
      • g - second polynomial
      • var_elim - variable, of which f and g are considered as polynomials

      Output:

      • M::MatrixElem - The Sylvester matrix
      source
      StructuralIdentifiability.choose — Method
      choose(polys, generic_point_generator)

      Input:

      • polys - an array of distinct irreducible polynomials in the same ring
      • generic_point_generator - a generic point generator as described above for one of polys

      Output:

      • the polynomial that vanishes at the generic_point_generator
      source
      StructuralIdentifiability.eliminate_var — Method
      eliminate_var(f, g, var_elim, generic_point_generator)

      Eliminate a variable from a pair of polynomials

      Input:

      • f and g - polynomials
      • var_elim - variable to be eliminated
      • generic_point_generator - a generic point generator object for the factor of the resultant of f and g of interest

      Output:

      • polynomial - the desired factor of the resultant of f and g
      source
      StructuralIdentifiability.simplify_matrix — Method
      simplify_matrix(M)

      Eliminate GCD of entries of every row and column

      Input:

      • M::MatrixElem - matrix to be simplified

      Output:

      • M::MatrixElem - Simplified matrix
      • extra_factors::Vector{AbstractAlgebra.MPolyElem} - array of GCDs eliminated from M.
      source
      +
      Edit on GitHub

      Elimination

      StructuralIdentifiability.Bezout_matrix — Method
      Bezout_matrix(f, g, var_elim)

      Compute the Bezout matrix of two polynomials f, g with respect to var_elim

      Inputs:

      • f - first polynomial
      • g - second polynomial
      • var_elim - variable, of which f and g are considered as polynomials

      Output:

      • M::MatrixElem - The Bezout matrix
      source
      StructuralIdentifiability.Sylvester_matrix — Method
      Sylvester_matrix(f, g, var_elim)

      Compute the Sylvester matrix of two polynomials f, g with respect to var_elim Inputs:

      • f - first polynomial
      • g - second polynomial
      • var_elim - variable, of which f and g are considered as polynomials

      Output:

      • M::MatrixElem - The Sylvester matrix
      source
      StructuralIdentifiability.choose — Method
      choose(polys, generic_point_generator)

      Input:

      • polys - an array of distinct irreducible polynomials in the same ring
      • generic_point_generator - a generic point generator as described above for one of polys

      Output:

      • the polynomial that vanishes at the generic_point_generator
      source
      StructuralIdentifiability.eliminate_var — Method
      eliminate_var(f, g, var_elim, generic_point_generator)

      Eliminate a variable from a pair of polynomials

      Input:

      • f and g - polynomials
      • var_elim - variable to be eliminated
      • generic_point_generator - a generic point generator object for the factor of the resultant of f and g of interest

      Output:

      • polynomial - the desired factor of the resultant of f and g
      source
      StructuralIdentifiability.simplify_matrix — Method
      simplify_matrix(M)

      Eliminate GCD of entries of every row and column

      Input:

      • M::MatrixElem - matrix to be simplified

      Output:

      • M::MatrixElem - Simplified matrix
      • extra_factors::Vector{AbstractAlgebra.MPolyElem} - array of GCDs eliminated from M.
      source
      diff --git a/dev/utils/global_identifiability/index.html b/dev/utils/global_identifiability/index.html index 52c6482d0..79372cb3c 100644 --- a/dev/utils/global_identifiability/index.html +++ b/dev/utils/global_identifiability/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Global Identifiability Tools

      Missing docstring.

      Missing docstring for StructuralIdentifiability.check_field_membership. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for StructuralIdentifiability.extract_identifiable_functions. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for StructuralIdentifiability.find_identifiable_functions. Check Documenter's build log for details.

      +
      Edit on GitHub

      Global Identifiability Tools

      Missing docstring.

      Missing docstring for StructuralIdentifiability.check_field_membership. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for StructuralIdentifiability.extract_identifiable_functions. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for StructuralIdentifiability.find_identifiable_functions. Check Documenter's build log for details.

      diff --git a/dev/utils/local_identifiability/index.html b/dev/utils/local_identifiability/index.html index b1e2eefc4..ff4e851a5 100644 --- a/dev/utils/local_identifiability/index.html +++ b/dev/utils/local_identifiability/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Local Identifiability Tools

      StructuralIdentifiability.differentiate_solution — Function
      differentiate_solution(ode, params, ic, inputs, prec)

      Input:

      • the same as for power_series_solutions

      Output:

      • a tuple consisting of the power series solution and a dictionary of the form (u, v) => power series, where u is a state variable v is a state or parameter, and the power series is the partial derivative of the function u w.r.t. v evaluated at the solution
      source
      StructuralIdentifiability.differentiate_output — Function
      differentiate_output(ode, params, ic, inputs, prec)

      Similar to differentiate_solution but computes partial derivatives of prescribed outputs returns a dictionary of the form y_function => Dict(var => dy/dvar) where dy/dvar is the derivative of y_function with respect to var.

      source
      +
      Edit on GitHub

      Local Identifiability Tools

      StructuralIdentifiability.differentiate_solution — Function
      differentiate_solution(ode, params, ic, inputs, prec)

      Input:

      • the same as for power_series_solutions

      Output:

      • a tuple consisting of the power series solution and a dictionary of the form (u, v) => power series, where u is a state variable v is a state or parameter, and the power series is the partial derivative of the function u w.r.t. v evaluated at the solution
      source
      StructuralIdentifiability.differentiate_output — Function
      differentiate_output(ode, params, ic, inputs, prec)

      Similar to differentiate_solution but computes partial derivatives of prescribed outputs returns a dictionary of the form y_function => Dict(var => dy/dvar) where dy/dvar is the derivative of y_function with respect to var.

      source
      diff --git a/dev/utils/ode/index.html b/dev/utils/ode/index.html index fbe77da00..ce6e07f58 100644 --- a/dev/utils/ode/index.html +++ b/dev/utils/ode/index.html @@ -3,8 +3,8 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Working with ODEs

      StructuralIdentifiability.__preprocess_ode — Method
      function __preprocess_ode(de::ModelingToolkit.AbstractTimeDependentSystem, measured_quantities::Array{Tuple{String, SymbolicUtils.BasicSymbolic}})

      Input:

      • de - ModelingToolkit.AbstractTimeDependentSystem, a system for identifiability query
      • measured_quantities - array of input function in the form (name, expression)

      Output:

      • ODE object containing required data for identifiability assessment
      • conversion dictionary from the symbols in the input MTK model to the variable involved in the produced ODE object
      source
      StructuralIdentifiability.power_series_solution — Method
      power_series_solution(ode, param_values, initial_conditions, input_values, prec)

      Input:

      • ode - an ode to solve
      • param_values - parameter values, must be a dictionary mapping parameter to a value
      • initial_conditions - initial conditions of ode, must be a dictionary mapping state variable to a value
      • input_values - power series for the inputs presented as a dictionary variable => list of coefficients
      • prec - the precision of solutions

      Output:

      • computes a power series solution with precision prec presented as a dictionary variable => corresponding coordinate of the solution
      source
      StructuralIdentifiability.preprocess_ode — Method
      function preprocess_ode(de::ModelingToolkit.AbstractTimeDependentSystem, measured_quantities::Array{ModelingToolkit.Equation})
-function preprocess_ode(de::ModelingToolkit.AbstractTimeDependentSystem, measured_quantities::Array{SymbolicUtils.BasicSymbolic})

      Input:

      • de - ModelingToolkit.AbstractTimeDependentSystem, a system for identifiability query
      • measured_quantities - array of output functions (as equations of just functions)

      Output:

      • ODE object containing required data for identifiability assessment
      • conversion dictionary from the symbols in the input MTK model to the variable involved in the produced ODE object
      source
      StructuralIdentifiability.set_parameter_values — Method
      set_parameter_values(ode, param_values)

      Input:

      • ode - an ODE as above
      • param_values - values for (possibly, some of) the parameters as dictionary parameter => value

      Output:

      • new ode with the parameters in param_values plugged with the given numbers
      source
      StructuralIdentifiability.find_submodels — Method
      find_submodels(ode)

      The function calculates and returns all valid submodels given a system of ODEs.

      Input:

      • ode - an ODEs system to be studied

      Output:

      • A list of submodels represented as ode objects

      Example:

      >ode = @ODEmodel(x1'(t) = x1(t)^2, 
+
      Edit on GitHub
      Working with ODEs
      StructuralIdentifiability.__preprocess_ode — Method
      function __preprocess_ode(de::ModelingToolkit.AbstractTimeDependentSystem, measured_quantities::Array{Tuple{String, SymbolicUtils.BasicSymbolic}})
      Input:
      • de - ModelingToolkit.AbstractTimeDependentSystem, a system for identifiability query
      • measured_quantities - array of input function in the form (name, expression)
      Output:
      • ODE object containing required data for identifiability assessment
      • conversion dictionary from the symbols in the input MTK model to the variable involved in the produced ODE object
      source
      StructuralIdentifiability.power_series_solution — Method
      power_series_solution(ode, param_values, initial_conditions, input_values, prec)
      Input:
      • ode - an ode to solve
      • param_values - parameter values, must be a dictionary mapping parameter to a value
      • initial_conditions - initial conditions of ode, must be a dictionary mapping state variable to a value
      • input_values - power series for the inputs presented as a dictionary variable => list of coefficients
      • prec - the precision of solutions
      Output:
      • computes a power series solution with precision prec presented as a dictionary variable => corresponding coordinate of the solution
      source
      StructuralIdentifiability.preprocess_ode — Method
      function preprocess_ode(de::ModelingToolkit.AbstractTimeDependentSystem, measured_quantities::Array{ModelingToolkit.Equation})
+function preprocess_ode(de::ModelingToolkit.AbstractTimeDependentSystem, measured_quantities::Array{SymbolicUtils.BasicSymbolic})
      Input:
      • de - ModelingToolkit.AbstractTimeDependentSystem, a system for identifiability query
      • measured_quantities - array of output functions (as equations of just functions)
      Output:
      • ODE object containing required data for identifiability assessment
      • conversion dictionary from the symbols in the input MTK model to the variable involved in the produced ODE object
      source
      StructuralIdentifiability.set_parameter_values — Method
      set_parameter_values(ode, param_values)
      Input:
      • ode - an ODE as above
      • param_values - values for (possibly, some of) the parameters as dictionary parameter => value
      Output:
      • new ode with the parameters in param_values plugged with the given numbers
      source
      StructuralIdentifiability.find_submodels — Method
      find_submodels(ode)
      The function calculates and returns all valid submodels given a system of ODEs.
      Input:
      • ode - an ODEs system to be studied
      Output: 
      • A list of submodels represented as ode objects
      Example:
      >ode = @ODEmodel(x1'(t) = x1(t)^2, 
                  x2'(t) = x1(t) * x2(t), 
                  y1(t) = x1(t), 
                  y2(t) = x2(t))
@@ -13,4 +13,4 @@
         
         x1'(t) = a(t)*x2(t)^2 + x1(t)
         y1(t) = x1(t)
-    ]
      source
      
+    ]
      source
      diff --git a/dev/utils/power_series_utils/index.html b/dev/utils/power_series_utils/index.html index 9b2faee08..c6b968d2a 100644 --- a/dev/utils/power_series_utils/index.html +++ b/dev/utils/power_series_utils/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Power Series Utilities

      StructuralIdentifiability.ps_matrix_homlinear_de — Method
      ps_matrix_homlinear_de(A, Y0, prec)

      Input:

      • A - a square matrix with entries in a univariate power series ring
      • Y0 - a square invertible matrix over the base field

      Output:

      • matrix Y such that Y' = AY up to precision of A - 1 and Y(0) = Y0
      source
      StructuralIdentifiability.ps_matrix_inv — Function
      ps_matrix_inv(M, prec)

      Input:

      • M - a square matrix with entries in a univariate power series ring it is assumed that M(0) is invertible and all entries having the same precision
      • prec - an integer, precision, if -1 then defaults to precision of M

      Output:

      • the inverse of M computed up to prec
      source
      StructuralIdentifiability.ps_matrix_linear_de — Method
      ps_matrix_linear_de(A, B, Y0, prec)

      Input:

      • A, B - square matrices with entries in a univariate power series ring
      • Y0 - a matrix over the base field with the rows number the same as A

      Output:

      • matrix Y such that Y' = AY + B up to precision of A - 1 and Y(0) = Y0
      source
      StructuralIdentifiability.ps_ode_solution — Method
      ps_ode_solution(equations, ic, inputs, prec)

      Input:

      • equations - a system of the form $A(x, u, mu)x' - B(x, u, mu) = 0$, where A is a generically nonsingular square matrix. Assumption: A is nonzero at zero
      • ic - initial conditions for x's (dictionary)
      • inputs - power series for inputs represented as arrays (dictionary)
      • prec - precision of the solution

      Output:

      • power series solution of the system
      source
      +
      Edit on GitHub

      Power Series Utilities

      StructuralIdentifiability.ps_matrix_homlinear_de — Method
      ps_matrix_homlinear_de(A, Y0, prec)

      Input:

      • A - a square matrix with entries in a univariate power series ring
      • Y0 - a square invertible matrix over the base field

      Output:

      • matrix Y such that Y' = AY up to precision of A - 1 and Y(0) = Y0
      source
      StructuralIdentifiability.ps_matrix_inv — Function
      ps_matrix_inv(M, prec)

      Input:

      • M - a square matrix with entries in a univariate power series ring it is assumed that M(0) is invertible and all entries having the same precision
      • prec - an integer, precision, if -1 then defaults to precision of M

      Output:

      • the inverse of M computed up to prec
      source
      StructuralIdentifiability.ps_matrix_linear_de — Method
      ps_matrix_linear_de(A, B, Y0, prec)

      Input:

      • A, B - square matrices with entries in a univariate power series ring
      • Y0 - a matrix over the base field with the rows number the same as A

      Output:

      • matrix Y such that Y' = AY + B up to precision of A - 1 and Y(0) = Y0
      source
      StructuralIdentifiability.ps_ode_solution — Method
      ps_ode_solution(equations, ic, inputs, prec)

      Input:

      • equations - a system of the form $A(x, u, mu)x' - B(x, u, mu) = 0$, where A is a generically nonsingular square matrix. Assumption: A is nonzero at zero
      • ic - initial conditions for x's (dictionary)
      • inputs - power series for inputs represented as arrays (dictionary)
      • prec - precision of the solution

      Output:

      • power series solution of the system
      source
      diff --git a/dev/utils/primality/index.html b/dev/utils/primality/index.html index 93125af7c..5e73e5c0a 100644 --- a/dev/utils/primality/index.html +++ b/dev/utils/primality/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Primality Checks

      StructuralIdentifiability.check_primality — Function
      check_primality(polys::Dict{fmpq_mpoly, fmpq_mpoly}, extra_relations::Array{fmpq_mpoly, 1})

      The function checks if the ideal generated by the polynomials and saturated at the leading coefficient with respect to the corresponding variables is prime over rationals.

      The extra_relations allows adding more polynomials to the generators (not affecting the saturation).

      source
      check_primality(polys::Dict{fmpq_mpoly, fmpq_mpoly})

      The function checks if the ideal generated by the polynomials and saturated at the leading coefficient with respect to the corresponding variables is prime over rationals.

      source
      +
      Edit on GitHub

      Primality Checks

      StructuralIdentifiability.check_primality — Function
      check_primality(polys::Dict{fmpq_mpoly, fmpq_mpoly}, extra_relations::Array{fmpq_mpoly, 1})

      The function checks if the ideal generated by the polynomials and saturated at the leading coefficient with respect to the corresponding variables is prime over rationals.

      The extra_relations allows adding more polynomials to the generators (not affecting the saturation).

      source
      check_primality(polys::Dict{fmpq_mpoly, fmpq_mpoly})

      The function checks if the ideal generated by the polynomials and saturated at the leading coefficient with respect to the corresponding variables is prime over rationals.

      source
      diff --git a/dev/utils/util/index.html b/dev/utils/util/index.html index 9b54f38a9..dc7c3faf7 100644 --- a/dev/utils/util/index.html +++ b/dev/utils/util/index.html @@ -3,5 +3,5 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Other Helpful Functions

      StructuralIdentifiability.dennums_to_fractions — Method
      dennums_to_fractions(dennums)

      Returns the field generators represented by fractions.

      Input: an array of arrays of polynomials, as in [[f1, f2, f3, ...], [g1, g2, g3, ...], ...]

      Output: an array of fractions [f2/f1, f3/f1, ..., g2/g1, g3/g1, ...]

      source
      StructuralIdentifiability.extract_coefficients — Method
      extract_coefficients(poly, variables)

      Input:

      • poly - multivariate polynomial
      • variables - a list of variables from the generators of the ring of p

      Output:

      • dictionary with keys being tuples of length lenght(variables) and values being polynomials in the variables other than those which are the coefficients at the corresponding monomials (in a smaller polynomial ring)
      source
      StructuralIdentifiability.fractions_to_dennums — Method
      fractions_to_dennums(fractions)

      Returns the field generators represented by lists of denominators and numerators.

      Input: an array of fractions, as in [f2/f1, f3/f1, ..., g2/g1, g3/g1, ...]

      Output: an array of arrays of polynomials, [[f1, f2, f3, ...], [g1, g2, g3, ...], ...]

      source
      StructuralIdentifiability.gen_tag_name — Function
      gen_tag_name(base; stop_words)
-gen_tag_names(n, base; stop_words)

      Generates a string which will not collide with the words in stop_words.

      Arguments

      • n: Generates a sequence of unique strings of length n
      • base: A string or a vector of strings, the base for the generated sequence
      • stop_words: A vector of strings, stop words
      source
      StructuralIdentifiability.make_substitution — Method
      make_substitution(f, var_sub, val_numer, val_denom)

      Substitute a variable in a polynomial with an expression

      Input:

      • f - the polynomial
      • var_sub - the variable to be substituted
      • var_numer - numerator of the substitution expression
      • var_denom - denominator of the substitution expression

      Output:

      • polynomial - result of substitution
      source
      StructuralIdentifiability.parent_ring_change — Method
      parent_ring_change(poly, new_ring)

      Converts a polynomial to a different polynomial ring Input

      • poly - a polynomial to be converted
      • new_ring - a polynomial ring such that every variable name appearing in poly appears among the generators

      Output:

      • a polynomial in new_ring “equal” to poly
      source
      StructuralIdentifiability.uncertain_factorization — Method
      uncertain_factorization(f)

      Input:

      • f - polynomial with rational coefficients

      Output:

      • list of pairs (div, certainty) where
        • div's are divisors of f such that f is their product with certain powers
        • if certainty is true, div is $Q$-irreducible
      source
      +
      Edit on GitHub

      Other Helpful Functions

      StructuralIdentifiability.dennums_to_fractions — Method
      dennums_to_fractions(dennums)

      Returns the field generators represented by fractions.

      Input: an array of arrays of polynomials, as in [[f1, f2, f3, ...], [g1, g2, g3, ...], ...]

      Output: an array of fractions [f2/f1, f3/f1, ..., g2/g1, g3/g1, ...]

      source
      StructuralIdentifiability.extract_coefficients — Method
      extract_coefficients(poly, variables)

      Input:

      • poly - multivariate polynomial
      • variables - a list of variables from the generators of the ring of p

      Output:

      • dictionary with keys being tuples of length lenght(variables) and values being polynomials in the variables other than those which are the coefficients at the corresponding monomials (in a smaller polynomial ring)
      source
      StructuralIdentifiability.fractions_to_dennums — Method
      fractions_to_dennums(fractions)

      Returns the field generators represented by lists of denominators and numerators.

      Input: an array of fractions, as in [f2/f1, f3/f1, ..., g2/g1, g3/g1, ...]

      Output: an array of arrays of polynomials, [[f1, f2, f3, ...], [g1, g2, g3, ...], ...]

      source
      StructuralIdentifiability.gen_tag_name — Function
      gen_tag_name(base; stop_words)
+gen_tag_names(n, base; stop_words)

      Generates a string which will not collide with the words in stop_words.

      Arguments

      • n: Generates a sequence of unique strings of length n
      • base: A string or a vector of strings, the base for the generated sequence
      • stop_words: A vector of strings, stop words
      source
      StructuralIdentifiability.make_substitution — Method
      make_substitution(f, var_sub, val_numer, val_denom)

      Substitute a variable in a polynomial with an expression

      Input:

      • f - the polynomial
      • var_sub - the variable to be substituted
      • var_numer - numerator of the substitution expression
      • var_denom - denominator of the substitution expression

      Output:

      • polynomial - result of substitution
      source
      StructuralIdentifiability.parent_ring_change — Method
      parent_ring_change(poly, new_ring)

      Converts a polynomial to a different polynomial ring Input

      • poly - a polynomial to be converted
      • new_ring - a polynomial ring such that every variable name appearing in poly appears among the generators

      Output:

      • a polynomial in new_ring “equal” to poly
      source
      StructuralIdentifiability.uncertain_factorization — Method
      uncertain_factorization(f)

      Input:

      • f - polynomial with rational coefficients

      Output:

      • list of pairs (div, certainty) where
        • div's are divisors of f such that f is their product with certain powers
        • if certainty is true, div is $Q$-irreducible
      source
      diff --git a/dev/utils/wronskian/index.html b/dev/utils/wronskian/index.html index 324d8e4f9..d6b66eee2 100644 --- a/dev/utils/wronskian/index.html +++ b/dev/utils/wronskian/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Wronskian Tools

      StructuralIdentifiability.get_max_below — Method
      get_max_below(t, vect)

      Input:

      • t - a trie with exponent vectors
      • vect - yet another exponent vector

      Output:

      • a pair (d, v) where v is a vector in the trie which is componentwise ≤ vect and the difference d is as small as possible
      source
      StructuralIdentifiability.massive_eval — Method
      massive_eval(polys, eval_dict)

      Input:

      • polys - a list of polynomials
      • eval_dict - dictionary from variables to the values. Missing values are treated as zeroes

      Output:

      • a list of values of the polynomials

      Evaluates a list of polynomials at a point. Assumes that multiplications are relatively expensive (like in truncated power series) so all the monomials are precomputed first and the values of monomials of lower degree are cached and used to compute the values of the monomials of higher degree

      source
      StructuralIdentifiability.monomial_compress — Method
      monomial_compress(io_equation, ode)

      Compresses an input-output equation for the rank computation Input:

      • io_equation - input-output equation
      • ode - the corresponding ODE model

      Output:

      • pair (coeffs, terms) such that:
        • sum of coeffs[i] * terms[i] = io_equation
        • coeffs involve only parameters, terms involve only inputs and outputs
        • length of the representation is the smallest possible
      source
      StructuralIdentifiability.wronskian — Method
      wronskian(io_equations, ode)

      Input:

      • io_equations - a set of io-equations in the form of the Dict as returned by find_ioequations
      • ode - the ODE object

      Output:

      • a list of Wronskians evaluated at a point modulo prime

      Computes the Wronskians of io_equations

      source
      +
      Edit on GitHub

      Wronskian Tools

      StructuralIdentifiability.get_max_below — Method
      get_max_below(t, vect)

      Input:

      • t - a trie with exponent vectors
      • vect - yet another exponent vector

      Output:

      • a pair (d, v) where v is a vector in the trie which is componentwise ≤ vect and the difference d is as small as possible
      source
      StructuralIdentifiability.massive_eval — Method
      massive_eval(polys, eval_dict)

      Input:

      • polys - a list of polynomials
      • eval_dict - dictionary from variables to the values. Missing values are treated as zeroes

      Output:

      • a list of values of the polynomials

      Evaluates a list of polynomials at a point. Assumes that multiplications are relatively expensive (like in truncated power series) so all the monomials are precomputed first and the values of monomials of lower degree are cached and used to compute the values of the monomials of higher degree

      source
      StructuralIdentifiability.monomial_compress — Method
      monomial_compress(io_equation, ode)

      Compresses an input-output equation for the rank computation Input:

      • io_equation - input-output equation
      • ode - the corresponding ODE model

      Output:

      • pair (coeffs, terms) such that:
        • sum of coeffs[i] * terms[i] = io_equation
        • coeffs involve only parameters, terms involve only inputs and outputs
        • length of the representation is the smallest possible
      source
      StructuralIdentifiability.wronskian — Method
      wronskian(io_equations, ode)

      Input:

      • io_equations - a set of io-equations in the form of the Dict as returned by find_ioequations
      • ode - the ODE object

      Output:

      • a list of Wronskians evaluated at a point modulo prime

      Computes the Wronskians of io_equations

      source