Boundary Value Problem Ontology

flow "BoundaryValueProblemOntology" v1.0

# ============================================================
# BOUNDARY VALUE PROBLEM ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/differential-equations/boundary-value-problem-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Differential Equations"
ENTITY := "Boundary Value Problem"

# ---------- CORE ENTITY ----------
BOUNDARY_VALUE_PROBLEM := {
    type: DifferentialEquationProblem,
    domain: DifferentialEquations,
    abbreviation: "BVP",
    purpose: "Determine a solution of a differential equation that satisfies specified conditions on the boundary of its domain."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    BOUNDARY_VALUE_PROBLEM,
    DIFFERENTIAL_EQUATION,
    DOMAIN,
    BOUNDARY,
    BOUNDARY_CONDITION,
    DIRICHLET_CONDITION,
    NEUMANN_CONDITION,
    ROBIN_CONDITION,
    MIXED_BOUNDARY_CONDITION,
    SOLUTION,
    EXISTENCE,
    UNIQUENESS,
    EIGENVALUE_PROBLEM,
    NUMERICAL_SOLUTION
}

# ---------- BASIC STRUCTURE ----------
BOUNDARY_VALUE_PROBLEM
    := DIFFERENTIAL_EQUATION
       + DOMAIN
       + BOUNDARY_CONDITIONS

BOUNDARY_CONDITION
    -> constrains(SOLUTION_ON_BOUNDARY)

BVP
    -> differs_from(INITIAL_VALUE_PROBLEM)
       by(CONDITION_LOCATION_AND_PROBLEM_STRUCTURE)

# ---------- ODE BOUNDARY VALUE PROBLEM ----------
for second-order ODE:

y_double_prime
    = f(x,y,y_prime)

on
    x in [a,b]

with

y(a)
    = alpha

y(b)
    = beta

BOUNDARY_DATA
    -> specified_at(MULTIPLE_POINTS)

# ---------- PDE BOUNDARY VALUE PROBLEM ----------
for
    L[u] = f
    on domain Omega

with
    B[u] = g
    on boundary(Omega)

L
    -> DIFFERENTIAL_OPERATOR

B
    -> BOUNDARY_OPERATOR

PDE_BVP
    -> couples(INTERIOR_EQUATION, BOUNDARY_DATA)

# ---------- DIRICHLET CONDITION ----------
DIRICHLET_CONDITION
    := u = g
       on(boundary)

DIRICHLET
    -> specifies(FUNCTION_VALUE)

example:
    u|_boundary
        = prescribed_value

# ---------- NEUMANN CONDITION ----------
NEUMANN_CONDITION
    := partial_u/partial_n
       = g
       on(boundary)

partial_u/partial_n
    := GRADIENT(u) dot n_hat

NEUMANN
    -> specifies(NORMAL_DERIVATIVE)

# ---------- ROBIN CONDITION ----------
ROBIN_CONDITION
    := alpha*u
       + beta*partial_u/partial_n
       = g
       on(boundary)

ROBIN
    -> combines(VALUE_AND_NORMAL_DERIVATIVE)

# ---------- MIXED BOUNDARY CONDITION ----------
MIXED_BOUNDARY_CONDITION
    -> different_boundary_types_on(DIFFERENT_BOUNDARY_SUBSETS)

example:

u = g1
    on Gamma_1

partial_u/partial_n = g2
    on Gamma_2

BOUNDARY
    := Gamma_1 union Gamma_2

# ---------- PERIODIC CONDITION ----------
PERIODIC_BOUNDARY_CONDITION
    -> identifies(VALUES_OR_DERIVATIVES_AT_OPPOSITE_BOUNDARIES)

example:

u(a)
    = u(b)

u_prime(a)
    = u_prime(b)

PERIODIC
    -> models(REPEATING_DOMAIN_STRUCTURE)

# ---------- SOLUTION ----------
BVP_SOLUTION
    -> satisfies(DIFFERENTIAL_EQUATION_IN_DOMAIN)
    -> satisfies(BOUNDARY_CONDITIONS)

SOLUTION_VALIDATION
    -> check(INTERIOR_EQUATION)
    -> check(BOUNDARY_DATA)

# ---------- EXISTENCE ----------
EXISTENCE
    -> asks(Whether_at_least_one_solution_satisfies_equation_and_boundary_data)

EXISTENCE
    -> depends_on(
        OPERATOR,
        DOMAIN,
        BOUNDARY_CONDITIONS,
        FORCING_TERM
    )

BVP
    -/> automatically_has(SOLUTION)

# ---------- UNIQUENESS ----------
UNIQUENESS
    -> asks(Whether_only_one_solution_satisfies_problem)

UNIQUENESS
    -> may_follow_from(
        ENERGY_METHODS,
        MAXIMUM_PRINCIPLES,
        OPERATOR_THEORY,
        COERCIVITY,
        OTHER_PROBLEM_SPECIFIC_THEOREMS
    )

BOUNDARY_TYPE
    -> affects(UNIQUENESS)

# ---------- PURE NEUMANN CAUTION ----------
for Poisson-type problem:

LAPLACIAN(u)
    = f

with

partial_u/partial_n
    = g

on boundary

COMPATIBILITY_CONDITION
    -> may_be_required_for(EXISTENCE)

SOLUTION
    -> may_be_unique_only_up_to(ADDITIVE_CONSTANT)

PURE_NEUMANN_PROBLEM
    -> requires(SPECIAL_UNIQUENESS_HANDLING)

# ---------- LINEAR BVP ----------
LINEAR_BVP
    := L[u] = f
       with
       B[u] = g

if
    L and B linear
then

SUPERPOSITION
    -> applies_to(HOMOGENEOUS_ASSOCIATED_PROBLEM)

GENERAL_NONHOMOGENEOUS_SOLUTION
    -> particular_solution
       + homogeneous_solution
       subject_to(boundary_conditions)

# ---------- EIGENVALUE BVP ----------
EIGENVALUE_PROBLEM
    := L[u]
       = lambda*w*u

with
    homogeneous_boundary_conditions

lambda
    -> EIGENVALUE

u
    -> EIGENFUNCTION

BOUNDARY_CONDITIONS
    -> determine(ALLOWED_SPECTRUM)

# ---------- STURM-LIOUVILLE STRUCTURE ----------
STURM_LIOUVILLE_PROBLEM:

-d/dx(
    p(x) y_prime
)
+
q(x)y
=
lambda*w(x)y

with
    boundary_conditions

STURM_LIOUVILLE
    -> important_class_of(LINEAR_EIGENVALUE_BVP)

EIGENFUNCTIONS
    -> may_form(ORTHOGONAL_BASIS)
       under(STANDARD_SELF_ADJOINT_CONDITIONS)

# ---------- SHOOTING METHOD ----------
SHOOTING_METHOD
    -> converts(BVP_TO_IVP_ITERATION)

procedure:
    guess(missing_initial_data)
    -> solve(IVP)
    -> compare(endpoint_with_boundary_target)
    -> update(guess)
    -> repeat_until(tolerance)

SHOOTING_METHOD
    -> useful_for(ODE_BVPs)

# ---------- FINITE DIFFERENCE METHOD ----------
FINITE_DIFFERENCE_METHOD
    -> discretises(DOMAIN)

DERIVATIVES
    -> approximated_by(DIFFERENCE_FORMULAS)

BOUNDARY_CONDITIONS
    -> incorporated_into(DISCRETE_SYSTEM)

BVP
    -> transformed_to(ALGEBRAIC_SYSTEM)

# ---------- FINITE ELEMENT METHOD ----------
FINITE_ELEMENT_METHOD
    -> constructs(WEAK_FORMULATION)
    -> discretises(FUNCTION_SPACE)

DIRICHLET_CONDITIONS
    -> may_be(ESSENTIAL_BOUNDARY_CONDITIONS)

NEUMANN_CONDITIONS
    -> may_appear_as(NATURAL_BOUNDARY_TERMS)

FINITE_ELEMENT_METHOD
    -> widely_used_for(PDE_BVPs)

# ---------- WEAK FORMULATION ----------
WEAK_FORMULATION
    -> multiply_equation_by(TEST_FUNCTION)
    -> integrate_over(DOMAIN)
    -> apply(INTEGRATION_BY_PARTS)
    -> incorporate(BOUNDARY_TERMS)

WEAK_SOLUTION
    -> may_require(LESS_CLASSICAL_DIFFERENTIABILITY)

# ---------- GREEN FUNCTION ----------
for linear operator L:

GREEN_FUNCTION
    -> constructed_to_satisfy(OPERATOR_AND_BOUNDARY_CONDITIONS)

SOLUTION
    -> may_be_represented_as(INTEGRAL_AGAINST_GREEN_FUNCTION)

BOUNDARY_CONDITIONS
    -> embedded_in(GREEN_FUNCTION)

# ---------- PHYSICAL INTERPRETATION ----------
DIRICHLET
    -> prescribed_state_value

NEUMANN
    -> prescribed_flux_or_gradient

ROBIN
    -> mixed_transfer_or_exchange_condition

BOUNDARY_VALUE_PROBLEM
    -> models(SPATIAL_EQUILIBRIUM_AND_CONSTRAINED_FIELDS)

# ---------- APPLICATIONS ----------
BOUNDARY_VALUE_PROBLEM
    -> applied_to(HEAT_CONDUCTION)
    -> applied_to(ELECTROSTATICS)
    -> applied_to(ELASTICITY)
    -> applied_to(FLUID_MECHANICS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(WAVEGUIDES)
    -> applied_to(STRUCTURAL_ANALYSIS)

# ---------- RELATION GRAPH ----------
DIFFERENTIAL_EQUATION
    + BOUNDARY_CONDITIONS
    -> BOUNDARY_VALUE_PROBLEM

BOUNDARY
    -> hosts(BOUNDARY_DATA)

DIRICHLET
    -> specifies(VALUE)

NEUMANN
    -> specifies(NORMAL_DERIVATIVE)

ROBIN
    -> combines(VALUE, NORMAL_DERIVATIVE)

BOUNDARY_CONDITIONS
    -> influence(EXISTENCE_AND_UNIQUENESS)

EIGENVALUE_BVP
    -> produces(SPECTRUM)

NUMERICAL_METHOD
    -> approximates(BVP_SOLUTION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "boundary value problem" ~= "differential equation problem with conditions prescribed on the domain boundary",
    "BVP" ~= "boundary value problem",
    "Dirichlet condition" ~= "prescribed function value on a boundary",
    "Neumann condition" ~= "prescribed normal derivative on a boundary",
    "Robin condition" ~= "linear combination of function value and normal derivative on a boundary",
    "mixed boundary conditions" ~= "different boundary-condition types applied to different boundary portions"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    bvp_requires_differential_equation_domain_and_boundary_conditions: true,
    solution_must_satisfy_interior_equation_and_boundary_data: true,
    existence_and_uniqueness_depend_on_operator_domain_and_boundary_type: true,
    pure_neumann_problem_may_require_compatibility_and_additive_constant_handling: true,
    eigenvalue_spectrum_depends_on_boundary_conditions: true,
    numerical_solution_is_approximate_unless_exactness_proven: true,
    boundary_orientation_matters_for_normal_derivative_and_flux_conditions: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    boundary_condition_classification: 0.99,
    existence_uniqueness_relation: 0.98,
    neumann_compatibility_relation: 0.98,
    eigenvalue_relation: 0.99,
    numerical_method_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(differential_equation)
    -> identify(domain)
    -> identify(boundary)
    -> classify(boundary_conditions)
    -> determine(equation_order_and_linearity)
    -> test(existence_and_uniqueness_conditions)
    -> test(compatibility_conditions_if_required)
    -> identify(eigenvalue_structure_if_present)
    -> select(analytical_or_numerical_method)
    -> construct(solution_or_approximation)
    -> verify(interior_equation_and_boundary_conditions)
    -> analyse(error_spectrum_or_physical_interpretation_if_requested)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed boundary-value-problem semantic graph",
    primary_entity: BOUNDARY_VALUE_PROBLEM,
    preserve: [
        differential_equation,
        domain,
        boundary,
        boundary_condition_types,
        boundary_values,
        normal_orientation,
        operator,
        forcing_term
    ],
    infer_through: [
        dirichlet_conditions,
        neumann_conditions,
        robin_conditions,
        mixed_conditions,
        eigenvalue_problems,
        weak_formulations,
        green_functions,
        numerical_methods
    ],
    avoid: [
        treating_boundary_conditions_as initial conditions,
        assuming_bvp_solution exists uniquely,
        ignoring_neumann compatibility conditions,
        ignoring_boundary_orientation_for normal derivatives,
        treating numerical approximation as exact solution,
        ignoring boundary conditions in eigenvalue spectrum
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + BOUNDARY_VALUE_PROBLEM
    + DIRICHLET_CONDITION
    + NEUMANN_CONDITION
    + ROBIN_CONDITION
    + MIXED_BOUNDARY_CONDITION
    + EIGENVALUE_PROBLEM
    + STURM_LIOUVILLE_PROBLEM
    + WEAK_FORMULATION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> BOUNDARY_VALUE_PROBLEM
    -> DIFFERENTIAL_EQUATION_IDENTIFICATION
    -> DOMAIN_BOUNDARY_IDENTIFICATION
    -> BOUNDARY_CONDITION_CLASSIFICATION
    -> ORDER_LINEARITY_ANALYSIS
    -> EXISTENCE_UNIQUENESS_ANALYSIS
    -> COMPATIBILITY_ANALYSIS
    -> EIGENVALUE_STRUCTURE_ANALYSIS
    -> METHOD_SELECTION
    -> SOLUTION_OR_APPROXIMATION
    -> BOUNDARY_SOLUTION_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW