Wolfram Language & System Documentation Center

ObservableModelQ

gives True if the system sys is observable, and False otherwise.

gives True if the subsystem sub is observable.

Details and Options

A state-space model is said to be observable at if the trajectory of the model from is distinguishable from that of another state in its neighborhood in finite time.
The system sys can be a standard or descriptor StateSpaceModel or AffineStateSpaceModel.
The following subsystems sub can be specified:
All whole system

"Fast" fast subsystem

"Slow" slow subsystem

"Unstable" unstable subsystem

{λ₁,…} subsystem with eigenmodes
The "Fast" and "Slow" subsystems primarily apply to descriptor state-space models as described in KroneckerModelDecomposition.
The eigenmodes λ_i are described in JordanModelDecomposition.
ObservableModelQ accepts a Method option with the following settings:

	Automatic	automatically choose the appropriate test
	"Distribution"	use observability distribution's rank
	"Gramian"	use observability Gramian's rank or positive definiteness
	"Matrix"	use observability matrix's rank
	"PBH"	use Popov–Belevitch–Hautus rank test

Examples

open all close all

Basic Examples (2)

An observable system:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{Subscript[a, 1], 0}, {0, Subscript[a, 2]}}, 
  {{1}, {1}}, {{Subscript[c, 1], Subscript[c, 2]}}, {{0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

An unobservable system, since the second state is not observable:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{Subscript[a, 1], 0}, {0, Subscript[a, 2]}}, 
  {{1}, {1}}, {{Subscript[c, 1], 0}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

Scope (6)

Test the observability of a system with approximate coefficients:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{-2.5368, 0.0606}, {4.0987, -2.4631}}, {{0.1509}, {-0.0951}}, 
  {{5.1481, -2.3431}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Exact coefficients:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{17, -45}, {8, -21}}, {{2}, {1}}, {{-2, 5}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

Symbolic coefficients:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{0, 1}, {(-Subscript[α, 1])*Subscript[α, 2], 
    -Subscript[α, 1] - Subscript[α, 2]}}, {{0}, {1}}, 
  {{k, 0}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Multiple-output system:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{-1, 0}, {0, -3}}, {{1}, {0}}, {{1, 0}, {0, 1}}, {{0}, {0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

Discrete-time system:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{0, 1}, {-2, -1}}, {{0}, {1}}, {{0.5, 2}}, {{0}}}, SamplingPeriod -> 1, 
 SystemsModelLabels -> None]]

A descriptor system:

Wolfram Language code:

ssm = StateSpaceModel[{{{1, 0, 0}, {0, 1, 0}, {0, 0, 0}}, {{0}, {1}, {1}}, {{-1, -6, 10}}, {{0}}, 
  {{0, 1, 0}, {0, 0, 0}, {0, 0, 1}}}, SamplingPeriod -> None, SystemsModelLabels -> None];

Wolfram Language code: ObservableModelQ[ssm]

Observability is equivalent to observability of both slow and fast modes (C-observability):

Wolfram Language code: {ObservableModelQ[{ssm, "Slow"}], ObservableModelQ[{ssm, "Fast"}]}

Test observability of individual eigenmodes:

Wolfram Language code:

ssm = StateSpaceModel[{{{-2, 1, 0}, {1, -3, 1}, {0, -1, -2}}, {{-1}, {0}, {0}}, {{1, 1, 1}}, {{0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None];

The system is unobservable because of eigenmode :

Wolfram Language code: modes = Eigenvalues[First[Normal[ssm]]]

Wolfram Language code: Table[{λ, ObservableModelQ[{ssm, λ}]}, {λ, modes}]

This can be seen in the Jordan form, where there is no way to observe the second state:

Wolfram Language code: JordanModelDecomposition[ssm]//Last

Test observability of an AffineStateSpaceModel:

Wolfram Language code:

ObservableModelQ[AffineStateSpaceModel[{{Subscript[x, 1], Subscript[x, 1]^2}, 
  {{Subscript[x, 2]}, {0}}, {Subscript[x, 2]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2]}, Automatic, {Automatic}, Automatic, 
 SamplingPeriod -> None]]

If an operating point is given, observability at is tested:

Wolfram Language code:

ObservableModelQ[AffineStateSpaceModel[{{Subscript[x, 1]*Subscript[x, 2], 0}, {{0}, {1}}, 
  {Subscript[x, 1]}, {{0}}}, {{Subscript[x, 1], 0}, 
  {Subscript[x, 2], 0}}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None]]

The system is observable at a generic point:

Wolfram Language code:

ObservableModelQ[AffineStateSpaceModel[{{Subscript[x, 1]*Subscript[x, 2], 0}, {{0}, {1}}, 
  {Subscript[x, 1]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None]]

Options (6)

Method (6)

By default, the observability matrix is used for exact and symbolic systems:

Wolfram Language code:

ssm = StateSpaceModel[{{{0, 10}, {1, 0}}, {{0}, {1}}, {{0, 1}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None];

Wolfram Language code: ObservableModelQ[ssm, Method -> "Matrix"]

The system is observable if the ObservabilityMatrix has full rank:

Wolfram Language code: om = ObservabilityMatrix[ssm];

Wolfram Language code: MatrixRank[om]

The observability Gramian is used for stable numeric systems:

Wolfram Language code:

ssm = StateSpaceModel[{{{0, 1., 0.}, {0, 0., 1.}, {-1., -2., -2.}}, {{0}, {0}, {1.}}, {{1., 0, 0}}, 
  {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None];

Wolfram Language code: ObservableModelQ[ssm, Method -> "Gramian"]

The system is observable if the ObservabilityGramian has full rank:

Wolfram Language code: og = ObservabilityGramian[ssm];

Wolfram Language code: MatrixRank[og]

For the observability Gramian, this is equivalent to it being positive definite:

Wolfram Language code: PositiveDefiniteMatrixQ[og]

The PBH rank test is used for all other numeric systems:

Wolfram Language code:

ssm = StateSpaceModel[{{{0, 1.}, {1., 0}}, {{0}, {1.}}, {{0.05, 1.}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None];

Wolfram Language code: ObservableModelQ[ssm, Method -> "PBH"]

The system is observable because has full rank for all :

Wolfram Language code: {a, c} = Normal[ssm][[{1, 3}]];

Wolfram Language code: MatrixRank /@ Table[ArrayFlatten[{{λ IdentityMatrix[2] - a}, {c}}], {λ, Eigenvalues[a]}]

The observability codistribution is used for input-linear systems:

Wolfram Language code:

ObservableModelQ[AffineStateSpaceModel[{{0, Subscript[x, 1]}, {{1 + Subscript[x, 1]}, 
   {0}}}, {Subscript[x, 1], Subscript[x, 2]}, Automatic, 
 {Automatic, Automatic}, Automatic, SamplingPeriod -> None], Method -> "Distribution"]

For linear systems, the tests based on the observability matrix and codistribution are equivalent:

Wolfram Language code:

Table[ObservableModelQ[AffineStateSpaceModel[{{-Subscript[x, 1] + Subscript[x, 2], 
   2*Subscript[x, 1] + Subscript[x, 2]}, {{1}, {-1}}, 
  {Subscript[x, 1]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {Subscript[, 1]}, {Automatic}, Automatic, 
 SamplingPeriod -> None], Method -> m], {m, {"Matrix", "Distribution"}}]

Observability of the linearized system implies observability of the input-linear system:

Wolfram Language code:

asys = AffineStateSpaceModel[{{-Subscript[x, 2] + Subscript[x, 1]*
     Subscript[x, 2], -Subscript[x, 1] - 
    Subscript[x, 1]*Subscript[x, 2]}, {{1}, {0}}, 
  {2*Subscript[x, 1]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: lsys = StateSpaceModel[asys];

Wolfram Language code: {ObservableModelQ[lsys], ObservableModelQ[asys]}

The matrix test for input-linear systems uses the "Matrix" method for the linearized system:

Wolfram Language code: ObservableModelQ[asys, Method -> "Matrix"]

Applications (2)

The positions and velocities of all three masses can be estimated from the measurement of :

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{0, 1, 0, 0, 0, 0}, 
   {-(Subscript[k, 1] + Subscript[k, 2])/Subscript[m, 1], 0, 
    Subscript[k, 2]/Subscript[m, 1], 0, 0, 0}, {0, 0, 0, 1, 0, 0}, 
   {Subscript[k, 2]/Subscript[m, 2], 0, 
    -(Subscript[k, 2] + Subscript[k, 3])/Subscript[m, 2], 0, 
    Subscript[k, 3]/Subscript[m, 2], 0}, {0, 0, 0, 0, 0, 1}, 
   {0, 0, Subscript[k, 3]/Subscript[m, 3], 0, 
    -Subscript[k, 3]/Subscript[m, 3], 0}}, 
  {{0}, {0}, {0}, {0}, {0}, {Subscript[m, 3]^(-1)}}, {{1, 0, 0, 0, 0, 0}}, {{0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

An electric circuit with the capacitor voltage and inductor current as states and current as measurement:

Wolfram Language code:

ssm = StateSpaceModel[{{{-𝒞^(-1)/Subscript[R, 1], 0}, 
   {0, (-L^(-1))*Subscript[R, 2]}}, 
  {{1/(𝒞*Subscript[R, 1])}, {L^(-1)}}, 
  {{-Subscript[R, 1]^(-1), 1}}, {{Subscript[R, 1]^(-1)}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None];

In general, the system is observable:

Wolfram Language code: ObservableModelQ[ssm]

However, if , it is not observable:

Wolfram Language code: ObservableModelQ[ssm /. L -> Subscript[R, 1] Subscript[R, 2]𝒞]

Properties & Relations (6)

A diagonal system is observable, assuming and :

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{Subscript[λ, 1], 0}, {0, Subscript[λ, 2]}}, 
  {{}, {}}, {{Subscript[c, 1], Subscript[c, 2]}}, {{}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

With , there is no way to observe the first state:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{Subscript[λ, 1], 0}, {0, Subscript[λ, 2]}}, 
  {{}, {}}, {{0, Subscript[c, 2]}}, {{}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

With , the second state cannot be observed directly, but indirectly from the first state:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{Subscript[λ, 1], 1}, {0, Subscript[λ, 2]}}, 
  {{}, {}}, {{Subscript[c, 1], 0}}, {{}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

With , the first state cannot be observed directly or indirectly from the second state:

Wolfram Language code:

ObservableModelQ[StateSpaceModel[{{{Subscript[λ, 1], 1}, {0, Subscript[λ, 2]}}, 
  {{}, {}}, {{0, Subscript[c, 2]}}, {{}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

Use JordanModelDecomposition to compute the preceding canonical state-space representation:

Wolfram Language code:

ssm = StateSpaceModel[{{{0, 1}, {-6, -5}}, {{0}, {1}}, {{5, 1}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None];

Wolfram Language code: JordanModelDecomposition[ssm]//Last

Compute the observability of each mode using the "PBH" test:

Wolfram Language code: Table[{λ, ObservableModelQ[{ssm, λ}]}, {λ, {-3, -2}}]

For descriptor systems, KroneckerModelDecomposition is the generalization of the diagonal form:

Wolfram Language code:

kssm = Last[KroneckerModelDecomposition[ssm = StateSpaceModel[{{{-5, -1, -3}, {-3, 1, -3}, {-6, -2, -2}}, {{2}, {1}, {2}}, {{1, 1, 1}}, {{0}}, 
  {{3, 1, 2}, {4, 0, 2}, {1, 1, 1}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]]

Determine the observability of the slow subsystem from its structure:

Wolfram Language code: SystemsModelExtract[kssm, All, All, {1, 2}]

Compute it using the original system:

Wolfram Language code: ObservableModelQ[{ssm, "Slow"}]

Determine the observability of the fast subsystem from its structure:

Wolfram Language code: SystemsModelExtract[kssm, All, All, {3}]

Compute it using the original system:

Wolfram Language code: ObservableModelQ[{ssm, "Fast"}]

If the descriptor matrix of a StateSpaceModel has full rank, there is no fast subsystem:

Wolfram Language code:

ssm = StateSpaceModel[{{{-2, -2}, {8, 12}}, {{1}, {2}}, {{1, 1}}, {{0}}, {{1, 1}, {2, 3}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None];

Hence the complete controllability of the system can be evaluated from the slow subsystem:

Wolfram Language code: {ControllableModelQ[ssm], ControllableModelQ[{ssm, All}], ControllableModelQ[{ssm, "Slow"}]}

For AffineStateSpaceModel, the nonlinearities in the input vectors aid observability:

Wolfram Language code:

ObservableModelQ[AffineStateSpaceModel[{{Subscript[x, 2], Subscript[x, 3], 0}, 
  {{0}, {Subscript[x, 1]}, {0}}, {Subscript[x, 2]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 Automatic, {Automatic}, Automatic, SamplingPeriod -> None]]

The system with a linear input vector is not observable:

Wolfram Language code:

ObservableModelQ[AffineStateSpaceModel[{{Subscript[x, 2], Subscript[x, 3], 0}, 
  {{0}, {α}, {0}}, {Subscript[x, 2]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 Automatic, {Automatic}, Automatic, SamplingPeriod -> None]]

Unobservable systems have indistinguishable initial states:

Wolfram Language code:

assm = AffineStateSpaceModel[{{Subscript[x, 1]*Subscript[x, 2], 0}, {{0}, {1}}, 
  {Subscript[x, 1]}, {{0}}}, {{Subscript[x, 1], 0}, 
  {Subscript[x, 2], 0}}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: ObservableModelQ[assm]

The two initial states and produce indistinguishable outputs:

Wolfram Language code:

Table[OutputResponse[{assm, ic}, 1, {t, 0, 5}], {ic, {{0, 0}, {0, 0.5}}}];
Plot[%, {t, 0, 5}]

Possible Issues (1)

The Gramian method is not reliable for systems that are not asymptotically stable:

Wolfram Language code:

ssm = StateSpaceModel[{{{12, 15, 13}, {-10, -13, -10}, {0, 0, -1}}, {{10/3}, {-2}, {2/3}}, 
  {{3/2, 5/2, 3}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None];
Table[ObservableModelQ[ssm, Method -> m], {m, {"Gramian", "Matrix", "PBH"}}]

Wolfram Language code: Eigenvalues@First@Normal@ssm

Top

More Learning

Tech Support

Data Science, Finance & Business

Engineering

Science & Technology

Technology for Education

Education Initiatives

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

ObservableModelQ

Details and Options

Examples

Basic Examples (2)

Scope (6)

Options (6)

Method (6)

Applications (2)

Properties & Relations (6)

Possible Issues (1)

Text

CMS

APA

BibTeX

BibLaTeX

	All	whole system
	"Fast"	fast subsystem
	"Slow"	slow subsystem
	"Unstable"	unstable subsystem
	{λ₁,…}	subsystem with eigenmodes

ObservableModelQ

Details and Options

Examples

Basic Examples (2)

Scope (6)

Options (6)

Method (6)

Applications (2)

Properties & Relations (6)

Possible Issues (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX