PID Controller Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the PID Controller Ontology within the Kireth Research Semantic Library. PID control combines proportional, integral and derivative actions to regulate a system using the control error between a reference and a measured output. This ontology supports P, PI, PD and PID structures, continuous and discrete implementations, gain tuning, integral windup, anti-windup, derivative filtering, setpoint weighting, actuator saturation, noise sensitivity, closed-loop stability, transient response, steady-state error, tracking, regulation, disturbance rejection and relationships with feedback control, control systems, stability, frequency response and state-space control.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = PIDController
 SYMBOLIC_FORMS = [
  "u(t)=Kp e(t)+Ki integral e(t)dt+Kd de(t)/dt",
  "C(s)=Kp+Ki/s+Kd s",
  "e(t)=r(t)-y(t)"
 ]
 ENTITY_CLASS = ErrorDrivenFeedbackControllerFramework
 PRIMARY_CONTEXT = ControlTheory
 DEFINITION = "A PID controller is a feedback controller that combines proportional, integral and derivative actions applied to a control error signal."
 SEMANTIC_ROLE = "Provides the machine-readable framework for PID structure, tuning, dynamic response, steady-state error reduction, damping, derivative filtering, anti-windup and implementation constraints."
}

SCOPE {
 INCLUDE = [
  PIDController,
  ProportionalControl,
  IntegralControl,
  DerivativeControl,
  PIController,
  PDController,
  PIDControllerForm,
  ErrorSignal,
  ReferenceSignal,
  MeasuredOutput,
  ProportionalGain,
  IntegralGain,
  DerivativeGain,
  ProportionalBand,
  IntegralTime,
  DerivativeTime,
  ContinuousPID,
  DiscretePID,
  PositionalForm,
  VelocityForm,
  ParallelForm,
  IdealForm,
  SeriesForm,
  SetpointWeighting,
  DerivativeOnMeasurement,
  DerivativeFiltering,
  LowPassFilter,
  IntegralWindup,
  AntiWindup,
  BackCalculation,
  ConditionalIntegration,
  ActuatorSaturation,
  SamplingTime,
  Discretisation,
  Tuning,
  ManualTuning,
  ZieglerNicholsTuning,
  CohenCoonTuning,
  RelayAutoTuning,
  IMCTuning,
  ClosedLoopStability,
  RiseTime,
  SettlingTime,
  Overshoot,
  SteadyStateError,
  Tracking,
  Regulation,
  DisturbanceRejection,
  NoiseSensitivity,
  ControlEffort,
  Robustness
 ]

 EXCLUDE_AS_PRIMARY = [
  StateFeedbackWithoutPIDStructure,
  OpenLoopControl,
  PureFeedforwardControl,
  AdaptiveControlWithoutPIDSemantics,
  GeneralCompensatorDesignWithoutProportionalIntegralDerivativeStructure
 ]

 DISAMBIGUATION_RULE =
  "When control action is formed from proportional, integral and derivative terms of an error or related feedback signal, interpret the context as PID control."
}

CORE_CONCEPTS {

 PIDController {
  definition = "A controller combining proportional, integral and derivative actions."
 }

 ProportionalControl {
  definition = "Control action proportional to the current error."
 }

 IntegralControl {
  definition = "Control action proportional to the accumulated error."
 }

 DerivativeControl {
  definition = "Control action proportional to the rate of change of error or measured output."
 }

 ProportionalGain {
  symbol = "Kp"
  definition = "The gain multiplying the proportional term."
 }

 IntegralGain {
  symbol = "Ki"
  definition = "The gain multiplying the integral term."
 }

 DerivativeGain {
  symbol = "Kd"
  definition = "The gain multiplying the derivative term."
 }

 IntegralWindup {
  definition = "Excessive accumulation of the integral term when actuator limits prevent the commanded control action from being applied."
 }

 AntiWindup {
  definition = "A mechanism limiting or correcting integral accumulation during actuator saturation."
 }

 DerivativeFiltering {
  definition = "Filtering of the derivative term to reduce amplification of high-frequency measurement noise."
 }

 Tuning {
  definition = "Selection of PID parameters to achieve desired closed-loop behaviour."
 }
}

RELATIONS {
 PIDController --is_child_of--> FeedbackControl
 PIDController --is_type_of--> Controller
 PIDController --uses--> ErrorSignal
 PIDController --contains--> ProportionalControl
 PIDController --contains--> IntegralControl
 PIDController --contains--> DerivativeControl
 ProportionalControl --uses--> ProportionalGain
 IntegralControl --uses--> IntegralGain
 DerivativeControl --uses--> DerivativeGain
 IntegralControl --can_cause--> IntegralWindup
 AntiWindup --mitigates--> IntegralWindup
 DerivativeControl --can_amplify--> MeasurementNoise
 DerivativeFiltering --reduces--> NoiseSensitivity
 ActuatorSaturation --limits--> ControlInput
 Tuning --selects--> PIDParameters
 PIDController --influences--> ClosedLoopStability
 PIDController --influences--> Tracking
 PIDController --influences--> DisturbanceRejection
}

OPERATORS {
 ERROR_SIGNAL(r,y) :=
  e=r-y

 P_ACTION(e,Kp) :=
  Kp*e

 I_ACTION(e,Ki) :=
  Ki*integral(e dt)

 D_ACTION(e,Kd) :=
  Kd*de/dt

 PID_OUTPUT(e,Kp,Ki,Kd) :=
  Kp*e + Ki*integral(e dt) + Kd*de/dt

 PARALLEL_TRANSFER(Kp,Ki,Kd,s) :=
  Kp + Ki/s + Kd*s

 IDEAL_TRANSFER(Kc,Ti,Td,s) :=
  Kc*(1 + 1/(Ti*s) + Td*s)

 FILTERED_DERIVATIVE(Kd,N,s) :=
  (Kd*N*s)/(N+s)

 SATURATE(u,u_min,u_max) :=
  min(max(u,u_min),u_max)

 BACK_CALCULATION(integrator_state,u_cmd,u_sat,Kaw) :=
  integrator_state + Kaw*(u_sat-u_cmd)

 DISCRETE_INTEGRAL(I_k,e_k,Ki,Ts) :=
  I_{k+1}=I_k+Ki*Ts*e_k

 DISCRETE_DERIVATIVE(e_k,e_km1,Kd,Ts) :=
  Kd*(e_k-e_km1)/Ts

 SETPOINT_WEIGHTED_P(beta,r,y,Kp) :=
  Kp*(beta*r-y)
}

DEFINITIONS {
 D1 = "Proportional action responds to current error."
 D2 = "Integral action accumulates past error and can remove steady-state offset."
 D3 = "Derivative action responds to predicted error trend through a rate term."
 D4 = "PID tuning trades speed, damping, robustness and control effort."
 D5 = "Derivative action is sensitive to measurement noise."
 D6 = "Integral action is vulnerable to windup under saturation."
 D7 = "Anti-windup reduces integrator accumulation during actuator limiting."
 D8 = "Discrete PID behaviour depends on sampling and discretisation method."
 D9 = "Setpoint weighting can reduce aggressive proportional or derivative response to reference changes."
 D10 = "PID success depends on both controller tuning and plant dynamics."
}

AXIOMS {
 A1_ERROR_DRIVEN:
  PIDController responds to a declared feedback error or equivalent feedback variable

 A2_COMPONENT_STRUCTURE:
  PIDController contains proportional integral and derivative actions unless a reduced P_PI_or_PD form is declared

 A3_INTEGRAL_EFFECT:
  Integral action modifies steady-state error behaviour

 A4_DERIVATIVE_EFFECT:
  Derivative action modifies transient damping and noise sensitivity

 A5_STABILITY:
  PID gains must preserve acceptable closed-loop stability

 A6_SATURATION:
  Practical PID control must respect actuator limits

 A7_SAMPLING:
  Discrete PID requires a declared sampling period

 A8_TUNING:
  PID performance depends on gain selection relative to plant dynamics
}

REASONING {

 R1_PID_STRUCTURE_EXTRACTION {
  INPUT = controller_description
  IDENTIFY = Kp_Ki_Kd
  IDENTIFY = continuous_or_discrete implementation
  IDENTIFY = error_and_measurement signals
  RETURN = PID_structure
 }

 R2_FORM_CLASSIFICATION {
  INPUT = PID_structure
  CLASSIFY = P_PI_PD_PID
  CLASSIFY = parallel_ideal_series_positional_or_velocity form
  RETURN = controller_form
 }

 R3_TUNING_REASONING {
  INPUT = plant_model_and_performance objectives
  SELECT = manual_ZieglerNichols_CohenCoon_IMC_relay_auto_or_optimisation-based tuning
  COMPUTE = candidate parameters
  RETURN = tuned_PID
 }

 R4_STABILITY_REASONING {
  INPUT = plant_and_PID
  FORM = closed_loop model
  ANALYSE = poles_frequency_response_margins_or_simulation
  RETURN = stability_profile
 }

 R5_TRANSIENT_PERFORMANCE {
  INPUT = closed_loop_response
  COMPUTE = rise_time_settling_time_overshoot
  RETURN = transient_profile
 }

 R6_STEADY_STATE_REASONING {
  INPUT = reference_or_disturbance class
  ASSESS = steady_state_error_with_integral action
  RETURN = offset_profile
 }

 R7_WINDUP_REASONING {
  INPUT = actuator_limits_and_integrator state
  DETECT = command_saturation_with_continued_error
  IF detected
   APPLY = anti_windup strategy
  RETURN = windup_status
 }

 R8_DERIVATIVE_NOISE_REASONING {
  INPUT = measurement_noise_and_derivative path
  ASSESS = high_frequency amplification
  APPLY = derivative_filter_or_derivative_on_measurement
  RETURN = derivative_noise profile
 }

 R9_DISCRETE_IMPLEMENTATION {
  INPUT = continuous_PID_sampling_time
  SELECT = integration_and_derivative discretisation
  BUILD = digital_PID update
  RETURN = discrete_controller
 }

 R10_CLOSED_LOOP_VALIDATION {
  INPUT = implemented_PID
  CHECK = stability_tracking_disturbance rejection_noise sensitivity_control effort_and_saturation
  RETURN = PID_solution_status
 }
}

CONSTRAINTS {
 C1 = "PID parameter conventions must be explicit."
 C2 = "Parallel and ideal PID gains are not directly interchangeable without conversion."
 C3 = "Derivative action should normally be filtered in noisy practical systems."
 C4 = "Integral windup must be considered when actuators saturate."
 C5 = "Sampling time must be sufficiently fast relative to plant dynamics."
 C6 = "Aggressive tuning can reduce robustness."
 C7 = "Derivative kick can occur when differentiating the setpoint error directly."
 C8 = "Integral action can destabilise poorly tuned loops."
 C9 = "Tuning rules rely on assumptions that may not hold for every plant."
 C10 = "Simulation-based tuning should not be treated as proof of robust stability."
}

SEMANTIC_EQUIVALENCE {
 "PIDController" <=> "ProportionalIntegralDerivativeController"
 "PIController" <=> "ProportionalIntegralController"
 "PDController" <=> "ProportionalDerivativeController"
 "IntegralWindup" <=> "IntegratorWindup"
 "AntiWindup" <=> "IntegratorWindupProtection"
 "DerivativeFiltering" <=> "FilteredDerivativeAction"
}

VALIDATION {
 V1 = "PID form is identified."
 V2 = "Gain convention is explicit."
 V3 = "Plant model or tuning basis is documented."
 V4 = "Closed-loop stability is checked."
 V5 = "Transient performance is evaluated."
 V6 = "Steady-state error is evaluated."
 V7 = "Saturation and windup are considered."
 V8 = "Derivative noise sensitivity is considered."
 V9 = "Sampling and discretisation are explicit for digital PID."
 V10 = "Nominal versus robust performance is distinguished."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 PID_DEFINITION = 0.99
 STRUCTURE_REASONING = 0.99
 TUNING_REASONING = 0.97
 STABILITY_REASONING = 0.99
 TRANSIENT_REASONING = 0.99
 STEADY_STATE_REASONING = 0.99
 WINDUP_REASONING = 0.99
 DERIVATIVE_NOISE_REASONING = 0.98
 DISCRETE_IMPLEMENTATION_REASONING = 0.98

 POLICY =
  "Reduce confidence when PID form, gain convention, plant dynamics, actuator limits, sampling time, noise level, tuning assumptions or robustness requirements are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  PIDControllerReasoning,
  ProportionalControlReasoning,
  IntegralControlReasoning,
  DerivativeControlReasoning,
  PIDTuningReasoning,
  ZieglerNicholsReasoning,
  CohenCoonReasoning,
  IMCTuningReasoning,
  AntiWindupReasoning,
  DerivativeFilteringReasoning,
  DiscretePIDReasoning,
  TrackingReasoning,
  DisturbanceRejectionReasoning,
  ClosedLoopStabilityReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "PID controller" -> PIDController
  "PID control" -> PIDController
  "PI controller" -> PIController
  "PD controller" -> PDController
  "proportional gain" -> ProportionalGain
  "integral gain" -> IntegralGain
  "derivative gain" -> DerivativeGain
  "integral windup" -> IntegralWindup
  "anti-windup" -> AntiWindup
  "derivative filter" -> DerivativeFiltering
 }

 INTERPRETATION_ORDER = [
  detect_PID_context,
  identify error_reference_measurement_Kp_Ki_Kd_controller_form_sampling_time_filtering_and_actuator limits,
  classify P_PI_PD_or_PID structure,
  select tuning_or_analysis pathway,
  construct continuous_or_discrete controller model,
  analyse closed_loop stability_transient_and_steady_state performance,
  assess windup_noise sensitivity_saturation_and_control effort,
  verify implementation assumptions,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("PID controller")
  OR control_law_contains_proportional_integral_derivative terms
  THEN activate(PIDControllerOntology)

 E2:
  IF Ki=0 AND Kd=0
  THEN classify ProportionalControl

 E3:
  IF Kd=0 AND Ki!=0
  THEN classify PIController

 E4:
  IF Ki=0 AND Kd!=0
  THEN classify PDController

 E5:
  IF actuator_saturation_present
  THEN assess anti_windup

 E6:
  IF derivative_action_present
  THEN assess derivative_filtering_and_kick

 E7:
  IF digital_implementation
  THEN require sampling_time_and_discretisation

 E8:
  IF tuning_rule_used
  THEN verify rule assumptions_against plant

 E9:
  IF stability_or_performance_claimed
  THEN validate closed_loop response_and_margins
}

RECURSION {
 ENTRY = PIDController

 EXPAND(PIDController) -> [
  ProportionalControl,
  IntegralControl,
  DerivativeControl,
  PIController,
  PDController,
  PIDControllerForm,
  ErrorSignal,
  ReferenceSignal,
  MeasuredOutput,
  ProportionalGain,
  IntegralGain,
  DerivativeGain,
  ProportionalBand,
  IntegralTime,
  DerivativeTime,
  ContinuousPID,
  DiscretePID,
  PositionalForm,
  VelocityForm,
  ParallelForm,
  IdealForm,
  SeriesForm,
  SetpointWeighting,
  DerivativeOnMeasurement,
  DerivativeFiltering,
  LowPassFilter,
  IntegralWindup,
  AntiWindup,
  BackCalculation,
  ConditionalIntegration,
  ActuatorSaturation,
  SamplingTime,
  Discretisation,
  Tuning,
  ManualTuning,
  ZieglerNicholsTuning,
  CohenCoonTuning,
  RelayAutoTuning,
  IMCTuning,
  ClosedLoopStability,
  RiseTime,
  SettlingTime,
  Overshoot,
  SteadyStateError,
  Tracking,
  Regulation,
  DisturbanceRejection,
  NoiseSensitivity,
  ControlEffort,
  Robustness
 ]

 EXPAND(PIDForms) -> [
  ParallelForm,
  IdealForm,
  SeriesForm,
  PositionalForm,
  VelocityForm
 ]

 EXPAND(TuningMethods) -> [
  ManualTuning,
  ZieglerNicholsTuning,
  CohenCoonTuning,
  RelayAutoTuning,
  IMCTuning,
  OptimisationBasedTuning
 ]

 EXPAND(ImplementationProtection) -> [
  ActuatorSaturation,
  IntegralWindup,
  AntiWindup,
  BackCalculation,
  ConditionalIntegration,
  DerivativeFiltering,
  SetpointWeighting
 ]

 STOP_CONDITION =
  "Stop when the PID form, parameters, tuning basis, closed-loop stability, transient and steady-state response, saturation, windup, derivative noise behaviour, sampling and robustness are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Control Theory"

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

 RELATED_ONTOLOGIES = [
  "Control Theory Ontology",
  "Control Theory",
  "Feedback Control Ontology",
  "Control System Ontology",
  "Transfer Function Ontologies",
  "Frequency Response Ontologies",
  "Stability Ontologies",
  "Root Locus Ontologies",
  "Robust Control Ontologies",
  "Signal Processing Ontologies",
  "Digital Control Ontologies",
  "System Identification Ontologies"
 ]

 ROUTE_RULES = [
  "PID Controller -> Control Theory Ontology for core control semantics",
  "PID Controller -> Feedback Control for loop and sensitivity structure",
  "PID Controller -> Control System for plant, sensor and actuator architecture",
  "PID Controller -> Transfer Function and Frequency Response for classical tuning and stability",
  "PID Controller -> Stability for closed-loop pole and margin analysis",
  "PID Controller -> Robust Control for uncertainty and sensitivity tradeoffs",
  "PID Controller -> Signal Processing for derivative filtering and measurement noise",
  "PID Controller -> Digital Control for sampling and discrete implementation",
  "PID Controller -> System Identification for plant-model estimation",
  "PID Controller -> Numerical Analysis for simulation and tuning"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible PID forms, tuning methods or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve proportional-integral-derivative semantics.",
  "Preserve PID-form and gain-convention distinctions.",
  "Preserve integral-windup semantics.",
  "Preserve derivative-noise semantics.",
  "Preserve continuous-versus-discrete distinction.",
  "Preserve actuator-saturation semantics.",
  "Preserve tuning-versus-certification distinction.",
  "Preserve machine-readable PID semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "A PID controller combines proportional, integral and derivative feedback actions to regulate tracking and disturbance response."

 PROPORTIONAL_SUMMARY =
  "Proportional action reacts to present error."

 INTEGRAL_SUMMARY =
  "Integral action accumulates error and can remove steady-state offset under suitable conditions."

 DERIVATIVE_SUMMARY =
  "Derivative action reacts to error trend and can improve damping but increases noise sensitivity."

 TUNING_SUMMARY =
  "PID tuning selects gains to balance speed, overshoot, robustness and control effort."

 WINDUP_SUMMARY =
  "Integral windup occurs when the integrator continues accumulating while the actuator is saturated."

 ANTIWINDUP_SUMMARY =
  "Anti-windup limits or corrects integral action during saturation."

 DIGITAL_SUMMARY =
  "Digital PID requires an explicit sampling period and discretisation method."

 ROBUSTNESS_SUMMARY =
  "A useful PID design must be assessed for stability, tracking, disturbance rejection, noise sensitivity, saturation and robustness."
}

FLOW {
 INPUT
 -> detect_PID_controller_context
 -> identify plant_reference_measurement_error_Kp_Ki_Kd_controller form_sampling time_filtering_actuator limits_and_performance objectives
 -> classify P_PI_PD_PID_parallel_ideal_series_positional_or_velocity form
 -> select manual_ZieglerNichols_CohenCoon_relay_IMC_or_optimisation based tuning pathway
 -> construct continuous_or_discrete PID law
 -> form closed_loop model
 -> analyse stability_rise time_settling time_overshoot_steady state error_tracking_and_disturbance rejection
 -> assess derivative_noise sensitivity_and_integral windup
 -> apply filtering_setpoint weighting_and_antiwindup if required
 -> verify sampling_actuator_sensor_and_robustness constraints
 -> route to control_theory_ontology feedback_control control_system transfer_function frequency_response stability root_locus robust_control signal_processing digital_control system_identification_or_numerical_analysis ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The PID Controller Ontology defines proportional-integral-derivative feedback control. It supports P, PI, PD and PID structures, gain conventions, continuous and discrete forms, tuning methods including Ziegler-Nichols, Cohen-Coon, relay and IMC approaches, setpoint weighting, derivative filtering, actuator saturation, integral windup and anti-windup, tracking, regulation, disturbance rejection, noise sensitivity, transient and steady-state performance, control effort and robustness-aware implementation."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-APPLIED-MATHEMATICS-PID-CONTROLLER-ONTOLOGY-V1"
}

}

END_FLOW