You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
At the moment all the algorithms in the package require input models to have rational right-hand side (that is, the rhs must be a quotient of two polynomials). One way to lift this limitation is to transform the system into a rational or even polynomial one. It is know that this can be done by introducing new variables (detailed algorithm with implementation in Python).
However, there is an important subtlety. Consider an example:
x'(t) = a * e^x(t)
y(t) = x(t)
The standard idea would be to introduce a new variable z(t) := e^x(t), this will recast the system into
x'(t) = a * z(t)
z'(t) = a * z(t)^2
y(t) = x(t)
In the latter model, parameter a will be non identifiable. However, if we add a different new variable w'(t) := a * e^x(t), the system will become
x'(t) = w(t)
w'(t) = w(t)^2
y(t) = x(t)
Although a has disappeared from the system, knowing x(0) and w(0) is sufficient to find it. Since these initial conditions are identifiable (and they are), a is in fact identifiable as well.
The difference between the two transformations above is that the former increases the number of degrees of freedom in the system and the latter does not. Because of this, the former yield an incorrect result. Therefore, the overall goal would be to have a procedure for transforming the model into a rational one while keeping the number of degrees of freedom the same. For practical examples of "careful" transformation, see sections A.2 and A.3 in this paper.
One plausible approach is:
Implement any reasonable procedure for transforming a system into a rational one (e.g. adding all non rational terms as new variables until we are done). This may increase the number of degrees of freedom.
Reduce back the number of degrees of freedom by applying an algorithm for finding scaling transformation from this paper.
This approach will work nicely for the example above. Implementing any of the two steps above separately would be a nice and welcome contribution on its own.
UPD: A simpler procedure can be established for parameters only #190
The text was updated successfully, but these errors were encountered:
At the moment all the algorithms in the package require input models to have rational right-hand side (that is, the rhs must be a quotient of two polynomials). One way to lift this limitation is to transform the system into a rational or even polynomial one. It is know that this can be done by introducing new variables (detailed algorithm with implementation in Python).
However, there is an important subtlety. Consider an example:
The standard idea would be to introduce a new variable
z(t) := e^x(t)
, this will recast the system intoIn the latter model, parameter
a
will be non identifiable. However, if we add a different new variablew'(t) := a * e^x(t)
, the system will becomeAlthough
a
has disappeared from the system, knowingx(0)
andw(0)
is sufficient to find it. Since these initial conditions are identifiable (and they are),a
is in fact identifiable as well.The difference between the two transformations above is that the former increases the number of degrees of freedom in the system and the latter does not. Because of this, the former yield an incorrect result. Therefore, the overall goal would be to have a procedure for transforming the model into a rational one while keeping the number of degrees of freedom the same. For practical examples of "careful" transformation, see sections A.2 and A.3 in this paper.
One plausible approach is:
This approach will work nicely for the example above. Implementing any of the two steps above separately would be a nice and welcome contribution on its own.
UPD: A simpler procedure can be established for parameters only #190
The text was updated successfully, but these errors were encountered: