Stability Analysis Ontology

flow "StabilityAnalysisOntology" v1.0

# STABILITY ANALYSIS ONTOLOGY — FLOW ALGEBRA
SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/ai-computational-analysis/stability-analysis-ontology-2.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "AI Computational Analysis"
ENTITY := "Stability Analysis"

STABILITY_ANALYSIS := {
 type: ComputationalStabilityFramework,
 domain: AIComputationalAnalysis,
 purpose: "Analyse whether mathematical models, dynamical systems and numerical algorithms remain controlled under perturbations, discretisation, rounding errors, parameter changes and repeated computation."
}

CONCEPTS := {
 STABILITY_ANALYSIS,
 PERTURBATION,
 DYNAMICAL_STABILITY,
 NUMERICAL_STABILITY,
 CONDITIONING,
 ERROR_PROPAGATION,
 EIGENVALUE,
 SPECTRAL_RADIUS,
 LYAPUNOV_STABILITY,
 ABSOLUTE_STABILITY,
 A_STABILITY,
 CFL_CONDITION,
 VON_NEUMANN_ANALYSIS,
 BACKWARD_STABILITY,
 ROBUSTNESS,
 CONVERGENCE
}

# ---------- GENERAL STABILITY ----------
system or algorithm:

INPUT
 ->
PROCESS
 ->
OUTPUT

perturb input:

x
 ->
x+delta_x

observe:

y
 ->
y+delta_y

STABILITY
 -> controlled_response_to(PERTURBATION)

STABILITY_ANALYSIS
 -> identify(PERTURBATION_GROWTH_OR_DECAY)

# ---------- STABILITY TYPES ----------
STABILITY_ANALYSIS
 -> distinguish(
 DYNAMICAL_STABILITY,
 NUMERICAL_STABILITY,
 PROBLEM_CONDITIONING,
 ROBUSTNESS
)

DYNAMICAL_STABILITY
 -> property_of(MATHEMATICAL_EVOLUTION)

NUMERICAL_STABILITY
 -> property_of(COMPUTATIONAL_METHOD)

CONDITIONING
 -> property_of(MATHEMATICAL_PROBLEM)

# ---------- LINEAR DYNAMICAL SYSTEM ----------
continuous:

dx/dt
 =
A*x

solution:

x(t)
 =
exp(A*t)*x_0

if all eigenvalues satisfy

Re(lambda_i)<0

then

origin
 -> ASYMPTOTICALLY_STABLE

if any

Re(lambda_i)>0

then

origin
 -> UNSTABLE

# ---------- DISCRETE DYNAMICAL SYSTEM ----------
x_(n+1)
 =
A*x_n

solution:

x_n
 =
A^n*x_0

if

spectral_radius(A)<1

then

origin
 -> ASYMPTOTICALLY_STABLE

if

spectral_radius(A)>1

then

origin
 -> UNSTABLE

BOUNDARY_CASE
 -> requires(FURTHER_ANALYSIS)

# ---------- SPECTRAL RADIUS ----------
rho(A)
 :=
max_i(
 |lambda_i(A)|
)

SPECTRAL_RADIUS
 -> controls(ASYMPTOTIC_POWER_BEHAVIOUR)
    in linear discrete systems

rho(A)<1
 -> powers_decay

# ---------- NONLINEAR LINEARISATION ----------
nonlinear system:

dx/dt
 =
f(x)

equilibrium:

f(x_star)=0

Jacobian:

J
 :=
Df(x_star)

LINEARISATION
 -> local_approximation

eigenvalues of J
 -> classify(HYPERBOLIC_LOCAL_STABILITY)

NONHYPERBOLIC_CASE
 -> linear_test_inconclusive

# ---------- LYAPUNOV STABILITY ----------
equilibrium x_star

-> LYAPUNOV_STABLE

if

for every epsilon>0
exists delta>0

such_that

||x(0)-x_star||<delta

implies

||x(t)-x_star||<epsilon

for all future t

LYAPUNOV_ANALYSIS
 -> nonlinear_stability_framework

# ---------- LYAPUNOV FUNCTION ----------
V(x)
 -> positive_definite

V_dot(x)
 -> negative_semidefinite

then

equilibrium
 -> STABLE

if

V_dot
 -> negative_definite

then

equilibrium
 -> ASYMPTOTICALLY_STABLE

under standard hypotheses

# ---------- NUMERICAL ERROR ----------
exact state:

x_n

computed state:

x_tilde_n

error:

e_n
 :=
x_tilde_n-x_n

NUMERICAL_STABILITY
 -> controls(GROWTH_OF_e_n)

sources:
 ROUNDING_ERROR
 TRUNCATION_ERROR
 ITERATION_ERROR
 DATA_ERROR

# ---------- ERROR RECURRENCE ----------
linear numerical propagation:

e_(n+1)
 =
M*e_n
+
tau_n

M
 -> ERROR_PROPAGATION_MATRIX

stability
 -> depends_on(POWERS_OF_M)

SPECTRAL_AND_NORM_ANALYSIS
 -> quantify(ERROR_AMPLIFICATION)

# ---------- CONDITIONING ----------
problem:

y
 =
F(x)

condition number:

kappa
 -> input_output_sensitivity

ILL_CONDITIONED_PROBLEM
 -> amplifies(INPUT_ERROR)

STABLE_ALGORITHM
 -/> fixes(INTRINSIC_ILL_CONDITIONING)

CONDITIONING
 and
NUMERICAL_STABILITY
 -> separate_sources_of(ERROR)

# ---------- BACKWARD STABILITY ----------
computed result
 y_tilde

is exact solution to

nearby input
 x+delta_x

BACKWARD_ERROR
 -> size_of(delta_x)

BACKWARD_STABLE_ALGORITHM
 -> solves(NEARBY_PROBLEM_EXACTLY)

FORWARD_ERROR
 -> bounded_by(CONDITIONING_TIMES_BACKWARD_ERROR)
    approximately under suitable assumptions

# ---------- TEST EQUATION ----------
ODE stability model:

y_prime
 =
lambda*y

Re(lambda)<0

numerical method produces:

y_(n+1)
 =
R(z)*y_n

where

z
 :=
h*lambda

R(z)
 -> STABILITY_FUNCTION

# ---------- ABSOLUTE STABILITY REGION ----------
S
 :=
{
 z in C :
 |R(z)|<=1
}

ABSOLUTE_STABILITY_REGION
 -> step_eigenvalue_values_not_amplified

NUMERICAL_STEP
 -> stable_for_test_mode_if(h*lambda in S)

# ---------- EXPLICIT EULER ----------
R(z)
 =
1+z

stable if

|1+z|
 <=
1

EXPLICIT_EULER
 -> bounded_stability_region

STIFF_PROBLEM
 -> may_require(VERY_SMALL_h)

# ---------- IMPLICIT EULER ----------
R(z)
 =
1/(1-z)

for
 Re(z)<=0

|R(z)|
 <=
1

IMPLICIT_EULER
 -> A_STABLE

and
 -> L_STABLE

# ---------- A-STABILITY ----------
method
 -> A_STABLE

if

left_half_complex_plane
 subset_of
ABSOLUTE_STABILITY_REGION

A_STABILITY
 -> desirable_for(STIFF_DECAYING_MODES)

# ---------- L-STABILITY ----------
A_STABLE_METHOD
 +
R(z)->0
as
|z|->infinity
within relevant left-half-plane limit

-> L_STABLE

L_STABILITY
 -> strongly_damps(VERY_STIFF_MODES)

# ---------- PDE STABILITY ----------
PDE discretisation

-> amplification of spatial modes

VON_NEUMANN_ANALYSIS
 -> insert(FOURIER_MODE)

u_j^n
 =
G^n
*
exp(i*k*j*Delta_x)

G
 -> AMPLIFICATION_FACTOR

stability typically requires

|G|
 <=
1

for all resolvable modes
 under appropriate norm/context

# ---------- CFL CONDITION ----------
hyperbolic explicit scheme:

numerical_domain_of_dependence
 -> must_cover(PHYSICAL_DOMAIN_OF_DEPENDENCE)

CFL_NUMBER:

C
 :=
a*Delta_t/Delta_x

stability
 -> often requires(C<=C_max)

CFL_CONDITION
 -> necessary_condition_for_many_explicit_hyperbolic_schemes

# ---------- DIFFUSION STABILITY ----------
explicit heat/diffusion scheme in 1D:

r
 :=
D*Delta_t/Delta_x^2

FTCS stability:

r<=1/2

PARABOLIC_EXPLICIT_METHOD
 -> time_step_scales_with(Delta_x^2)

# ---------- MATRIX STABILITY ----------
iteration:

x_(k+1)
 =
M*x_k+c

converges if

rho(M)<1

ITERATIVE_LINEAR_SOLVER
 -> stability_and_convergence_linked_to(ITERATION_MATRIX)

# ---------- GRADIENT DESCENT STABILITY ----------
quadratic objective:

f(x)
 =
1/2*x^T*A*x

gradient update:

x_(k+1)
 =
(
I-alpha*A
)
*x_k

stability/convergence if

rho(
 I-alpha*A
)
 <1

for SPD A:

0<alpha<2/lambda_max(A)

OPTIMISATION_STEP_SIZE
 -> stability_condition

# ---------- MACHINE LEARNING ----------
training dynamics
 -> iterative_parameter_system

large learning rate
 -> oscillation_or_divergence

small learning rate
 -> stable_but_slow_updates

GRADIENT_NORM
 -> may_explode_or_vanish

AI_STABILITY_ANALYSIS
 -> examines(TRAINING_DYNAMICS_AND_NUMERICAL_PRECISION)

# ---------- ROBUSTNESS ----------
model:

y
 =
F(x,theta)

perturb:

x+delta_x
theta+delta_theta

ROBUSTNESS
 -> bounded_change_in(OUTPUT_OR_DECISION)

ROBUST_STABILITY
 -> stability_under(MODEL_AND_PARAMETER_UNCERTAINTY)

# ---------- PSEUDOSPECTRUM ----------
for nonnormal matrix A:

small perturbation
 -> eigenvalues_may_move_substantially

PSEUDOSPECTRUM
 -> analyses(SPECTRAL_SENSITIVITY)

EIGENVALUES_ALONE
 -/> always_capture(TRANSIENT_GROWTH)

NONNORMALITY
 -> may_generate(LARGE_TRANSIENT_AMPLIFICATION)

# ---------- TRANSIENT GROWTH ----------
even if asymptotically stable:

||exp(A*t)||
 -> may_initially_grow

TRANSIENT_GROWTH
 -> important_in(NONNORMAL_SYSTEMS)

ASYMPTOTIC_STABILITY
 -/> monotonic_decay_in_every_norm

# ---------- ENERGY METHOD ----------
define energy/norm:

E(t)
 :=
||u(t)||^2

derive:

dE/dt
 <=
C*E

GRONWALL_INEQUALITY
 -> bound(E(t))

ENERGY_ESTIMATE
 -> stability_without(EXPLICIT_SPECTRAL_DECOMPOSITION)

# ---------- GRONWALL ----------
if

u(t)
 <=
a
+
integral_0^t(
 b(s)*u(s)
 ds
)

then

u(t)
 <=
a
*
exp(
 integral_0^t b(s) ds
)

under standard nonnegative assumptions

GRONWALL
 -> controls(PERTURBATION_GROWTH)

# ---------- CONVERGENCE RELATION ----------
for many numerical schemes:

CONSISTENCY
 +
STABILITY
 -> CONVERGENCE

but

exact theorem
 -> depends_on(PROBLEM_CLASS_AND_DISCRETISATION)

STABILITY
 -> necessary_component_of(RELIABLE_REFINEMENT)

# ---------- PRECISION ----------
FLOATING_POINT
 -> introduces(ROUNDING_PERTURBATIONS)

low precision
 -> larger_roundoff

mixed precision
 -> combines(SPEED_AND_ACCURACY)

STABILITY_ANALYSIS
 -> determines(IF_ERRORS_ARE_AMPLIFIED)

# ---------- APPLICATIONS ----------
STABILITY_ANALYSIS
 -> applied_to(NUMERICAL_ANALYSIS)
 -> applied_to(DYNAMICAL_SYSTEMS)
 -> applied_to(ODE_SOLVERS)
 -> applied_to(PDE_SOLVERS)
 -> applied_to(OPTIMISATION)
 -> applied_to(MACHINE_LEARNING)
 -> applied_to(CONTROL)
 -> applied_to(SCIENTIFIC_COMPUTING)

# ---------- RELATION GRAPH ----------
PERTURBATION
 -> generates(ERROR_OR_STATE_DEVIATION)

DYNAMICAL_SYSTEM
 -> analysed_by(LYAPUNOV_AND_SPECTRAL_METHODS)

NUMERICAL_METHOD
 -> analysed_by(AMPLIFICATION_AND_STABILITY_REGION)

CONDITIONING
 -> determines(PROBLEM_SENSITIVITY)

ALGORITHM_STABILITY
 -> determines(ERROR_PROPAGATION)

STEP_SIZE
 -> affects(NUMERICAL_AND_OPTIMISATION_STABILITY)

NONNORMALITY
 -> causes(TRANSIENT_GROWTH)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
 "stability analysis" ~= "analysis of whether perturbations remain controlled under evolution or computation",
 "numerical stability" ~= "resistance of an algorithm to amplification of computational errors",
 "absolute stability region" ~= "set of scaled eigenvalues for which a time-stepping method does not amplify the linear test equation",
 "A-stability" ~= "property that a time-stepping method contains the entire left half-plane in its absolute stability region",
 "backward stability" ~= "property that a computed answer is exact for a nearby input problem",
 "spectral radius" ~= "largest absolute eigenvalue of a matrix"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
 dynamical_stability_numerical_stability_and_conditioning_are_distinct: true,
 eigenvalue_tests_require_system_and_normality_context: true,
 nonnormal_systems_can_show_transient_growth_despite_asymptotic_stability: true,
 absolute_stability_depends_on_method_step_size_and_problem_spectrum: true,
 CFL_conditions_are_scheme_and_equation_dependent: true,
 stable_algorithm_cannot_remove_intrinsic_problem_ill_conditioning: true,
 numerical_stability_claims_require_defined_norm_error_model_and_discretisation: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
 core_definition: 0.99,
 spectral_relation: 0.99,
 numerical_stability_relation: 0.99,
 conditioning_backward_relation: 0.99,
 ODE_PDE_relation: 0.99,
 nonnormal_transient_relation: 0.98,
 semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
 identify(system_algorithm_problem_and_perturbation_type)
 -> distinguish(dynamical_numerical_conditioning_or_robustness_context)
 -> linearise_or_construct(error_propagation_operator_if_relevant)
 -> compute(eigenvalues_spectral_radius_or_amplification_factor)
 -> analyse(step_size_and_absolute_stability_region)
 -> test(CFL_or_diffusive_restrictions_for_PDE_discretisation)
 -> evaluate(condition_number_backward_error_and_forward_error)
 -> inspect(nonnormality_transient_growth_and_energy_bounds)
 -> refine(step_method_precision_or_preconditioning_if_needed)
 -> validate(norm_boundary_initial_and_discretisation_assumptions)
 -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
 parse_as: "typed stability-analysis semantic graph",
 primary_entity: STABILITY_ANALYSIS,
 preserve: [
  system_or_algorithm,
  perturbation,
  norm,
  time_step,
  discretisation,
  spectrum,
  conditioning,
  precision,
  boundary_conditions
 ],
 infer_through: [
  eigenvalues,
  spectral_radius,
  Lyapunov_stability,
  error_propagation,
  absolute_stability_regions,
  A_stability,
  CFL_conditions,
  backward_errors,
  pseudospectra
 ],
 avoid: [
  conflating_problem_conditioning_with algorithm stability,
  using_eigenvalues_alone_for strongly nonnormal transient behavior,
  declaring_scheme_stable_without step_size context,
  treating_CFL_as universal sufficient condition,
  ignoring_boundary_conditions_in PDE stability,
  assuming_asymptotic_stability_means monotonic decay
 ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
 validate(new_information)
 -> identify(stability_analysis_context)
 -> compare(existing_relations)
 -> preserve(system_perturbation_norm_step_spectrum_conditioning_and_precision_invariants)
 -> update(affected_entities)
 -> update(affected_edges)
 -> recompute(CONFIDENCE)
 -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
 SOURCE_URL
 + ENTITY
 + CONCEPTS
 + STABILITY_ANALYSIS
 + PERTURBATION
 + DYNAMICAL_STABILITY
 + NUMERICAL_STABILITY
 + CONDITIONING
 + ERROR_PROPAGATION
 + SPECTRAL_RADIUS
 + LYAPUNOV_STABILITY
 + ABSOLUTE_STABILITY
 + A_STABILITY
 + CFL_CONDITION
 + BACKWARD_STABILITY
 + SEMANTIC_EQUIVALENCE
 + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
 -> STABILITY_ANALYSIS
 -> CONTEXT_IDENTIFICATION
 -> STABILITY_TYPE_CLASSIFICATION
 -> PROPAGATION_OPERATOR_ANALYSIS
 -> SPECTRAL_AMPLIFICATION_ANALYSIS
 -> STEP_SIZE_STABILITY_ANALYSIS
 -> PDE_RESTRICTION_ANALYSIS
 -> CONDITIONING_ERROR_ANALYSIS
 -> TRANSIENT_ENERGY_ANALYSIS
 -> METHOD_REFINEMENT
 -> HYPOTHESIS_VALIDATION
 -> RECURSIVE_REASONING(query)
 -> CONFIDENCE
 -> OUTPUT(semantic_result)

END FLOW