Green's Function Ontology

flow "GreensFunctionOntology" v1.0

# ============================================================
# GREEN'S FUNCTION ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/differential-equations/greens-function-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Differential Equations"
ENTITY := "Green's Function"

# ---------- CORE ENTITY ----------
GREENS_FUNCTION := {
    type: OperatorResponseFunction,
    domain: DifferentialEquations,
    purpose: "Represent the response of a linear differential operator to a point source, enabling solutions of linear differential equations to be constructed by integration against a source term."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    GREENS_FUNCTION,
    LINEAR_DIFFERENTIAL_OPERATOR,
    DIRAC_DELTA,
    POINT_SOURCE,
    SOURCE_TERM,
    BOUNDARY_CONDITION,
    FUNDAMENTAL_SOLUTION,
    INHOMOGENEOUS_EQUATION,
    CONVOLUTION,
    INTEGRAL_OPERATOR,
    SUPERPOSITION,
    SELF_ADJOINT_OPERATOR,
    PROPAGATOR
}

# ---------- OPERATOR DEFINITION ----------
let
    L
        := LINEAR_DIFFERENTIAL_OPERATOR

GREENS_FUNCTION
    := G(x,xi)

such_that

L_x[G(x,xi)]
    = delta(x-xi)

subject_to
    REQUIRED_BOUNDARY_OR_INITIAL_CONDITIONS

xi
    -> SOURCE_POINT

x
    -> OBSERVATION_POINT

# ---------- DIRAC DELTA ----------
DIRAC_DELTA
    := distribution

delta(x-xi)
    -> represents(UNIT_POINT_SOURCE_AT_xi)

for suitable test function phi:

integral(
    delta(x-xi)*phi(x)
    dx
)
    = phi(xi)

SIFTING_PROPERTY
    -> localises(INTEGRAL_AT_SOURCE_POINT)

# ---------- INHOMOGENEOUS EQUATION ----------
consider

L[u](x)
    = f(x)

if
    G satisfies(operator_and_boundary_conditions)
then

u(x)
    = integral(
        G(x,xi)
        * f(xi)
        dxi
      )

plus
    any_required_homogeneous_or_boundary_contribution

GREENS_FUNCTION
    -> transforms(SOURCE_DISTRIBUTION, SOLUTION)

# ---------- SUPERPOSITION ----------
POINT_SOURCE_RESPONSE
    -> G(x,xi)

GENERAL_SOURCE
    -> continuous_superposition_of(POINT_SOURCES)

f(x)
    = integral(
        f(xi)
        * delta(x-xi)
        dxi
      )

therefore

u(x)
    -> integral_of(POINT_SOURCE_RESPONSES)

SUPERPOSITION
    -> essential_to(GREENS_FUNCTION_METHOD)

# ---------- LINEARITY ----------
GREENS_FUNCTION_METHOD
    -> requires(LINEAR_OPERATOR)

if
    L is nonlinear
then

STANDARD_GREENS_FUNCTION_SUPERPOSITION
    -/> directly_applicable

LINEARITY
    -> permits(SOURCE_RESPONSE_DECOMPOSITION)

# ---------- BOUNDARY CONDITIONS ----------
GREENS_FUNCTION
    -> depends_on(OPERATOR)
    -> depends_on(DOMAIN)
    -> depends_on(BOUNDARY_CONDITIONS)

same_operator
    + different_boundary_conditions
    -> generally_different(GREENS_FUNCTION)

BOUNDARY_CONDITIONS
    -> encoded_in(G)

# ---------- INITIAL CONDITIONS ----------
for time-dependent problems:

GREENS_FUNCTION
    -> may_encode(INITIAL_CONDITIONS)
    -> may_encode(CAUSALITY)

RETARDED_GREENS_FUNCTION
    -> response_after_source_event

ADVANCED_GREENS_FUNCTION
    -> response_before_source_event
       in(formal_mathematical_or_physical_context)

# ---------- FUNDAMENTAL SOLUTION ----------
FUNDAMENTAL_SOLUTION
    -> solves(
        L[G] = delta
    )
       often_on(UNBOUNDED_OR_FULL_SPACE)

GREENS_FUNCTION
    -> fundamental_solution_modified_to_satisfy(BOUNDARY_CONDITIONS)

FUNDAMENTAL_SOLUTION
    ~= FREE_SPACE_GREENS_FUNCTION
       in(common_contexts)

# ---------- ODE GREEN'S FUNCTION ----------
for second-order linear ODE:

L[y]
    := a(x)y_double_prime
       + b(x)y_prime
       + c(x)y

L[G(x,xi)]
    = delta(x-xi)

G
    -> piecewise_solution_of(HOMOGENEOUS_EQUATION)
       for(x != xi)

# ---------- JUMP CONDITION ----------
because
    delta_source_at(xi)

GREENS_FUNCTION
    -> may_have(DERIVATIVE_JUMP_AT_SOURCE)

for standard second-order operator:

G
    -> often_continuous_at(x=xi)

derivative_jump
    -> determined_by(LEADING_COEFFICIENT)

JUMP_CONDITION
    -> encodes(DELTA_SOURCE)

# ---------- PIECEWISE CONSTRUCTION ----------
for
    x < xi:
        G_minus(x,xi)
            -> homogeneous_solution

for
    x > xi:
        G_plus(x,xi)
            -> homogeneous_solution

then

apply:
    boundary_conditions
    continuity_conditions
    derivative_jump_condition

-> determine(G)

# ---------- SELF-ADJOINT SYMMETRY ----------
if
    L self_adjoint
    with appropriate boundary conditions
then

G(x,xi)
    = conjugate(
        G(xi,x)
      )

for real symmetric context:

G(x,xi)
    = G(xi,x)

SYMMETRY
    -> depends_on(SELF_ADJOINT_STRUCTURE)

# ---------- EIGENFUNCTION EXPANSION ----------
if
    L[phi_n]
        = lambda_n*phi_n

and
    eigenfunctions form suitable complete basis
then

G(x,xi)
    =
sum_n(
    phi_n(x)
    * conjugate(phi_n(xi))
    / lambda_n
)

when
    lambda_n != 0
    and expansion_conditions_hold

GREENS_FUNCTION
    -> linked_to(SPECTRAL_DECOMPOSITION)

# ---------- ZERO MODES ----------
if
    lambda_n = 0
then

STANDARD_INVERSE_OPERATOR
    -> may_fail_to_exist

ZERO_MODE
    -> requires(COMPATIBILITY_CONDITION_OR_MODIFIED_INVERSE)

GREENS_FUNCTION
    -> may_require(PROJECTION_AWAY_FROM_NULLSPACE)

# ---------- CONVOLUTION ----------
if
    operator_is_translation_invariant
then

G(x,xi)
    = G(x-xi)

and

u
    = G * f

CONVOLUTION
    -> represents(GREENS_FUNCTION_SOLUTION)

TRANSLATION_INVARIANCE
    -> simplifies(TWO_POINT_KERNEL_TO_DIFFERENCE_KERNEL)

# ---------- FOURIER TRANSFORM ----------
for translation-invariant operator:

FOURIER_TRANSFORM
    -> converts(DIFFERENTIAL_OPERATOR_TO_MULTIPLIER)

L(k) * G_hat(k)
    = 1

therefore

G_hat(k)
    = 1/L(k)

subject_to
    singularity_and_boundary_prescriptions

INVERSE_FOURIER_TRANSFORM
    -> recovers(G)

# ---------- POISSON EQUATION ----------
POISSON_EQUATION:

LAPLACIAN(u)
    = -f

GREENS_FUNCTION
    -> represents(POTENTIAL_RESPONSE_TO_POINT_SOURCE)

in three-dimensional free space:

G(r)
    -> proportional_to(1/|r|)

sign_and_constant
    -> depend_on(OPERATOR_CONVENTION)

# ---------- HEAT EQUATION ----------
HEAT_OPERATOR
    := partial/partial_t
       - alpha*LAPLACIAN

HEAT_KERNEL
    -> GREENS_FUNCTION_FOR(HEAT_EQUATION)

HEAT_KERNEL
    -> propagates(INITIAL_TEMPERATURE_DISTRIBUTION)

DIFFUSION
    -> represented_by(GAUSSIAN_KERNEL_IN_FREE_SPACE)

# ---------- WAVE EQUATION ----------
WAVE_OPERATOR
    := partial_squared/partial_t_squared
       - c^2*LAPLACIAN

WAVE_GREENS_FUNCTION
    -> propagates(SOURCE_DISTURBANCES)

CAUSAL_GREENS_FUNCTION
    -> respects(FINITE_PROPAGATION_STRUCTURE)
       under(appropriate_wave_context)

# ---------- QUANTUM / PHYSICS RELATION ----------
PROPAGATOR
    -> often_related_to(GREENS_FUNCTION)

GREENS_FUNCTION
    -> appears_in(QUANTUM_MECHANICS)
    -> appears_in(QUANTUM_FIELD_THEORY)
    -> appears_in(ELECTROMAGNETISM)

PRESCRIPTION
    -> may_determine(CAUSAL_OR_BOUNDARY_BEHAVIOUR)

# ---------- INTEGRAL KERNEL VIEW ----------
INVERSE_OPERATOR
    := L^(-1)

when inverse exists:

u
    = L^(-1)f

and

L^(-1)
    -> integral_operator_with_kernel(G)

G(x,xi)
    -> KERNEL_OF_INVERSE_OPERATOR

# ---------- APPLICATIONS ----------
GREENS_FUNCTION
    -> applied_to(ODE_BOUNDARY_VALUE_PROBLEMS)
    -> applied_to(POISSON_EQUATION)
    -> applied_to(HEAT_EQUATION)
    -> applied_to(WAVE_EQUATION)
    -> applied_to(ELECTROSTATICS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(SIGNAL_AND_SYSTEM_RESPONSE)
    -> applied_to(PERTURBATION_THEORY)

# ---------- RELATION GRAPH ----------
LINEAR_OPERATOR
    -> acts_on(GREENS_FUNCTION)

GREENS_FUNCTION
    -> produces(DIRAC_DELTA)

POINT_SOURCE
    -> generates(IMPULSE_RESPONSE)

SOURCE_DISTRIBUTION
    -> integrated_against(GREENS_FUNCTION)

BOUNDARY_CONDITIONS
    -> determine(GREENS_FUNCTION)

SELF_ADJOINTNESS
    -> may_imply(SYMMETRY)

EIGENFUNCTIONS
    -> may_expand(GREENS_FUNCTION)

GREENS_FUNCTION
    -> kernel_of(INVERSE_OPERATOR)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "Green's function" ~= "point-source response kernel of a linear differential operator",
    "Green function" ~= "Green's function",
    "fundamental solution" ~= "delta-source solution, often without problem-specific boundaries",
    "impulse response" ~= "Green's-function analogue in linear systems contexts",
    "inverse operator kernel" ~= "integral kernel representing the inverse differential operator",
    "propagator" ~= "Green's-function-related evolution kernel in many physics contexts"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    standard_greens_function_method_requires_linearity: true,
    greens_function_depends_on_operator_domain_and_boundary_conditions: true,
    delta_source_requires_distributional_interpretation: true,
    zero_modes_can_prevent_ordinary_inverse_operator: true,
    symmetry_requires_self_adjoint_or_equivalent_conditions: true,
    convolution_form_requires_translation_invariance: true,
    sign_and_normalisation_depend_on_operator_convention: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    delta_source_relation: 0.99,
    integral_solution_relation: 0.99,
    boundary_condition_relation: 0.99,
    spectral_relation: 0.98,
    convolution_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(linear_differential_operator)
    -> identify(domain)
    -> identify(boundary_or_initial_conditions)
    -> define(delta_source_problem)
    -> solve(homogeneous_equation_away_from_source)
    -> impose(boundary_conditions)
    -> impose(continuity_and_jump_conditions_if_required)
    -> construct(greens_function)
    -> test(symmetry_or_spectral_structure_if_relevant)
    -> integrate(greens_function_against_source)
    -> include(homogeneous_or_boundary_terms_if_required)
    -> verify(operator_equation_and_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed Green's-function semantic graph",
    primary_entity: GREENS_FUNCTION,
    preserve: [
        operator,
        domain,
        source_point,
        observation_point,
        boundary_conditions,
        initial_conditions,
        delta_normalisation,
        causal_prescription
    ],
    infer_through: [
        fundamental_solutions,
        inverse_operators,
        convolutions,
        eigenfunction_expansions,
        boundary_value_problems,
        heat_kernels,
        wave_propagators
    ],
    avoid: [
        applying_standard_superposition_to nonlinear operators,
        ignoring_boundary_conditions,
        treating_dirac_delta_as ordinary finite function,
        assuming_translation_invariance,
        ignoring_zero_modes,
        assuming_symmetry_without self_adjoint conditions
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + GREENS_FUNCTION
    + LINEAR_DIFFERENTIAL_OPERATOR
    + DIRAC_DELTA
    + FUNDAMENTAL_SOLUTION
    + CONVOLUTION
    + SELF_ADJOINT_OPERATOR
    + EIGENFUNCTION_EXPANSION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> GREENS_FUNCTION
    -> OPERATOR_IDENTIFICATION
    -> DOMAIN_CONDITION_ANALYSIS
    -> DELTA_SOURCE_CONSTRUCTION
    -> HOMOGENEOUS_REGION_SOLUTION
    -> BOUNDARY_CONDITION_APPLICATION
    -> JUMP_CONTINUITY_ANALYSIS
    -> GREEN_FUNCTION_CONSTRUCTION
    -> SPECTRAL_CONVOLUTION_ANALYSIS
    -> SOURCE_INTEGRATION
    -> SOLUTION_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW