Spectral Methods Ontology

flow "SpectralMethodsOntology" v1.0

# ============================================================
# SPECTRAL METHODS ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
SPECTRAL_METHODS := {
    type: GlobalNumericalDiscretisationFramework,
    domain: NumericalCalculus,
    purpose: "Approximate functions and solutions of differential equations using global basis expansions, typically Fourier or orthogonal-polynomial modes, with very high accuracy for sufficiently smooth problems."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    SPECTRAL_METHOD,
    GLOBAL_BASIS,
    FOURIER_BASIS,
    CHEBYSHEV_POLYNOMIAL,
    LEGENDRE_POLYNOMIAL,
    SPECTRAL_COEFFICIENT,
    COLLOCATION,
    GALERKIN_METHOD,
    TAU_METHOD,
    PSEUDOSPECTRAL_METHOD,
    DIFFERENTIATION_MATRIX,
    TRANSFORM,
    ALIASING,
    SPECTRAL_CONVERGENCE,
    BOUNDARY_CONDITION
}

# ---------- GLOBAL APPROXIMATION ----------
u(x)
    approx
u_N(x)

u_N(x)
    :=
sum_from_k_0_to_N(
    a_k
    *
    phi_k(x)
)

phi_k
    -> GLOBAL_BASIS_FUNCTION

a_k
    -> SPECTRAL_COEFFICIENT

SPECTRAL_METHOD
    -> approximates_solution_by(GLOBAL_EXPANSION)

# ---------- BASIS SELECTION ----------
PERIODIC_DOMAIN
    -> FOURIER_BASIS

FINITE_NONPERIODIC_INTERVAL
    -> CHEBYSHEV_OR_LEGENDRE_BASIS

GEOMETRY_AND_BOUNDARY_STRUCTURE
    -> influence(BASIS_SELECTION)

BASIS
    -> chosen_to_match(PROBLEM_STRUCTURE)

# ---------- FOURIER SPECTRAL BASIS ----------
for periodic interval:

phi_k(x)
    :=
exp(i*k*x)

u_N(x)
    =
sum_from_k_minusN_to_N(
    a_k
    *
    exp(i*k*x)
)

FOURIER_BASIS
    -> diagonalises(CONSTANT_COEFFICIENT_DERIVATIVES)

# ---------- FOURIER DIFFERENTIATION ----------
if

u(x)
    =
sum_k(
    a_k*exp(i*k*x)
)

then

du/dx
    =
sum_k(
    i*k*a_k
    *
    exp(i*k*x)
)

DERIVATIVE
    -> multiplication_of(SPECTRAL_COEFFICIENT_BY_i_k)

higher derivative:

d^m u/dx^m
    -> coefficient_multiplier((i*k)^m)

# ---------- CHEBYSHEV POLYNOMIAL ----------
T_n(x)
    :=
cos(
    n*arccos(x)
)

for
    x in [-1,1]

CHEBYSHEV_POLYNOMIALS
    -> orthogonal_under(
        weight=1/sqrt(1-x^2)
    )

CHEBYSHEV_BASIS
    -> common_for(NONPERIODIC_FINITE_INTERVALS)

# ---------- CHEBYSHEV NODES ----------
Chebyshev-Lobatto points:

x_j
    :=
cos(
    pi*j/N
)

j=0,...,N

NODES
    -> clustered_near(ENDPOINTS)

ENDPOINT_CLUSTERING
    -> reduces(RUNGE_TYPE_INTERPOLATION_PROBLEMS)

# ---------- LEGENDRE BASIS ----------
P_n(x)
    -> LEGENDRE_POLYNOMIAL

orthogonal on
    [-1,1]

with weight
    1

LEGENDRE_SPECTRAL_METHOD
    -> alternative_orthogonal_polynomial_framework

# ---------- MODAL REPRESENTATION ----------
MODAL_FORM
    -> unknowns_are(SPECTRAL_COEFFICIENTS_a_k)

u_N
    =
sum_k(
    a_k*phi_k
)

MODAL_METHOD
    -> operates_in(COEFFICIENT_SPACE)

# ---------- NODAL REPRESENTATION ----------
NODAL_FORM
    -> unknowns_are(FUNCTION_VALUES_AT_COLLOCATION_NODES)

u_j
    :=
u(x_j)

TRANSFORM
    -> converts_between(NODAL_AND_MODAL_REPRESENTATIONS)

PSEUDOSPECTRAL_METHOD
    -> often_uses(NODAL_VALUES)

# ---------- SPECTRAL GALERKIN ----------
choose
    trial_space V_N

and
    test_space V_N

residual:

R_N
    :=
L(u_N)-f

GALERKIN_CONDITION:

<R_N,phi_j>
    = 0

for all basis/test modes

SPECTRAL_GALERKIN
    -> weighted_residual_method

# ---------- COLLOCATION ----------
choose
    collocation_points x_j

enforce

L(u_N)(x_j)
    =
f(x_j)

for all selected nodes

COLLOCATION_METHOD
    -> residual_zero_at(DISCRETE_POINTS)

# ---------- TAU METHOD ----------
TAU_METHOD
    -> enforce(residual_orthogonality_for_most_modes)
    -> replace_selected_equations_with(BOUNDARY_CONDITIONS)

TAU
    -> spectral_weighted_residual_method

# ---------- PSEUDOSPECTRAL ----------
PSEUDOSPECTRAL_METHOD
    -> evaluate(NONLINEAR_PRODUCTS_IN_PHYSICAL_OR_NODAL_SPACE)
    -> transform_between(PHYSICAL_AND_SPECTRAL_SPACE)

DERIVATIVES
    -> often_computed_in(SPECTRAL_SPACE)

NONLINEAR_TERMS
    -> often_computed_in(PHYSICAL_SPACE)

# ---------- DIFFERENTIATION MATRIX ----------
at collocation nodes:

u_prime_vector
    approx
D
*
u_vector

D
    -> SPECTRAL_DIFFERENTIATION_MATRIX

D_ij
    -> derivative_of(CARDINAL_BASIS_FUNCTION_j_AT_NODE_i)

DIFFERENTIATION_MATRIX
    -> dense_for(GLOBAL_SPECTRAL_METHODS)

# ---------- SECOND DERIVATIVE ----------
u_double_prime_vector
    approx
D2
*
u_vector

D2
    -> second_derivative_matrix

may_be
    D*D
or
    constructed_directly

BOUNDARY_TREATMENT
    -> modifies(DISCRETE_OPERATOR)

# ---------- SPECTRAL CONVERGENCE ----------
for sufficiently smooth analytic u:

error
    -> decreases(VERY_RAPIDLY_WITH_N)

often
    -> exponential_or_geometric_decay

SPECTRAL_CONVERGENCE
    -> faster_than(fixed_order_algebraic_convergence)
       for(SMOOTH_PROBLEMS)

# ---------- COEFFICIENT DECAY ----------
smoothness_of(u)
    -> reflected_in(DECAY_RATE_OF_SPECTRAL_COEFFICIENTS)

analytic_function
    -> rapid_coefficient_decay

limited_regularities
    -> slower_algebraic_decay

SPECTRAL_COEFFICIENTS
    -> diagnostic_of(SOLUTION_REGULARITY)

# ---------- GIBBS PHENOMENON ----------
if
    solution_has(DISCONTINUITY)

then

GLOBAL_SPECTRAL_APPROXIMATION
    -> oscillations_near_jump

GIBBS_PHENOMENON
    -> degrades(POINTWISE_ACCURACY_NEAR_DISCONTINUITY)

SPECTRAL_METHOD
    -> best_suited_to(SMOOTH_SOLUTIONS)

# ---------- ALIASING ----------
nonlinear product:

u*v

-> generates(HIGHER_FREQUENCY_MODES)

if modes exceed
    REPRESENTABLE_BANDWIDTH

then

HIGH_MODES
    -> fold_into(LOW_MODES)

ALIASING
    -> spectral_error_from(UNDERSAMPLED_NONLINEAR_INTERACTIONS)

# ---------- DEALIASING ----------
methods:
    THREE_HALVES_RULE
    TWO_THIRDS_FILTER
    OVERINTEGRATION
    SPECTRAL_FILTERING

DEALIASING
    -> reduces(NONLINEAR_ALIASING_ERROR)

# ---------- FFT RELATION ----------
FOURIER_PSEUDOSPECTRAL_METHOD
    -> uses(FFT)

physical_values
    -> FFT
    -> spectral_coefficients

spectral_coefficients
    -> inverse_FFT
    -> physical_values

FFT
    -> reduces(transform_cost_to(O(N_LOG_N)))

# ---------- CHEBYSHEV TRANSFORM ----------
CHEBYSHEV_COEFFICIENTS
    -> computable_via(COSINE_TRANSFORM)

FAST_COSINE_TRANSFORM
    -> efficient_modal_nodal_conversion

FAST_TRANSFORMS
    -> central_to(PRACTICAL_SPECTRAL_METHODS)

# ---------- BOUNDARY CONDITIONS ----------
PERIODIC_BOUNDARY
    -> naturally_matched_by(FOURIER_BASIS)

DIRICHLET
    -> enforce_at(ENDPOINT_NODES_OR_BASIS_CONSTRUCTION)

NEUMANN
    -> enforce(DERIVATIVE_CONSTRAINT)

BOUNDARY_CONDITION
    -> must_be_consistent_with(SPECTRAL_SPACE)

# ---------- DOMAIN MAPPING ----------
physical interval
    [a,b]

-> map_to
    [-1,1]

using affine transformation

x
    =
(a+b)/2
+
(b-a)/2
*
xi

DERIVATIVES
    -> scaled_by(MAPPING_JACOBIAN)

DOMAIN_MAPPING
    -> permits(STANDARD_REFERENCE_BASIS)

# ---------- MULTIDOMAIN SPECTRAL ----------
complex_or_nonsmooth_domain
    -> partition_into(SUBDOMAINS)

spectral approximation
    -> applied_per_subdomain

INTERFACE_CONDITIONS
    -> couple(SUBDOMAINS)

MULTIDOMAIN_SPECTRAL
    -> combines(LOCAL_GEOMETRIC_FLEXIBILITY_WITH_HIGH_ORDER_ACCURACY)

# ---------- SPECTRAL ELEMENT RELATION ----------
SPECTRAL_ELEMENT_METHOD
    -> high_order_polynomial_basis_on(MULTIPLE_ELEMENTS)

SPECTRAL_ELEMENT
    -> combines(FINITE_ELEMENT_GEOMETRIC_LOCALITY, SPECTRAL_HIGH_ORDER_ACCURACY)

SPECTRAL_METHOD
    and
FINITE_ELEMENT_METHOD
    -> related_but_distinct_discretisation_frameworks

# ---------- TIME-DEPENDENT PDE ----------
spatial spectral discretisation:

du_N/dt
    =
F_N(u_N,t)

TIME_STEPPER
    -> advances(SPECTRAL_OR_NODAL_COEFFICIENTS)

METHOD_OF_LINES
    -> spectral_in_space_plus(NUMERICAL_TIME_INTEGRATION)

# ---------- STIFFNESS ----------
high spectral modes
    -> large_derivative_eigenvalues

explicit_time_stepping
    -> may_face(SEVERE_STABILITY_RESTRICTIONS)

IMPLICIT_OR_IMEX_METHOD
    -> useful_for(STIFF_SPECTRAL_DISCRETISATIONS)

# ---------- POISSON EQUATION ----------
-LAPLACIAN(u)
    =
f

spectral expansion
    -> derivative_operator_in_basis_space

for Fourier periodic case:

|k|^2
*
u_hat_k
    =
f_hat_k

for
    k != 0

SPECTRAL_OPERATOR
    -> may_be(DIAGONAL_IN_FOURIER_SPACE)

# ---------- CONDITIONING ----------
HIGH_ORDER_GLOBAL_DIFFERENTIATION_MATRIX
    -> may_be(ILL_CONDITIONED)

CONDITION_NUMBER
    -> grows_with(N)

PRECONDITIONING
    -> may_be_required_for(LARGE_SYSTEMS)

NUMERICAL_STABILITY
    -> implementation_dependent

# ---------- FILTERING ----------
spectral coefficients
    -> multiply_by(FILTER_sigma_k)

high modes
    -> selectively_damped

SPECTRAL_FILTER
    -> controls(HIGH_FREQUENCY_NOISE_OR_GIBBS_OSCILLATIONS)

FILTERING
    -> modifies(SOLUTION_AND_ACCURACY)

# ---------- APPLICATIONS ----------
SPECTRAL_METHODS
    -> applied_to(FLUID_DYNAMICS)
    -> applied_to(WAVE_PROPAGATION)
    -> applied_to(WEATHER_AND_CLIMATE_MODELS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(ASTROPHYSICS)
    -> applied_to(PDE_SOLVERS)
    -> applied_to(STABILITY_ANALYSIS)
    -> applied_to(SCIENTIFIC_COMPUTING)

# ---------- RELATION GRAPH ----------
FUNCTION
    -> expanded_in(GLOBAL_BASIS)

GLOBAL_BASIS
    -> produces(SPECTRAL_COEFFICIENTS)

FOURIER_BASIS
    -> suits(PERIODIC_PROBLEMS)

CHEBYSHEV_BASIS
    -> suits(FINITE_NONPERIODIC_INTERVALS)

COLLOCATION
    -> enforces(PDE_AT_NODES)

GALERKIN
    -> enforces(RESIDUAL_ORTHOGONALITY)

FFT
    -> accelerates(FOURIER_SPECTRAL_TRANSFORMS)

SMOOTHNESS
    -> controls(SPECTRAL_CONVERGENCE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "spectral method" ~= "global high-order numerical approximation using basis-function expansions",
    "spectral coefficient" ~= "coefficient of a global basis mode in a spectral expansion",
    "pseudospectral method" ~= "spectral method combining nodal evaluation with spectral differentiation or transforms",
    "spectral collocation" ~= "enforcement of a differential equation at selected global interpolation nodes",
    "spectral convergence" ~= "very rapid convergence with increasing mode count for sufficiently smooth functions",
    "dealiasing" ~= "removal or reduction of nonlinear spectral aliasing errors"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    spectral_accuracy_depends_strongly_on_solution_smoothness: true,
    basis_choice_must_match_domain_and_boundary_structure: true,
    discontinuities_can_generate_Gibbs_phenomenon: true,
    nonlinear_terms_can_generate_aliasing_without_sufficient_resolution_or_dealiasing: true,
    differentiation_matrices_can_be_dense_and_ill_conditioned: true,
    boundary_conditions_must_be_enforced_consistently_with_basis: true,
    spectral_and_spectral_element_methods_are_related_but_not_identical: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    basis_relation: 0.99,
    Galerkin_collocation_relation: 0.99,
    convergence_relation: 0.99,
    aliasing_relation: 0.99,
    FFT_PDE_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(PDE_function_domain_and_boundary_conditions)
    -> assess(periodicity_geometry_and_solution_smoothness)
    -> choose(Fourier_Chebyshev_Legendre_or_other_basis)
    -> choose(Galerkin_collocation_tau_or_pseudospectral_form)
    -> construct(nodes_basis_and_transforms)
    -> construct(spectral_derivative_operator)
    -> impose(boundary_conditions)
    -> discretise(linear_and_nonlinear_terms)
    -> apply(dealiasing_if_needed)
    -> solve(discrete_system_or_advance_in_time)
    -> inspect(coefficient_decay_error_and_conditioning)
    -> validate(resolution_stability_and_basis_compatibility)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed spectral-method semantic graph",
    primary_entity: SPECTRAL_METHODS,
    preserve: [
        domain,
        boundary_conditions,
        basis_family,
        mode_count,
        collocation_nodes,
        representation_type,
        transform,
        regularity,
        time_stepper
    ],
    infer_through: [
        Fourier_spectral_methods,
        Chebyshev_methods,
        Legendre_methods,
        Galerkin_methods,
        collocation,
        differentiation_matrices,
        spectral_convergence,
        aliasing_and_dealiasing
    ],
    avoid: [
        assuming_exponential_convergence_for nonsmooth solution,
        using_Fourier_basis_for nonperiodic boundaries_without treatment,
        ignoring_aliasing_in nonlinear equations,
        confusing_modal_and_nodal representations,
        ignoring_conditioning_of high_order differentiation matrices,
        treating_spectral_element_as identical_to global spectral method
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + SPECTRAL_METHODS
    + GLOBAL_BASIS
    + FOURIER_BASIS
    + CHEBYSHEV_POLYNOMIAL
    + GALERKIN_METHOD
    + COLLOCATION
    + PSEUDOSPECTRAL_METHOD
    + DIFFERENTIATION_MATRIX
    + ALIASING
    + SPECTRAL_CONVERGENCE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> SPECTRAL_METHODS
    -> PROBLEM_DOMAIN_IDENTIFICATION
    -> PERIODICITY_REGULARITY_ANALYSIS
    -> BASIS_SELECTION
    -> FORMULATION_SELECTION
    -> NODE_TRANSFORM_CONSTRUCTION
    -> DIFFERENTIATION_OPERATOR_CONSTRUCTION
    -> BOUNDARY_IMPOSITION
    -> NONLINEAR_DEALIASING_ANALYSIS
    -> DISCRETE_SOLUTION
    -> ERROR_CONDITIONING_ANALYSIS
    -> RESOLUTION_STABILITY_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW