Numerical Convergence Ontology

flow "NumericalConvergenceOntology" v1.0

# ============================================================
# NUMERICAL CONVERGENCE ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/numerical-calculus/numerical-convergence-ontology-2.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Numerical Calculus"
ENTITY := "Numerical Convergence"

# ---------- CORE ENTITY ----------
NUMERICAL_CONVERGENCE := {
    type: NumericalApproximationProperty,
    domain: NumericalCalculus,
    purpose: "Describe whether and how a sequence of numerical approximations approaches the exact mathematical solution as discretisation, iteration or approximation parameters are refined."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    NUMERICAL_CONVERGENCE,
    APPROXIMATION_SEQUENCE,
    EXACT_SOLUTION,
    ERROR,
    GRID_REFINEMENT,
    STEP_SIZE,
    ITERATION,
    ORDER_OF_CONVERGENCE,
    RATE_OF_CONVERGENCE,
    CONSISTENCY,
    STABILITY,
    ASYMPTOTIC_REGIME,
    RESIDUAL,
    TOLERANCE,
    FIXED_POINT
}

# ---------- BASIC DEFINITION ----------
let
    u
        -> EXACT_SOLUTION

and
    u_h
        -> NUMERICAL_APPROXIMATION

NUMERICAL_CONVERGENCE
    -> holds_if

||u_h-u||
    -> 0

as

h
    -> 0

in
    specified_norm

CONVERGENCE
    -> requires(LIMITING_APPROXIMATION_MATCHES_EXACT_SOLUTION)

# ---------- PARAMETER GENERIC FORM ----------
approximation
    A_n

-> converges_to(A)

if

lim_(n->infinity)
||A_n-A||
    = 0

REFINEMENT_PARAMETER
    -> may_be(
        GRID_SIZE,
        TIME_STEP,
        POLYNOMIAL_ORDER,
        ITERATION_COUNT,
        SAMPLE_COUNT
    )

# ---------- ERROR ----------
e_h
    :=
u-u_h

CONVERGENCE
    iff

||e_h||
    -> 0

ERROR
    -> primary_measure_of(CONVERGENCE)

# ---------- NORM DEPENDENCE ----------
possible norms:
    L1
    L2
    L_INFINITY
    ENERGY_NORM
    DISCRETE_NORM

CONVERGENCE_IN_ONE_NORM
    -/> automatically(CONVERGENCE_IN_ALL_NORMS)

NORM
    -> must_be_specified

# ---------- ORDER OF CONVERGENCE ----------
if

||e_h||
    =
C*h^p
+
o(h^p)

then

p
    -> ORDER_OF_CONVERGENCE

h
    -> characteristic_discretisation_parameter

ORDER_p
    -> error_reduction_rate_under(REFINEMENT)

# ---------- REFINEMENT RATIO ----------
if

h_2
    =
h_1/r

then asymptotically:

E(h_2)
/
E(h_1)
    approx
r^(-p)

therefore

p
    approx
log(
    E(h_1)/E(h_2)
)
/
log(r)

OBSERVED_ORDER
    -> estimated_from(MULTIPLE_REFINEMENTS)

# ---------- ASYMPTOTIC REGIME ----------
ORDER_ESTIMATE
    -> meaningful_when(LEADING_ERROR_TERM_DOMINATES)

coarse_grid
    -> may_not_be(ASYMPTOTIC)

very_fine_grid
    -> may_be_contaminated_by(ROUNDING_ERROR)

ASYMPTOTIC_REGIME
    -> intermediate_refinement_region_where(THEORETICAL_SCALING_VISIBLE)

# ---------- LINEAR CONVERGENCE ----------
iterative sequence
    x_k -> x_star

LINEAR_CONVERGENCE
    if

limsup(
    ||x_(k+1)-x_star||
    /
    ||x_k-x_star||
)
    =
rho

with
    0 < rho < 1

ERROR
    -> reduced_by_approximately(CONSTANT_FACTOR_PER_ITERATION)

# ---------- SUPERLINEAR ----------
SUPERLINEAR_CONVERGENCE
    if

||e_(k+1)||
/
||e_k||
    -> 0

SUPERLINEAR
    -> faster_than(FIXED_LINEAR_RATE)

# ---------- QUADRATIC ----------
QUADRATIC_CONVERGENCE
    if

||e_(k+1)||
    <=
C
*
||e_k||^2

near solution

NEWTON_METHOD
    -> often_quadratically_convergent
       under(STANDARD_LOCAL_HYPOTHESES)

# ---------- GENERAL ITERATION ORDER ----------
sequence
    x_k -> x_star

has order q if

lim(
    ||e_(k+1)||
    /
    ||e_k||^q
)
    =
lambda

where

0 < lambda < infinity

q
    -> ITERATIVE_ORDER_OF_CONVERGENCE

# ---------- FIXED POINT ----------
iteration:

x_(k+1)
    =
g(x_k)

fixed point:

x_star
    =
g(x_star)

if

|g_prime(x_star)|
    < 1

then

local_convergence
    -> typically(LINEAR)

CONTRACTION_MAPPING
    -> guarantees(CONVERGENCE_UNDER_CONTRACTION_HYPOTHESES)

# ---------- CONSISTENCY ----------
discrete operator
    L_h

approximates
    continuous operator
    L

CONSISTENCY
    if

L_h(u)
    -> L(u)

as
    h -> 0

for sufficiently smooth u

CONSISTENCY
    -> local_approximation_correctness

# ---------- STABILITY ----------
STABILITY
    -> bounded_response_to(PERTURBATIONS)

perturbations may arise from:
    INITIAL_DATA
    ROUNDING
    TRUNCATION
    FORCING
    ITERATIVE_ERROR

STABILITY
    -> controls(ERROR_PROPAGATION)

# ---------- CONSISTENCY + STABILITY ----------
for suitable well-posed linear initial-value problems:

CONSISTENCY
    + STABILITY
    -> CONVERGENCE

LAX_EQUIVALENCE_THEOREM
    -> establishes_equivalence_of(STABILITY_AND_CONVERGENCE)
       for(CONSISTENT_LINEAR_FINITE_DIFFERENCE_SCHEMES_UNDER_ITS_HYPOTHESES)

# ---------- LOCAL / GLOBAL ERROR ----------
LOCAL_TRUNCATION_ERROR
    -> error_generated_per_step_or_operator_application

GLOBAL_ERROR
    -> accumulated_solution_error

LOCAL_ORDER
    -/> always_identical_to(GLOBAL_ORDER)

STABILITY
    -> determines(HOW_LOCAL_ERRORS_PROPAGATE)

# ---------- ODE CONVERGENCE ----------
ODE method:

y_(n+1)
    =
Phi(
    h,
    t_n,
    y_n
)

CONVERGENCE
    -> y_n approaches y(t_n)

as
    h -> 0

for fixed finite interval

ONE_STEP_METHOD
    -> consistency_plus_stability_conditions_support_convergence

# ---------- MULTISTEP METHODS ----------
LINEAR_MULTISTEP_METHOD
    -> requires(CONSISTENCY)
    -> requires(ZERO_STABILITY)

DAHLQUIST_EQUIVALENCE
    -> consistency_plus_zero_stability
       iff convergence
       for(LINEAR_MULTISTEP_METHODS)

ROOT_CONDITION
    -> characterises(ZERO_STABILITY)

# ---------- PDE GRID CONVERGENCE ----------
mesh size
    h

time step
    Delta_t

numerical solution
    u_(h,Delta_t)

convergence:

||u_(h,Delta_t)-u||
    -> 0

as

h -> 0
and
Delta_t -> 0

subject_to
    stability_relation_between_parameters_if_required

# ---------- CFL RELATION ----------
for many hyperbolic explicit schemes:

Delta_t
    and
h

-> constrained_by(CFL_CONDITION)

REFINEMENT_PATH
    -> must_remain_in(STABLE_PARAMETER_REGION)

CONVERGENCE_TEST
    -> preserve(STABILITY_CONDITION)

# ---------- FINITE ELEMENT CONVERGENCE ----------
finite element space
    V_h

u_h in V_h

as
    h -> 0

approximation_space
    -> becomes_richer

CEA_LEMMA
    -> bounds(FEM_ERROR_BY_BEST_APPROXIMATION_ERROR)
       under(COERCIVITY_AND_CONTINUITY)

APPROXIMATION_PROPERTY
    -> yields(CONVERGENCE)

# ---------- SPECTRAL CONVERGENCE ----------
mode count
    N -> infinity

for analytic smooth solution:

error
    -> may_decay(EXPONENTIALLY_OR_GEOMETRICALLY)

for finite regularity:

error
    -> often_algebraic

SPECTRAL_CONVERGENCE
    -> strongly_depends_on(REGULARITY)

# ---------- MONTE CARLO CONVERGENCE ----------
sample count
    N

Monte_Carlo_error
    -> O(N^(-1/2))
       in(ROOT_MEAN_SQUARE_UNDER_STANDARD_ASSUMPTIONS)

CONVERGENCE
    -> statistical

CONFIDENCE_INTERVAL
    -> quantifies(SAMPLING_UNCERTAINTY)

# ---------- RESIDUAL CONVERGENCE ----------
iterative solver:

residual
    r_k
    :=
b-A*x_k

r_k -> 0

RESIDUAL_CONVERGENCE
    -/> necessarily_small_solution_error_for(ILL_CONDITIONED_SYSTEM)

SOLUTION_ERROR
    -> linked_to(RESIDUAL_BY(A_inverse_AND_CONDITIONING)

# ---------- STOPPING CRITERION ----------
iteration
    -> stop_when

||r_k||
    <= tolerance

or

||x_(k+1)-x_k||
    <= tolerance

STOPPING_CRITERION
    -> practical_proxy_for(CONVERGENCE)

TOLERANCE
    -/> exact_error_guarantee_without(ERROR_RELATION)

# ---------- GRID CONVERGENCE STUDY ----------
compute solutions:

u_h
u_(h/r)
u_(h/r^2)

compare:
    solution_difference
    error_norm
    observed_order

GRID_CONVERGENCE_STUDY
    -> verifies(REFINEMENT_BEHAVIOUR)

# ---------- RICHARDSON EXTRAPOLATION ----------
if

Q_h
    =
Q
+
C*h^p
+
higher_order_terms

then

Q_extrapolated
    :=
Q_(h/r)
+
[
    Q_(h/r)-Q_h
]
/
(
    r^p-1
)

RICHARDSON_EXTRAPOLATION
    -> estimates(LIMITING_SOLUTION_AND_ERROR)

requires
    ASYMPTOTIC_ERROR_MODEL

# ---------- ROUNDING LIMIT ----------
as
    h -> very_small

DISCRETISATION_ERROR
    -> decreases

ROUNDING_ERROR
    -> may_increase_or_dominate

OBSERVED_CONVERGENCE
    -> may_stagnate_or_reverse

FINITE_PRECISION
    -> imposes(PRACTICAL_REFINEMENT_LIMIT)

# ---------- DIVERGENCE ----------
if

approximation_sequence
    -/> approach(EXACT_SOLUTION)

then

method_or_parameter_sequence
    -> DIVERGENT

causes may include:
    INSTABILITY
    INCONSISTENCY
    WRONG_BRANCH
    INADEQUATE_RESOLUTION
    NONCONVERGENT_ITERATION
    ROUNDING_DOMINATION

# ---------- APPLICATIONS ----------
NUMERICAL_CONVERGENCE
    -> applied_to(NUMERICAL_DIFFERENTIATION)
    -> applied_to(NUMERICAL_INTEGRATION)
    -> applied_to(ODE_SOLVERS)
    -> applied_to(PDE_SOLVERS)
    -> applied_to(FINITE_DIFFERENCE_METHODS)
    -> applied_to(FINITE_ELEMENT_METHODS)
    -> applied_to(SPECTRAL_METHODS)
    -> applied_to(ITERATIVE_SOLVERS)

# ---------- RELATION GRAPH ----------
REFINEMENT_PARAMETER
    -> controls(APPROXIMATION_SEQUENCE)

APPROXIMATION_SEQUENCE
    -> compared_with(EXACT_SOLUTION)

ERROR
    -> measures(CONVERGENCE)

ORDER_OF_CONVERGENCE
    -> measures(ERROR_DECAY_RATE)

CONSISTENCY
    -> ensures(CORRECT_LOCAL_LIMIT)

STABILITY
    -> controls(ERROR_PROPAGATION)

GRID_REFINEMENT
    -> reveals(ASYMPTOTIC_BEHAVIOUR)

ROUNDING_ERROR
    -> limits(PRACTICAL_CONVERGENCE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "numerical convergence" ~= "approach of numerical approximations to the exact solution under systematic refinement",
    "order of convergence" ~= "asymptotic rate at which numerical error decreases",
    "grid convergence" ~= "approach of a discretised solution to a limiting solution as the mesh is refined",
    "linear convergence" ~= "iterative convergence with approximately constant error-reduction factor",
    "quadratic convergence" ~= "iterative convergence where the next error is proportional to the square of the current error",
    "asymptotic regime" ~= "refinement range where the leading theoretical error model dominates"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    convergence_must_be_defined_with_respect_to_parameter_and_norm: true,
    observed_order_requires_asymptotic_regime: true,
    residual_convergence_does_not_automatically_imply_small_solution_error: true,
    consistency_alone_does_not_guarantee_convergence: true,
    refinement_must_respect_stability_conditions: true,
    finite_precision_can_limit_or_reverse_observed_convergence: true,
    theoretical_order_requires_method_specific_regularities_and_hypotheses: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    order_relation: 0.99,
    consistency_stability_relation: 0.99,
    iterative_convergence_relation: 0.99,
    grid_refinement_relation: 0.99,
    rounding_limit_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(numerical_method_and_target_solution)
    -> identify(refinement_or_iteration_parameter)
    -> identify(error_norm_and_reference_solution)
    -> construct(approximation_sequence)
    -> compute(error_or_successive_difference)
    -> estimate(observed_order_or_iteration_rate)
    -> test(asymptotic_regime)
    -> analyse(consistency_and_stability)
    -> verify(parameter_refinement_respects_stability_constraints)
    -> inspect(rounding_and_conditioning_effects)
    -> classify(convergent_stagnating_or_divergent_behaviour)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed numerical-convergence semantic graph",
    primary_entity: NUMERICAL_CONVERGENCE,
    preserve: [
        numerical_method,
        exact_or_reference_solution,
        approximation_sequence,
        refinement_parameter,
        norm,
        error,
        theoretical_order,
        stability_conditions
    ],
    infer_through: [
        grid_refinement,
        observed_order,
        consistency,
        stability,
        iterative_rates,
        Richardson_extrapolation,
        residual_analysis,
        finite_precision_limits
    ],
    avoid: [
        claiming_convergence_without specifying limiting process,
        inferring_order_from too_few_or_nonasymptotic refinements,
        equating_small_residual_with small_solution_error,
        refining_outside_stable_parameter_region,
        ignoring_norm_dependence,
        mistaking_roundoff_stagnation_for theoretical nonconvergence
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + NUMERICAL_CONVERGENCE
    + APPROXIMATION_SEQUENCE
    + ERROR
    + ORDER_OF_CONVERGENCE
    + CONSISTENCY
    + STABILITY
    + ASYMPTOTIC_REGIME
    + RICHARDSON_EXTRAPOLATION
    + TOLERANCE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> NUMERICAL_CONVERGENCE
    -> METHOD_TARGET_IDENTIFICATION
    -> REFINEMENT_PARAMETER_ANALYSIS
    -> NORM_REFERENCE_ANALYSIS
    -> APPROXIMATION_SEQUENCE_CONSTRUCTION
    -> ERROR_COMPUTATION
    -> ORDER_RATE_ESTIMATION
    -> ASYMPTOTIC_REGIME_ANALYSIS
    -> CONSISTENCY_STABILITY_ANALYSIS
    -> REFINEMENT_STABILITY_VALIDATION
    -> ROUNDING_CONDITIONING_ANALYSIS
    -> CONVERGENCE_CLASSIFICATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW