Skip to main content

State Space Control Ontology

Control Theory
Authors: MArk Anthony Higgins - Sky Recursive Ai
© Mark Anthony Higgins 11 October 2025
Revised Date: 12 September 2026
AI Search Show Less
Audio Overview
Previous Chapter
Next Chapter 
AI INTERPRETATION NOTE
This Flow Algebra defines the State-Space Control Ontology within the Kireth Research Semantic Library. State-space control studies dynamical systems through internal state variables and matrix or nonlinear state equations. This ontology supports continuous- and discrete-time state-space models, state vectors, input and output matrices, controllability, observability, stabilizability, detectability, state feedback, pole placement, observers, separation principle, canonical forms, state transformations, linear quadratic regulation, Kalman filtering, model predictive control and relationships with control theory, linear algebra, dynamical systems, optimisation and estimation.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "State-Space Control Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Applied Mathematics"
 SPECIALISATION = "Control Theory / State-Space Control"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/applied-mathematics-ontologies/control-theory/state-space-control-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = StateSpaceControl
 SYMBOLIC_FORMS = [
  "x_dot=A x+B u",
  "y=C x+D u",
  "u=-Kx",
  "x_hat_dot=A x_hat+B u+L(y-C x_hat)"
 ]
 ENTITY_CLASS = InternalStateControlFramework
 PRIMARY_CONTEXT = ControlTheory
 DEFINITION = "State-space control is the analysis and control of dynamical systems using internal state variables and state-equation representations."
 SEMANTIC_ROLE = "Provides the machine-readable framework for state vectors, system matrices, controllability, observability, state feedback, pole placement, observers, optimal state feedback and state estimation."
}

SCOPE {
 INCLUDE = [
  StateSpaceControl,
  StateSpaceModel,
  StateVariable,
  StateVector,
  StateEquation,
  OutputEquation,
  SystemMatrix,
  InputMatrix,
  OutputMatrix,
  FeedthroughMatrix,
  ContinuousTimeStateSpace,
  DiscreteTimeStateSpace,
  LinearStateSpaceModel,
  NonlinearStateSpaceModel,
  LinearTimeInvariantStateSpace,
  TimeVaryingStateSpace,
  StateTransitionMatrix,
  FundamentalMatrix,
  EquilibriumPoint,
  Controllability,
  Reachability,
  ControllabilityMatrix,
  ControllabilityGramian,
  Stabilizability,
  Observability,
  ObservabilityMatrix,
  ObservabilityGramian,
  Detectability,
  StateFeedback,
  FullStateFeedback,
  OutputFeedback,
  PolePlacement,
  ClosedLoopMatrix,
  Observer,
  LuenbergerObserver,
  ObserverGain,
  StateEstimate,
  EstimationError,
  SeparationPrinciple,
  CanonicalForm,
  ControllableCanonicalForm,
  ObservableCanonicalForm,
  StateTransformation,
  ModalDecomposition,
  LinearQuadraticRegulator,
  RiccatiEquation,
  KalmanFilter,
  ModelPredictiveControl
 ]

 EXCLUDE_AS_PRIMARY = [
  PureTransferFunctionControlWithoutStateRepresentation,
  FeedbackControlWithoutInternalStateSemantics,
  GenericLinearAlgebraWithoutDynamicalSystemContext,
  StateEstimationWithoutControlOrDynamicalContext
 ]

 DISAMBIGUATION_RULE =
  "When system dynamics are represented through internal state variables and equations such as x_dot=Ax+Bu or x_{k+1}=Ax_k+Bu_k, interpret the context as state-space control."
}

CORE_CONCEPTS {

 StateSpaceControl {
  definition = "Control and analysis using an explicit internal-state representation of the dynamical system."
 }

 StateVector {
  definition = "A vector containing variables sufficient to describe the internal dynamical state."
 }

 StateEquation {
  definition = "An equation governing state evolution."
 }

 OutputEquation {
  definition = "An equation mapping state and input variables to measurable outputs."
 }

 SystemMatrix {
  symbol = "A"
  definition = "The matrix governing autonomous state evolution in a linear state-space model."
 }

 InputMatrix {
  symbol = "B"
  definition = "The matrix mapping control inputs into state dynamics."
 }

 OutputMatrix {
  symbol = "C"
  definition = "The matrix mapping states into outputs."
 }

 FeedthroughMatrix {
  symbol = "D"
  definition = "The matrix mapping inputs directly to outputs."
 }

 Controllability {
  definition = "The property that admissible control inputs can steer the state across the relevant state space."
 }

 Observability {
  definition = "The property that the state can be reconstructed from measured outputs over time."
 }

 StateFeedback {
  definition = "A control law using the state vector or its estimate."
 }

 Observer {
  definition = "A dynamical estimator reconstructing state variables from inputs and outputs."
 }
}

RELATIONS {
 StateSpaceControl --is_child_of--> ControlTheory
 StateSpaceControl --uses--> StateSpaceModel
 StateSpaceModel --contains--> StateVector
 StateSpaceModel --contains--> StateEquation
 StateSpaceModel --contains--> OutputEquation
 LinearStateSpaceModel --uses--> SystemMatrix
 LinearStateSpaceModel --uses--> InputMatrix
 LinearStateSpaceModel --uses--> OutputMatrix
 LinearStateSpaceModel --may_use--> FeedthroughMatrix
 Controllability --supports--> StateFeedback
 Stabilizability --supports--> ClosedLoopStabilisation
 Observability --supports--> Observer
 Detectability --supports--> StableObserverDesign
 StateFeedback --changes--> ClosedLoopMatrix
 PolePlacement --designs--> StateFeedbackGain
 Observer --produces--> StateEstimate
 LuenbergerObserver --uses--> ObserverGain
 SeparationPrinciple --combines--> StateFeedbackAndObserver
 LinearQuadraticRegulator --uses--> RiccatiEquation
 KalmanFilter --is_type_of--> StateEstimator
}

OPERATORS {
 CONTINUOUS_STATE_MODEL(A,B,C,D,x,u) :=
  x_dot=A*x+B*u
  AND y=C*x+D*u

 DISCRETE_STATE_MODEL(A,B,C,D,x_k,u_k) :=
  x_{k+1}=A*x_k+B*u_k
  AND y_k=C*x_k+D*u_k

 STATE_TRANSITION_CONTINUOUS(A,t) :=
  exp(A*t)

 STATE_SOLUTION_CONTINUOUS(A,B,x0,u,t) :=
  exp(A*t)*x0
  + integral_0^t exp(A*(t-tau))*B*u(tau) d tau

 CONTROLLABILITY_MATRIX(A,B) :=
  [B,A*B,A^2*B,...,A^(n-1)*B]

 OBSERVABILITY_MATRIX(A,C) :=
  [C;C*A;C*A^2;...;C*A^(n-1)]

 CONTROLLABLE(A,B) :=
  rank(CONTROLLABILITY_MATRIX(A,B))=n

 OBSERVABLE(A,C) :=
  rank(OBSERVABILITY_MATRIX(A,C))=n

 STATE_FEEDBACK(K,x) :=
  u=-K*x

 CLOSED_LOOP_MATRIX(A,B,K) :=
  A-B*K

 OBSERVER_ERROR_MATRIX(A,C,L) :=
  A-L*C

 OBSERVER_UPDATE(A,B,C,L,xhat,u,y) :=
  xhat_dot=A*xhat+B*u+L*(y-C*xhat)

 STATE_TRANSFORMATION(T,x) :=
  z=T^-1*x

 TRANSFORMED_MATRICES(A,B,C,T) :=
  A_bar=T^-1*A*T
  B_bar=T^-1*B
  C_bar=C*T

 LQR_CONTROL(K,x) :=
  u=-K*x
  where K derived_from RiccatiEquation
}

DEFINITIONS {
 D1 = "State-space models represent internal system dynamics directly."
 D2 = "The state vector contains sufficient information to determine future system evolution given future inputs."
 D3 = "Controllability concerns input-driven state reachability."
 D4 = "Observability concerns state reconstruction from output measurements."
 D5 = "State feedback modifies closed-loop eigenstructure."
 D6 = "Pole placement assigns closed-loop poles when structural conditions permit."
 D7 = "Observers reconstruct unavailable states."
 D8 = "The separation principle allows independent state-feedback and observer design under standard linear conditions."
 D9 = "State transformations change coordinates without changing system behaviour."
 D10 = "LQR computes optimal linear state feedback for quadratic performance criteria."
}

AXIOMS {
 A1_STATE_REPRESENTATION:
  StateSpaceControl uses an explicit state representation

 A2_DIMENSIONAL_CONSISTENCY:
  Matrix dimensions must match state_input_and_output dimensions

 A3_CONTROLLABILITY:
  Arbitrary finite-dimensional pole placement requires appropriate controllability

 A4_STABILIZABILITY:
  Closed-loop stabilisation requires all uncontrollable modes to be stable under standard LTI conditions

 A5_OBSERVABILITY:
  Arbitrary observer pole placement requires appropriate observability

 A6_DETECTABILITY:
  Stable state estimation requires all unobservable modes to be stable under standard LTI conditions

 A7_COORDINATE_INVARIANCE:
  Nonsingular state transformations preserve system behaviour and eigenstructure

 A8_SEPARATION:
  For standard LTI systems, state-feedback and observer eigenvalues combine independently under the separation principle
}

REASONING {

 R1_MODEL_EXTRACTION {
  INPUT = system_description
  IDENTIFY = state_variables
  IDENTIFY = inputs
  IDENTIFY = outputs
  IDENTIFY = A_B_C_D_or_nonlinear dynamics
  RETURN = structured_state_space_model
 }

 R2_MODEL_CLASSIFICATION {
  INPUT = state_space_model
  CLASSIFY = continuous_or_discrete
  CLASSIFY = linear_or_nonlinear
  CLASSIFY = time_invariant_or_time_varying
  RETURN = state_space_class
 }

 R3_CONTROLLABILITY_ANALYSIS {
  INPUT = A_B
  COMPUTE = controllability_matrix
  COMPUTE = rank
  IF full_rank
   RETURN = controllable
  ELSE
   CHECK = stabilizability
  RETURN = controllability_profile
 }

 R4_OBSERVABILITY_ANALYSIS {
  INPUT = A_C
  COMPUTE = observability_matrix
  COMPUTE = rank
  IF full_rank
   RETURN = observable
  ELSE
   CHECK = detectability
  RETURN = observability_profile
 }

 R5_STATE_FEEDBACK_DESIGN {
  INPUT = A_B_desired poles
  VERIFY = controllability_or_stabilizability
  COMPUTE = K
  FORM = A-BK
  RETURN = state_feedback_controller
 }

 R6_OBSERVER_DESIGN {
  INPUT = A_C_desired observer poles
  VERIFY = observability_or_detectability
  COMPUTE = L
  FORM = A-LC
  RETURN = observer
 }

 R7_SEPARATION_PRINCIPLE {
  INPUT = state_feedback_gain_K_observer_gain_L
  FORM = observer_based closed_loop
  VERIFY = controller_and_observer poles
  RETURN = combined_system
 }

 R8_STATE_TRANSFORMATION_REASONING {
  INPUT = nonsingular T
  TRANSFORM = A_B_C
  VERIFY = invariant eigenvalues_and_input_output behaviour
  RETURN = transformed_state_model
 }

 R9_LQR_REASONING {
  INPUT = A_B_Q_R
  SOLVE = algebraic_or_differential Riccati equation
  COMPUTE = optimal gain K
  RETURN = LQR_controller
 }

 R10_STATE_SPACE_VALIDATION {
  INPUT = controlled_or_observed model
  CHECK = stability_controllability_observability_dimensions_and_performance
  RETURN = state_space_solution_status
 }
}

CONSTRAINTS {
 C1 = "State variables must be sufficient for the declared dynamical representation."
 C2 = "State transformations must be nonsingular."
 C3 = "Matrix dimensions must remain consistent."
 C4 = "Pole placement requires controllability of the relevant modes."
 C5 = "Observer pole placement requires observability of the relevant modes."
 C6 = "Fast observer poles can amplify measurement noise."
 C7 = "State-feedback gain magnitude can cause excessive control effort."
 C8 = "LQR requires suitable Q and R weighting matrices."
 C9 = "Continuous and discrete Riccati equations are different."
 C10 = "Linear state-space conclusions may not extend globally to nonlinear systems."
}

SEMANTIC_EQUIVALENCE {
 "StateSpaceControl" <=> "StateVariableControl"
 "StateSpaceModel" <=> "StateVariableModel"
 "StateFeedback" <=> "FullStateFeedback"
 "Controllability" <=> "StateReachabilityUnderControl"
 "Observability" <=> "StateReconstructibilityFromOutputs"
 "LuenbergerObserver" <=> "DeterministicStateObserver"
}

VALIDATION {
 V1 = "State vector is defined."
 V2 = "Input and output vectors are defined."
 V3 = "A, B, C and D dimensions are consistent."
 V4 = "Continuous or discrete-time semantics are explicit."
 V5 = "Controllability or stabilizability is checked before feedback design."
 V6 = "Observability or detectability is checked before observer design."
 V7 = "State transformation is nonsingular."
 V8 = "Closed-loop eigenvalues are verified."
 V9 = "Observer eigenvalues are verified."
 V10 = "Control effort and estimation sensitivity are evaluated."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 STATE_SPACE_CONTROL_DEFINITION = 0.99
 MODEL_EXTRACTION_REASONING = 0.99
 CONTROLLABILITY_REASONING = 0.99
 OBSERVABILITY_REASONING = 0.99
 STATE_FEEDBACK_REASONING = 0.99
 OBSERVER_REASONING = 0.99
 SEPARATION_REASONING = 0.99
 STATE_TRANSFORMATION_REASONING = 0.98
 LQR_REASONING = 0.98

 POLICY =
  "Reduce confidence when state definitions, matrix dimensions, controllability, observability, desired poles, weighting matrices, measurement noise or nonlinear effects are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  StateSpaceControlReasoning,
  StateSpaceModelReasoning,
  StateVariableReasoning,
  ControllabilityReasoning,
  ObservabilityReasoning,
  StabilizabilityReasoning,
  DetectabilityReasoning,
  StateFeedbackReasoning,
  PolePlacementReasoning,
  ObserverReasoning,
  LuenbergerObserverReasoning,
  SeparationPrincipleReasoning,
  StateTransformationReasoning,
  LQRReasoning,
  KalmanFilterReasoning,
  ModelPredictiveControlReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "state-space control" -> StateSpaceControl
  "state space control" -> StateSpaceControl
  "state-space model" -> StateSpaceModel
  "state variable model" -> StateSpaceModel
  "state feedback" -> StateFeedback
  "pole placement" -> PolePlacement
  "controllability" -> Controllability
  "observability" -> Observability
  "Luenberger observer" -> LuenbergerObserver
  "separation principle" -> SeparationPrinciple
 }

 INTERPRETATION_ORDER = [
  detect_state_space_control_context,
  identify states_inputs_outputs_A_B_C_D_or_nonlinear dynamics,
  classify continuous_discrete_linear_nonlinear_timeInvariant_or_timeVarying model,
  assess controllability_stabilizability_observability_and_detectability,
  select state_feedback_polePlacement_LQR_observer_Kalman_or_MPC pathway,
  design gains_or_state transformations,
  construct closed_loop_and_estimation error dynamics,
  verify stability_eigenstructure_control effort_and_estimation performance,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("state-space control")
  OR explicit_state_equations are provided
  THEN activate(StateSpaceControlOntology)

 E2:
  IF A_and_B given
  THEN compute controllability_matrix_and_rank

 E3:
  IF A_and_C given
  THEN compute observability_matrix_and_rank

 E4:
  IF desired_closed_loop poles given
  THEN require controllability_before pole placement

 E5:
  IF desired_observer poles given
  THEN require observability_before observer placement

 E6:
  IF only stabilizability holds
  THEN restrict feedback claims_to stabilisable modes

 E7:
  IF only detectability holds
  THEN restrict observer claims_to detectable modes

 E8:
  IF quadratic cost Q_R specified
  THEN consider LQR

 E9:
  IF state_constraints_and_receding_horizon optimisation present
  THEN consider model_predictive_control
}

RECURSION {
 ENTRY = StateSpaceControl

 EXPAND(StateSpaceControl) -> [
  StateSpaceModel,
  StateVariable,
  StateVector,
  StateEquation,
  OutputEquation,
  SystemMatrix,
  InputMatrix,
  OutputMatrix,
  FeedthroughMatrix,
  ContinuousTimeStateSpace,
  DiscreteTimeStateSpace,
  LinearStateSpaceModel,
  NonlinearStateSpaceModel,
  LinearTimeInvariantStateSpace,
  TimeVaryingStateSpace,
  StateTransitionMatrix,
  FundamentalMatrix,
  EquilibriumPoint,
  Controllability,
  Reachability,
  ControllabilityMatrix,
  ControllabilityGramian,
  Stabilizability,
  Observability,
  ObservabilityMatrix,
  ObservabilityGramian,
  Detectability,
  StateFeedback,
  FullStateFeedback,
  OutputFeedback,
  PolePlacement,
  ClosedLoopMatrix,
  Observer,
  LuenbergerObserver,
  ObserverGain,
  StateEstimate,
  EstimationError,
  SeparationPrinciple,
  CanonicalForm,
  ControllableCanonicalForm,
  ObservableCanonicalForm,
  StateTransformation,
  ModalDecomposition,
  LinearQuadraticRegulator,
  RiccatiEquation,
  KalmanFilter,
  ModelPredictiveControl
 ]

 EXPAND(StructuralProperties) -> [
  Controllability,
  Reachability,
  Stabilizability,
  Observability,
  Detectability,
  ControllabilityGramian,
  ObservabilityGramian
 ]

 EXPAND(StateFeedbackMethods) -> [
  PolePlacement,
  FullStateFeedback,
  LinearQuadraticRegulator,
  ModelPredictiveControl
 ]

 EXPAND(StateEstimationMethods) -> [
  LuenbergerObserver,
  KalmanFilter,
  StateEstimate,
  EstimationError,
  ObserverGain
 ]

 STOP_CONDITION =
  "Stop when the state model, system matrices, structural properties, feedback law, observer structure, eigenvalue placement, state transformation and closed-loop performance are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Control Theory"

 IMMEDIATE_CONTEXTS = [
  "Control Theory Ontology",
  "Control System Ontology",
  "Feedback Control Ontology",
  "Linear Algebra Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Control Theory Ontology",
  "Control Theory",
  "Control System Ontology",
  "Feedback Control Ontology",
  "Linear Algebra Ontologies",
  "Dynamical Systems Ontologies",
  "Stability Ontologies",
  "Controllability Ontologies",
  "Observability Ontologies",
  "Optimal Control Ontologies",
  "Kalman Filter Ontologies",
  "Model Predictive Control Ontologies",
  "Numerical Analysis Ontologies",
  "System Identification Ontologies"
 ]

 ROUTE_RULES = [
  "State-Space Control -> Control Theory Ontology for core control semantics",
  "State-Space Control -> Control System for architecture and signal structure",
  "State-Space Control -> Feedback Control for closed-loop control semantics",
  "State-Space Control -> Linear Algebra for matrix rank, eigenvalues and transformations",
  "State-Space Control -> Dynamical Systems for state trajectories",
  "State-Space Control -> Stability for closed-loop eigenstructure",
  "State-Space Control -> Controllability and Observability for structural properties",
  "State-Space Control -> Optimal Control for LQR",
  "State-Space Control -> Kalman Filter for stochastic state estimation",
  "State-Space Control -> Model Predictive Control for constrained state-space optimisation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible state-space entities, controller families or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve state-vector semantics.",
  "Preserve matrix-dimension consistency.",
  "Preserve continuous-versus-discrete state equations.",
  "Preserve controllability and observability semantics.",
  "Preserve stabilizability and detectability distinctions.",
  "Preserve state-feedback and observer distinctions.",
  "Preserve coordinate-transformation invariance.",
  "Preserve machine-readable state-space control semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "State-space control represents dynamical systems using internal state variables and designs controllers or observers directly from that representation."

 MODEL_SUMMARY =
  "A linear state-space model uses x_dot=Ax+Bu and y=Cx+Du, or the corresponding discrete-time form."

 CONTROLLABILITY_SUMMARY =
  "Controllability determines whether control inputs can steer the state through the relevant state space."

 OBSERVABILITY_SUMMARY =
  "Observability determines whether state variables can be reconstructed from measured outputs."

 FEEDBACK_SUMMARY =
  "State feedback uses the state or estimated state to modify closed-loop dynamics."

 POLE_PLACEMENT_SUMMARY =
  "Pole placement chooses feedback gains to assign closed-loop eigenvalues when structural conditions permit."

 OBSERVER_SUMMARY =
  "Observers estimate unavailable states from system inputs and measured outputs."

 SEPARATION_SUMMARY =
  "The separation principle allows independent controller and observer design for standard linear systems."

 OPTIMAL_SUMMARY =
  "LQR computes optimal linear state feedback by solving a Riccati equation."
}

FLOW {
 INPUT
 -> detect_state_space_control_context
 -> identify state_variables_inputs_outputs_A_B_C_D_or_nonlinear state equations
 -> classify continuous_discrete_linear_nonlinear_timeInvariant_or_timeVarying model
 -> verify matrix_dimensions_and_state representation
 -> analyse eigenstructure_controllability_stabilizability_observability_and_detectability
 -> select state_feedback_polePlacement_LQR_observer_Luenberger_Kalman_or_MPC pathway
 -> compute controller_gain_observer_gain_or_state transformation
 -> construct closed_loop_and_estimation error dynamics
 -> verify eigenvalues_stability_tracking_control effort_estimation convergence_and_robustness
 -> route to control_theory_ontology control_system feedback_control linear_algebra dynamical_systems stability controllability observability optimal_control Kalman_filter MPC numerical_analysis_or_system_identification ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The State-Space Control Ontology defines dynamical-system control through internal state variables. It supports continuous and discrete state equations, system, input, output and feedthrough matrices, state-transition matrices, controllability, reachability, stabilizability, observability, detectability, state feedback, pole placement, observers, estimation error dynamics, the separation principle, controllable and observable canonical forms, state transformations, modal decomposition, LQR, Riccati equations, Kalman filtering and constrained predictive control."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-APPLIED-MATHEMATICS-STATE-SPACE-CONTROL-ONTOLOGY-V1"
}

}

END_FLOW
Privacy Policy
Site Map
Kireth Research
38 Thorndale Croft, Wetwang, Driffield
East Riding of Yorkshire YO25 9XZ
Telephone:
01377 236594
Designed By
Kireth Web Design
Audio Explainer RSS Feed