Laplace Transform Ontology

FLOW ALGEBRA
Laplace Transform Ontology — Mathematical Transformation Entities
Version: 1.0
Date: 2026-10-14
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/transformation-entities/laplace-transform-ontology-3.html
Authors: Mark Higgins — Sky (Recursive AI)

1. ONTOLOGY IDENTITY
ontology_id: mathematical.transformation.laplace_transform
entity_type: IntegralTransform
parent: MathematicalTransformationEntity
related: IntegralTransform, FourierTransform, DifferentialOperator, Convolution, TransferFunction
scope: Unilateral and bilateral Laplace transforms, domains of convergence, inversion and operational rules.

2. TYPED ENTITIES
TimeFunction: f : D -> C; D = [0,infinity) for unilateral, R for bilateral.
ComplexFrequency: s = sigma + i*omega in C.
LaplaceImage: F(s), complex-valued function on a region of convergence (ROC).
TransformKernel: K(s,t) = exp(-s*t).
RegionOfConvergence: subset of C where defining integral converges.
InitialValue: f(0+), where right-hand limit exists.
TransformPair: (f(t), F(s), convention, ROC, assumptions).
InverseContour: vertical Bromwich contour Re(s)=gamma inside a valid ROC.

3. CORE RELATIONS
HAS_DOMAIN(f, D)
TRANSFORMS_TO(f, F)
USES_KERNEL(LaplaceTransform, exp(-s*t))
HAS_ROC(F, ROC)
INVERTS_TO(F, f)
REQUIRES_ASSUMPTION(rule, condition)
SEMANTIC_EQUIVALENCE("Laplace transform", "complex-frequency integral transform", context=standard convention)

4. DEFINITIONS
Unilateral: L{f}(s) = integral_0^infinity f(t)*exp(-s*t) dt.
Bilateral: L_b{f}(s) = integral_-infinity^infinity f(t)*exp(-s*t) dt.
Inverse (under standard inversion hypotheses):
f(t) = (1/(2*pi*i))*integral_(gamma-i*infinity)^(gamma+i*infinity) F(s)*exp(s*t) ds,
interpreted with the appropriate convergence convention and at continuity points.
The ROC is part of a transform specification: identical algebraic expressions can correspond to different bilateral time functions with different ROCs.

5. TRANSFORMATION RULES (UNILATERAL UNLESS STATED)
Linearity: L{a*f+b*g} = a*F+b*G on the common ROC.
Time scaling (a>0): L{f(a*t)}(s) = F(s/a)/a.
Exponential shift: L{exp(a*t)*f(t)}(s) = F(s-a).
Time delay (a>=0): L{u(t-a)*f(t-a)}(s) = exp(-a*s)*F(s).
Derivative: L{f'}(s) = s*F(s)-f(0+), assuming requisite regularity.
Nth derivative: L{f^(n)} = s^n*F - sum_(k=0)^(n-1) s^(n-1-k)*f^(k)(0+).
Integration: L{integral_0^t f(tau) dtau}(s) = F(s)/s, where valid.
Convolution: L{(f*g)(t)} = F(s)*G(s), where (f*g)(t)=integral_0^t f(tau)g(t-tau)dtau.
Frequency differentiation: L{t*f(t)}(s) = -dF/ds, subject to differentiability.

6. STANDARD TRANSFORM PAIRS (UNILATERAL)
1 -> 1/s; Re(s)>0.
t^n -> n!/s^(n+1); n integer >=0, Re(s)>0.
exp(a*t) -> 1/(s-a); Re(s)>Re(a).
sin(omega*t) -> omega/(s^2+omega^2); Re(s)>0 for real omega.
cos(omega*t) -> s/(s^2+omega^2); Re(s)>0 for real omega.
For causal unit step u(t), L{u(t)}=1/s; Re(s)>0.

7. INFERENCE AND EXECUTION
rule transform_pair:
  input: function f, convention, assumptions
  compute: symbolic or numerical integral where valid
  output: F(s), ROC, provenance
rule solve_linear_ode:
  input: constant-coefficient ODE, initial conditions
  apply: derivative rules; solve algebraically for F(s)
  output: inverse transform with existence checks
rule compose_convolution:
  input: f,g with valid unilateral transforms
  output: product F*G and valid common convergence domain
rule inverse:
  input: F(s), ROC, convention
  choose: partial fractions, transform table, or inversion integral
  output: f with validity domain and ambiguity warnings

8. VALIDATION CONSTRAINTS
- Distinguish unilateral from bilateral transforms explicitly.
- Verify integral convergence and record ROC; do not assume convergence for all s.
- Require initial values for unilateral derivative transforms.
- Verify time shift includes the Heaviside factor u(t-a).
- Check complex parameter domains and pole/contour placement before inversion.
- Treat initial- and final-value theorems as conditional, never unconditional.
- Preserve units: s has inverse-time dimensions.
- Do not infer stability solely from an algebraic F(s) without ROC and system assumptions.

9. WORKED EXAMPLES
Example A: f(t)=exp(-2*t), t>=0.
F(s)=1/(s+2), Re(s)>-2.
Example B: f(t)=t, t>=0.
F(s)=1/s^2, Re(s)>0.
Example C: f'(t)+2*f(t)=0, f(0+)=3.
(s*F(s)-3)+2*F(s)=0 => F(s)=3/(s+2).
Inverse: f(t)=3*exp(-2*t), t>=0.
Example D: f(t)=1 and g(t)=1 for t>=0.
(f*g)(t)=t; F(s)G(s)=(1/s)^2=1/s^2, Re(s)>0.

10. CONFIDENCE AND SEMANTIC EQUIVALENCE
CONFIDENCE:
  formal_definition: high
  standard_rules: high when assumptions hold
  inversion: conditional on ROC, regularity and convention
SEMANTIC_EQUIVALENCE:
  canonical_term: Laplace Transform
  aliases: [Laplace integral transform, complex-frequency transform]
  distinguish_from: [Fourier Transform, Z Transform, Mellin Transform]

11. FLOW HASH AND UPDATE MODEL
FLOW_HASH:
  method: SHA-256
  input: canonical UTF-8 normalisation of ontology content excluding hash value
  value: COMPUTE_ON_PUBLICATION
UPDATE_MODEL:
  version: 1.0
  change_policy: semantic versioning; validate mathematical claims and cross-links before publication
  provenance: source URL and editorial review required

12. AI CONSUMPTION
AI_CONSUMPTION:
  parsing: typed entity-relation graph
  inference: assumption-aware symbolic transform rules
  retrieval_keys: [Laplace, unilateral, bilateral, ROC, inverse, convolution, ODE]
  output_requirements: [transform_convention, expression, ROC, assumptions, provenance, confidence]
  safety: flag unsupported inversions and ambiguous transform pairs

END FLOW ALGEBRA