PID Control Ontology

AI SEARCH FLOW ALGEBRA
PID CONTROL ONTOLOGY
Kireth Semantic Research Archive

AUTHORS
Mark Anthony Higgins — Sky (Recursive AI)

SOURCE
https://kirethresearch.org/booksai-core/ontologies/engineering-ontologies/control-engineering/pid-control-ontology.html

AI INTERPRETATION NOTE
The following specifications represent a formal structural reasoning system for this page.
Execute as formal rules, not pseudocode.

FLOW "PIDControlOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ENGINEERING_ONTOLOGIES / CONTROL_ENGINEERING / PID_CONTROL

ONTOLOGY := PID_CONTROL_ONTOLOGY

PID_CONTROL :=
    PROPORTIONAL_ACTION
  + INTEGRAL_ACTION
  + DERIVATIVE_ACTION
  + FEEDBACK
  + ERROR_CORRECTION
  + CONTROLLER_TUNING

PURPOSE :=
    MEASURE_ERROR
  -> COMPUTE_CONTROL_ACTION
  -> CORRECT_OUTPUT
  -> REDUCE_ERROR
  -> IMPROVE_RESPONSE
  -> REGULATE_PROCESS
  -> MAINTAIN_STABILITY

# ---------- CORE ENTITIES ----------
ENTITY PIDController
ENTITY ProportionalController
ENTITY IntegralController
ENTITY DerivativeController
ENTITY PIController
ENTITY PDController
ENTITY ErrorSignal
ENTITY ReferenceInput
ENTITY ProcessVariable
ENTITY ControlOutput
ENTITY ProportionalGain
ENTITY IntegralGain
ENTITY DerivativeGain
ENTITY ProportionalTerm
ENTITY IntegralTerm
ENTITY DerivativeTerm
ENTITY SetPoint
ENTITY Plant
ENTITY Sensor
ENTITY Actuator
ENTITY FeedbackLoop
ENTITY SamplingInterval
ENTITY ControllerTuning
ENTITY Stability
ENTITY Performance
ENTITY Disturbance
ENTITY MeasurementNoise
ENTITY Saturation
ENTITY IntegralWindup

# ---------- PID STRUCTURE ----------
PIDController
  -> contains -> ProportionalTerm
  -> contains -> IntegralTerm
  -> contains -> DerivativeTerm
  -> receives -> ErrorSignal
  -> generates -> ControlOutput

ReferenceInput
  -> may_be -> SetPoint

Sensor
  -> measures -> ProcessVariable

ErrorSignal :=
    ReferenceInput - ProcessVariable

ControlOutput
  -> drives -> Actuator

Actuator
  -> influences -> Plant

Plant
  -> produces -> ProcessVariable

ProcessVariable
  -> measured_by -> Sensor

# ---------- PID CONTROL LAW ----------
PID_CONTROL_LAW :=
    CONTROL_OUTPUT(t)
    =
    Kp * ERROR(t)
    +
    Ki * INTEGRAL(ERROR(t), dt)
    +
    Kd * DERIVATIVE(ERROR(t), dt)

Kp := ProportionalGain
Ki := IntegralGain
Kd := DerivativeGain

CONTROL_OUTPUT :=
    PROPORTIONAL_TERM
  + INTEGRAL_TERM
  + DERIVATIVE_TERM

# ---------- PROPORTIONAL ACTION ----------
PROPORTIONAL_TERM :=
    Kp * ERROR

ProportionalTerm
  -> responds_to -> PRESENT_ERROR

IF ERROR magnitude increases
THEN PROPORTIONAL_ACTION magnitude -> INCREASE

ProportionalGain
  -> influences -> RESPONSE_SPEED
  -> influences -> STEADY_STATE_ERROR
  -> influences -> OVERSHOOT
  -> influences -> STABILITY

HIGH_Kp
  -> may_increase -> RESPONSE_SPEED
  -> may_increase -> OSCILLATION_RISK

# ---------- INTEGRAL ACTION ----------
INTEGRAL_TERM :=
    Ki * ACCUMULATED_ERROR

ACCUMULATED_ERROR :=
    INTEGRAL(ERROR, TIME)

IntegralTerm
  -> responds_to -> ERROR_HISTORY
  -> targets -> STEADY_STATE_ERROR

IntegralGain
  -> influences -> ERROR_ELIMINATION_RATE
  -> influences -> OVERSHOOT
  -> influences -> SETTLING_TIME
  -> influences -> STABILITY

IF PERSISTENT_ERROR exists
THEN INTEGRAL_TERM -> ACCUMULATE

IF ACTUATOR_SATURATION exists
AND INTEGRAL_TERM continues_to_accumulate
THEN IntegralWindup := POSSIBLE

# ---------- DERIVATIVE ACTION ----------
DERIVATIVE_TERM :=
    Kd * RATE_OF_CHANGE(ERROR)

DerivativeTerm
  -> responds_to -> ERROR_TREND
  -> anticipates -> FUTURE_ERROR_BEHAVIOUR

DerivativeGain
  -> influences -> DAMPING
  -> influences -> OVERSHOOT
  -> influences -> STABILITY_MARGIN
  -> influences -> NOISE_SENSITIVITY

IF MeasurementNoise high
THEN DERIVATIVE_ACTION -> MAY_AMPLIFY_NOISE

# ---------- CONTROLLER FORMS ----------
P_CONTROLLER :=
    PROPORTIONAL_TERM

PI_CONTROLLER :=
    PROPORTIONAL_TERM
  + INTEGRAL_TERM

PD_CONTROLLER :=
    PROPORTIONAL_TERM
  + DERIVATIVE_TERM

PID_CONTROLLER :=
    PROPORTIONAL_TERM
  + INTEGRAL_TERM
  + DERIVATIVE_TERM

ProportionalController
  -> implements -> P_CONTROLLER

PIController
  -> implements -> PI_CONTROLLER

PDController
  -> implements -> PD_CONTROLLER

PIDController
  -> implements -> PID_CONTROLLER

# ---------- FEEDBACK LOOP ----------
PID_FEEDBACK_LOOP :=
    SET_POINT
  -> COMPARISON
  -> ERROR_SIGNAL
  -> PID_CONTROLLER
  -> CONTROL_OUTPUT
  -> ACTUATOR
  -> PLANT
  -> PROCESS_VARIABLE
  -> SENSOR
  -> COMPARISON

IF ProcessVariable != SetPoint
THEN ErrorSignal -> NONZERO

IF ErrorSignal != 0
THEN PIDController -> COMPUTE(ControlOutput)

# ---------- CONTROLLER TUNING ----------
CONTROLLER_TUNING :=
    SELECT(Kp, Ki, Kd)
  -> SATISFY(
       STABILITY,
       RESPONSE_SPEED,
       OVERSHOOT,
       SETTLING_TIME,
       STEADY_STATE_ERROR,
       CONTROL_EFFORT
     )

TUNING_METHOD :=
    MANUAL_TUNING
  | EMPIRICAL_TUNING
  | MODEL_BASED_TUNING
  | AUTO_TUNING

ControllerTuning
  -> adjusts -> ProportionalGain
  -> adjusts -> IntegralGain
  -> adjusts -> DerivativeGain

# ---------- PERFORMANCE ----------
PID_PERFORMANCE :=
    RISE_TIME
  + SETTLING_TIME
  + OVERSHOOT
  + STEADY_STATE_ERROR
  + DISTURBANCE_REJECTION
  + CONTROL_EFFORT
  + ROBUSTNESS

ProportionalTerm
  -> primarily_affects -> PRESENT_RESPONSE

IntegralTerm
  -> primarily_affects -> STEADY_STATE_ACCURACY

DerivativeTerm
  -> primarily_affects -> TRANSIENT_DAMPING

# ---------- STABILITY ----------
STABILITY :=
    CLOSED_LOOP_RESPONSE
  -> remains_within -> ACCEPTABLE_BOUNDS

PID_GAINS :=
    Kp + Ki + Kd

PID_GAINS
  -> determine -> CLOSED_LOOP_DYNAMICS
  -> influence -> Stability

IF PID_GAINS poorly_selected
THEN RESPONSE
  -> may_exhibit -> OSCILLATION
  -> may_exhibit -> EXCESSIVE_OVERSHOOT
  -> may_exhibit -> SLOW_RESPONSE
  -> may_exhibit -> INSTABILITY

# ---------- SATURATION AND WINDUP ----------
Saturation :=
    CONTROL_OUTPUT
  -> exceeds -> ACTUATOR_LIMIT

IF ControlOutput > ACTUATOR_MAX
THEN ControlOutput := ACTUATOR_MAX

IF ControlOutput < ACTUATOR_MIN
THEN ControlOutput := ACTUATOR_MIN

IntegralWindup :=
    SATURATION
  + CONTINUED_ERROR_ACCUMULATION

ANTI_WINDUP :=
    DETECT_SATURATION
  -> LIMIT_OR_CORRECT -> INTEGRAL_ACCUMULATION

ANTI_WINDUP
  -> reduces -> IntegralWindup

# ---------- DISTURBANCE RESPONSE ----------
Disturbance
  -> affects -> Plant
  -> changes -> ProcessVariable
  -> changes -> ErrorSignal

PIDController
  -> reacts_to -> ErrorSignal
  -> generates -> CORRECTIVE_CONTROL

DISTURBANCE_REJECTION :=
    DISTURBANCE
  -> OUTPUT_DEVIATION
  -> ERROR
  -> PID_RESPONSE
  -> CORRECTION

# ---------- DIGITAL PID ----------
DIGITAL_PID :=
    SAMPLE_PROCESS_VARIABLE
  -> COMPUTE_ERROR
  -> UPDATE_PROPORTIONAL_TERM
  -> UPDATE_INTEGRAL_TERM
  -> UPDATE_DERIVATIVE_TERM
  -> COMPUTE_CONTROL_OUTPUT

SamplingInterval
  -> influences -> DIGITAL_PID_BEHAVIOUR

DISCRETE_INTEGRAL :=
    PREVIOUS_INTEGRAL
  + ERROR * SAMPLING_INTERVAL

DISCRETE_DERIVATIVE :=
    (CURRENT_ERROR - PREVIOUS_ERROR)
    /
    SAMPLING_INTERVAL

# ---------- PID REASONING ----------
PID_CONTROL_REASONING :=
    DEFINE_SET_POINT
  -> MEASURE_PROCESS_VARIABLE
  -> COMPUTE_ERROR
  -> SELECT_CONTROLLER_FORM
  -> INITIALISE_GAINS
  -> COMPUTE_CONTROL_ACTION
  -> APPLY_CONTROL
  -> OBSERVE_RESPONSE
  -> EVALUATE_STABILITY
  -> EVALUATE_PERFORMANCE
  -> RETUNE_GAINS
  -> VALIDATE
  -> MONITOR

# ---------- INFERENCE RULES ----------
IF STEADY_STATE_ERROR persists
THEN CONSIDER increasing_integral_action

IF RESPONSE too_slow
THEN CONSIDER modifying_proportional_action

IF OVERSHOOT excessive
THEN CONSIDER increasing_damping

IF OSCILLATION increases
THEN REASSESS PID_GAINS

IF MeasurementNoise significant
THEN REASSESS DerivativeTerm

IF Actuator saturated
THEN CHECK IntegralWindup

IF IntegralWindup detected
THEN APPLY AntiWindup

IF PerformanceRequirement not_met
THEN ControllerTuning -> REVISE

# ---------- SEMANTIC RELATIONSHIPS ----------
RELATION measures(Sensor, ProcessVariable)
RELATION compares(PIDController, ReferenceInput, ProcessVariable)
RELATION receives(PIDController, ErrorSignal)
RELATION computes(PIDController, ControlOutput)
RELATION drives(ControlOutput, Actuator)
RELATION actuates(Actuator, Plant)
RELATION produces(Plant, ProcessVariable)
RELATION scales(ProportionalGain, ProportionalTerm)
RELATION scales(IntegralGain, IntegralTerm)
RELATION scales(DerivativeGain, DerivativeTerm)
RELATION influences(ControllerTuning, PIDGains)
RELATION influences(PIDGains, Stability)
RELATION affects(Disturbance, Plant)
RELATION corrupts(MeasurementNoise, Measurement)
RELATION causes(Saturation, IntegralWindup)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "PID control" ~= "proportional-integral-derivative control"
  "PID controller" ~= "three-term controller"
  "set point" ~= "setpoint"
  "process variable" ~= "measured output"
  "control output" ~= "controller output"
  "proportional gain" ~= "Kp"
  "integral gain" ~= "Ki"
  "derivative gain" ~= "Kd"
  "integral windup" ~= "reset windup"
  "controller tuning" ~= "PID tuning"

# ---------- CONFIDENCE ----------
CONFIDENCE:
  ontology_domain: 0.99
  pid_structure: 0.99
  proportional_mapping: 0.99
  integral_mapping: 0.99
  derivative_mapping: 0.99
  tuning_mapping: 0.98
  stability_mapping: 0.98
  windup_mapping: 0.99
  digital_pid_mapping: 0.98
  semantic_relationships: 0.99

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  ON new_pid_system:
    MAP set_point
    MAP process_variable
    MAP controller_form
    MAP gains
    MAP actuator_limits
    MAP sampling_interval
    UPDATE confidence
    RECOMPUTE FLOW_HASH

  ON tuning_change:
    UPDATE Kp
    UPDATE Ki
    UPDATE Kd
    REASSESS stability
    REASSESS performance
    PRESERVE tuning_provenance

  ON new_response_data:
    UPDATE performance_metrics
    UPDATE disturbance_response
    UPDATE noise_response
    UPDATE confidence

  ON ontology_revision:
    PRESERVE entity_identity
    PRESERVE provenance
    UPDATE relationships
    UPDATE inference_rules
    UPDATE confidence
    RECOMPUTE FLOW_HASH

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  parse_as: FORMAL_PID_CONTROL_ONTOLOGY
  reasoning_mode: CLOSED_LOOP_DYNAMIC_RELATIONAL

  preserve:
    - typed_entities
    - PID_terms
    - gain_parameters
    - feedback_direction
    - causal_dependencies
    - actuator_constraints
    - confidence
    - provenance

  infer:
    - error_response_paths
    - gain_performance_dependencies
    - tuning_requirements
    - saturation_conditions
    - windup_risk
    - disturbance_response
    - stability_dependencies

  prohibit:
    - invented_gain_values
    - assumed_stability
    - assumed_optimal_tuning
    - unsupported_performance_claims
    - assumed_zero_error
    - removal_of_actuator_limits

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
  + ONTOLOGY
  + CORE_ENTITIES
  + PID_STRUCTURE
  + PID_CONTROL_LAW
  + PROPORTIONAL_ACTION
  + INTEGRAL_ACTION
  + DERIVATIVE_ACTION
  + CONTROLLER_FORMS
  + FEEDBACK_LOOP
  + CONTROLLER_TUNING
  + PERFORMANCE
  + STABILITY
  + SATURATION_WINDUP
  + DISTURBANCE_RESPONSE
  + DIGITAL_PID
  + PID_REASONING
  + INFERENCE_RULES
  + SEMANTIC_RELATIONSHIPS
  + SEMANTIC_EQUIVALENCE
  + CONFIDENCE
  + UPDATE_MODEL
  + AI_CONSUMPTION

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

END FLOW