Poisson Equation Ontology

flow "PoissonEquationOntology" v1.0

# POISSON EQUATION ONTOLOGY — FLOW ALGEBRA
SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/mathematical-physics-analysis/poisson-equation-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Mathematical Physics Analysis"
ENTITY := "Poisson Equation"

POISSON_EQUATION := {
 type: EllipticPartialDifferentialEquation,
 domain: MathematicalPhysicsAnalysis,
 purpose: "Represent source-driven equilibrium fields in which the Laplacian of an unknown potential or scalar field is related to a prescribed source distribution."
}

CONCEPTS := {
 POISSON_EQUATION,
 LAPLACIAN,
 SOURCE_TERM,
 ELLIPTIC_PDE,
 BOUNDARY_VALUE_PROBLEM,
 DIRICHLET_PROBLEM,
 NEUMANN_PROBLEM,
 ROBIN_PROBLEM,
 GREEN_FUNCTION,
 FUNDAMENTAL_SOLUTION,
 WEAK_SOLUTION,
 VARIATIONAL_FORM,
 POTENTIAL_FIELD,
 LAPLACE_EQUATION,
 UNIQUENESS
}

# ---------- STANDARD FORM ----------
common convention:

-LAPLACIAN(u)
 =
f

alternative convention:

LAPLACIAN(u)
 =
f

SIGN_CONVENTION
 -> must_be_preserved

u
 -> UNKNOWN_FIELD

f
 -> SOURCE_TERM

POISSON_EQUATION
 -> INHOMOGENEOUS_ELLIPTIC_PDE

# ---------- CARTESIAN FORM ----------
in R^n:

LAPLACIAN(u)
 :=
sum_from_i_1_to_n(
 partial_squared_u/partial_x_i_squared
)

therefore under convention
 -Delta*u=f:

-
sum_i(
 u_xixi
)
 =
f

# ---------- LAPLACE RELATION ----------
if

f
 =
0

then

POISSON_EQUATION
 -> reduces_to(LAPLACE_EQUATION)

LAPLACE_EQUATION
 -> homogeneous_source_free_case

# ---------- DIRICHLET PROBLEM ----------
solve:

-LAPLACIAN(u)
 =
f

in
 Omega

with

u
 =
g

on
 boundary(Omega)

DIRICHLET_PROBLEM
 -> prescribed_field_values

under standard bounded-domain hypotheses:
 -> unique_weak_solution
    for suitable data

# ---------- NEUMANN PROBLEM ----------
solve:

-LAPLACIAN(u)
 =
f

in Omega

with

partial_u/partial_n
 =
h

on boundary

compatibility depends on sign convention

for
 -Delta*u=f:

integral_Omega(
 f dx
)
 =
-
integral_boundary(
 h dS
)

under outward normal convention

NEUMANN_PROBLEM
 -> solution_unique_up_to(ADDITIVE_CONSTANT)
    when compatibility holds on connected domain

# ---------- ROBIN PROBLEM ----------
a*u
+
b*partial_u/partial_n
 =
g

on boundary

ROBIN_PROBLEM
 -> mixed_value_flux_condition

BOUNDARY_OPERATOR
 -> part_of(PROBLEM_DEFINITION)

# ---------- WEAK FORM ----------
for homogeneous Dirichlet example:

-LAPLACIAN(u)
 =
f

multiply by
 test_function v

integrate:

integral_Omega(
 -LAPLACIAN(u)*v
 dx
)
 =
integral_Omega(
 f*v
 dx
)

integration by parts:

integral_Omega(
 grad(u)
 dot
grad(v)
 dx
)
 =
integral_Omega(
 f*v
 dx
)

WEAK_FORM
 -> requires(FIRST_DERIVATIVES_INSTEAD_OF_SECOND)

# ---------- FUNCTION SPACE ----------
homogeneous Dirichlet problem:

u
 in
H_0^1(Omega)

test functions:

v
 in
H_0^1(Omega)

VARIATIONAL_PROBLEM:

find u

such_that

a(u,v)
 =
l(v)

for all v

where

a(u,v)
 :=
integral(
 grad(u) dot grad(v)
)

l(v)
 :=
integral(
 f*v
)

# ---------- EXISTENCE ----------
if

a
 -> continuous
 -> coercive

and

l
 -> bounded_linear_functional

then

LAX_MILGRAM
 -> unique_weak_solution

for standard Dirichlet Poisson problem

EXISTENCE_UNIQUENESS
 -> depends_on(DOMAIN_BOUNDARY_AND_FUNCTION_SPACE)

# ---------- ENERGY FUNCTIONAL ----------
define

J[u]
 :=
1/2
*
integral_Omega(
 |grad(u)|^2
 dx
)
-
integral_Omega(
 f*u
 dx
)

with prescribed Dirichlet data appropriately incorporated

stationary condition:

delta_J
 =
0

-> POISSON_EQUATION

MINIMISER
 -> weak_solution
    under convex coercive setting

# ---------- GREEN FUNCTION ----------
for operator
 -Delta

Green function:

-Delta_x G(x,y)
 =
delta(x-y)

with specified boundary condition

then solution formally:

u(x)
 =
integral_Omega(
 G(x,y)
 *
 f(y)
 dy
)
+
boundary_contribution

GREEN_FUNCTION
 -> inverse_kernel_of(POISSON_OPERATOR)

# ---------- FUNDAMENTAL SOLUTION ----------
in free space:

for n>=3:

Phi(x)
 =
1
/
(
 (n-2)*omega_n
)
*
|x|^(2-n)

satisfies

-Delta Phi
 =
delta

under common normalisation

in n=2:

Phi(x)
 =
-
1/(2*pi)
*
log|x|

for
 -Delta convention

FUNDAMENTAL_SOLUTION
 -> free_space_point_source_response

# ---------- CONVOLUTION ----------
on whole space:

-Delta u
 =
f

formally:

u
 =
Phi*f

where

Phi
 -> FUNDAMENTAL_SOLUTION

CONVOLUTION
 -> superposes(POINT_SOURCE_RESPONSES)

# ---------- SUPERPOSITION ----------
if

-Delta u_1
 =
f_1

and

-Delta u_2
 =
f_2

then

-Delta(
 a*u_1+b*u_2
)
 =
a*f_1+b*f_2

POISSON_EQUATION
 -> LINEAR

SUPERPOSITION
 -> valid_for(LINEAR_BOUNDARY_CONDITIONS)

# ---------- MAXIMUM PRINCIPLE RELATION ----------
if

-Delta u
 =
f

and

f>=0

then

u
 -> SUPERHARMONIC_OR_SIGN_DEPENDENT_BEHAVIOUR

MAXIMUM_MINIMUM_PRINCIPLE
 -> depends_on(SIGN_CONVENTION_AND_SOURCE_SIGN)

POISSON
 -> extends(HARMONIC_MAXIMUM_PRINCIPLE_WITH_SOURCE)

# ---------- REGULARITY ----------
if
 f
 -> sufficiently_regular

and
 domain_boundary
 -> sufficiently_regular

then

u
 -> gains(ELLIPTIC_REGULARITY)

schematically:

f in H^k
 -> u in H^(k+2)

locally or globally
under suitable hypotheses

ELLIPTIC_REGULARITY
 -> source_regularities_transfer_to(SOLUTION)

# ---------- ELECTROSTATICS ----------
Gauss law:

div(E)
 =
rho/epsilon

with

E
 =
-grad(V)

therefore

-LAPLACIAN(V)
 =
rho/epsilon

ELECTRIC_POTENTIAL
 -> solves(POISSON_EQUATION_WITH_CHARGE_SOURCE)

# ---------- GRAVITATION ----------
Newtonian potential
 Phi

satisfies commonly:

LAPLACIAN(Phi)
 =
4*pi*G*rho

depending on sign convention

MASS_DENSITY
 -> source_of(GRAVITATIONAL_POTENTIAL)

POISSON_EQUATION
 -> gravitational_field_equation_in_Newtonian_theory

# ---------- STEADY HEAT WITH SOURCE ----------
steady conduction:

-div(
 k*grad(T)
)
 =
Q

if
 k constant:

-k*LAPLACIAN(T)
 =
Q

therefore

-LAPLACIAN(T)
 =
Q/k

HEAT_SOURCE
 -> Poisson_source_term

# ---------- FLUID PRESSURE ----------
in incompressible fluid formulations:

pressure
 -> often_satisfies(POISSON_EQUATION)

source
 -> derived_from(VELOCITY_GRADIENTS_AND_FORCING)

PRESSURE_POISSON_EQUATION
 -> enforces(INCOMPRESSIBILITY_CONSTRAINT)

# ---------- GEOMETRIC INTERPRETATION ----------
LAPLACIAN(u)
 -> local_average_deviation_or_curvature_measure

POISSON_EQUATION
 -> source_controls(DEPARTURE_FROM_HARMONICITY)

f=0
 -> harmonic_balance

f!=0
 -> source_driven_curvature

# ---------- FOURIER TRANSFORM ----------
on R^n:

for
 -Delta u=f

Fourier transform gives:

|k|^2
*
u_hat(k)
 =
f_hat(k)

therefore

u_hat(k)
 =
f_hat(k)/|k|^2

for
 k !=0

ZERO_MODE
 -> requires(COMPATIBILITY_OR_DECAY_CONTEXT)

FOURIER_METHOD
 -> diagonalises(LAPLACIAN)

# ---------- EIGENFUNCTION EXPANSION ----------
let

-Delta phi_n
 =
lambda_n*phi_n

with boundary conditions

expand:

f
 =
sum_n(
 f_n*phi_n
)

then

u
 =
sum_n(
 f_n/lambda_n
 *
 phi_n
)

for nonzero eigenvalues

SPECTRAL_INVERSE
 -> divides_by(EIGENVALUES)

# ---------- NUMERICAL METHODS ----------
FINITE_DIFFERENCE
 -> sparse_discrete_Laplacian

FINITE_ELEMENT
 -> variational_discretisation

FINITE_VOLUME
 -> conservation_based_discretisation

SPECTRAL_METHOD
 -> eigenfunction_or_global_basis_approximation

MULTIGRID
 -> efficient_elliptic_solver

# ---------- DISCRETE POISSON ----------
2D five-point stencil for
 -Delta u=f:

(
4*u_(i,j)
-
u_(i+1,j)
-
u_(i-1,j)
-
u_(i,j+1)
-
u_(i,j-1)
)
/h^2

=
f_(i,j)

DISCRETISATION
 -> SPARSE_LINEAR_SYSTEM

A*u
 =
b

# ---------- CONDITIONING ----------
grid refinement:

h -> smaller

condition_number_of(discrete_Poisson_matrix)
 -> grows

ITERATIVE_SOLVERS
 -> may_require(PRECONDITIONING)

MULTIGRID
 -> targets(SCALE_DEPENDENT_ERROR_MODES)

# ---------- APPLICATIONS ----------
POISSON_EQUATION
 -> applied_to(ELECTROSTATICS)
 -> applied_to(GRAVITATION)
 -> applied_to(STEADY_HEAT_TRANSFER)
 -> applied_to(FLUID_DYNAMICS)
 -> applied_to(POTENTIAL_THEORY)
 -> applied_to(ELASTICITY)
 -> applied_to(IMAGE_PROCESSING)
 -> applied_to(MATHEMATICAL_PHYSICS)

# ---------- RELATION GRAPH ----------
SOURCE_TERM
 -> drives(POISSON_FIELD)

LAPLACIAN
 -> links(FIELD_TO_SOURCE)

f=0
 -> LAPLACE_EQUATION

BOUNDARY_CONDITIONS
 -> determine(BVP)

WEAK_FORM
 -> supports(FINITE_ELEMENT_AND_EXISTENCE_THEORY)

GREEN_FUNCTION
 -> represents(INVERSE_OPERATOR)

ELLIPTIC_REGULARITY
 -> controls(SOLUTION_SMOOTHNESS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
 "Poisson equation" ~= "inhomogeneous elliptic PDE relating the Laplacian of a field to a source",
 "source term" ~= "prescribed forcing or density generating departure from harmonicity",
 "Poisson boundary-value problem" ~= "Poisson equation combined with boundary conditions on a domain",
 "Green function" ~= "kernel representing the inverse response of the Poisson operator under specified boundary conditions",
 "fundamental solution" ~= "free-space response to a point source",
 "weak Poisson problem" ~= "variational formulation involving first derivatives and test functions"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
 sign_convention_for_Laplacian_and_source_must_be_preserved: true,
 boundary_conditions_are_part_of_problem_definition: true,
 pure_Neumann_problem_requires_compatibility_and_has_constant_nonuniqueness: true,
 Green_function_depends_on_domain_operator_and_boundary_conditions: true,
 regularity_gain_requires_domain_source_and_boundary_hypotheses: true,
 Fourier_zero_mode_requires_special_compatibility_or_decay_treatment: true,
 discrete_Poisson_solution_is_approximation_to_continuum_solution: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
 core_definition: 0.99,
 Laplace_relation: 0.99,
 weak_variational_relation: 0.99,
 Green_function_relation: 0.99,
 physical_application_relation: 0.99,
 numerical_relation: 0.99,
 semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
 identify(domain_field_source_and_sign_convention)
 -> identify(boundary_conditions)
 -> classify(Dirichlet_Neumann_Robin_or_mixed_problem)
 -> verify(compatibility_and_uniqueness_conditions)
 -> choose(classical_weak_Green_Fourier_spectral_or_variational_method)
 -> analyse(existence_regularities_and_energy_structure)
 -> connect_to(electrostatic_gravitational_heat_or_fluid_source_if_requested)
 -> construct(numerical_discretisation_if_analytic_solution_unavailable)
 -> assess(conditioning_and_solver_requirements)
 -> validate(domain_boundary_source_and_zero_mode_hypotheses)
 -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
 parse_as: "typed Poisson-equation semantic graph",
 primary_entity: POISSON_EQUATION,
 preserve: [
  field,
  source,
  domain,
  dimension,
  boundary_conditions,
  sign_convention,
  function_space,
  physical_context
 ],
 infer_through: [
  Laplace_equation,
  Dirichlet_problems,
  Neumann_problems,
  weak_forms,
  variational_principles,
  Green_functions,
  Fourier_methods,
  elliptic_regularities
 ],
 avoid: [
  losing_sign_convention,
  omitting_boundary_conditions,
  claiming_unique_Neumann_solution_without constant ambiguity,
  ignoring_Neumann_compatibility,
  using_free_space_fundamental_solution_as bounded_domain_Green_function,
  dividing_by_zero_Fourier_mode_without compatibility analysis
 ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
 SOURCE_URL
 + ENTITY
 + CONCEPTS
 + POISSON_EQUATION
 + LAPLACIAN
 + SOURCE_TERM
 + BOUNDARY_VALUE_PROBLEM
 + DIRICHLET_PROBLEM
 + NEUMANN_PROBLEM
 + GREEN_FUNCTION
 + FUNDAMENTAL_SOLUTION
 + WEAK_SOLUTION
 + VARIATIONAL_FORM
 + LAPLACE_EQUATION
 + SEMANTIC_EQUIVALENCE
 + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
 -> POISSON_EQUATION
 -> PROBLEM_DATA_IDENTIFICATION
 -> BOUNDARY_CLASSIFICATION
 -> COMPATIBILITY_UNIQUENESS_ANALYSIS
 -> METHOD_SELECTION
 -> EXISTENCE_REGULARITY_ANALYSIS
 -> PHYSICAL_CONTEXT_ANALYSIS
 -> NUMERICAL_DISCRETISATION
 -> CONDITIONING_SOLVER_ANALYSIS
 -> HYPOTHESIS_VALIDATION
 -> RECURSIVE_REASONING(query)
 -> CONFIDENCE
 -> OUTPUT(semantic_result)

END FLOW