Laplace Transform Ontology

flow "LaplaceTransformOntology" v1.0

# ============================================================
# LAPLACE TRANSFORM ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/fourier-harmonic-analysis/laplace-transform-ontology-2.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Fourier and Harmonic Analysis"
ENTITY := "Laplace Transform"

# ---------- CORE ENTITY ----------
LAPLACE_TRANSFORM := {
    type: IntegralTransform,
    domain: MathematicalAnalysis,
    purpose: "Transform functions of a real variable into functions of a complex frequency variable, converting many differential and integral equations into algebraic equations."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    LAPLACE_TRANSFORM,
    INVERSE_LAPLACE_TRANSFORM,
    COMPLEX_FREQUENCY,
    REGION_OF_CONVERGENCE,
    EXPONENTIAL_ORDER,
    LINEARITY,
    DERIVATIVE_PROPERTY,
    INTEGRATION_PROPERTY,
    TIME_SHIFT,
    FREQUENCY_SHIFT,
    CONVOLUTION,
    INITIAL_VALUE_THEOREM,
    FINAL_VALUE_THEOREM,
    TRANSFER_FUNCTION,
    DIFFERENTIAL_EQUATION
}

# ---------- ONE-SIDED DEFINITION ----------
for
    f(t)
    defined_for(t >= 0)

LAPLACE_TRANSFORM(f)
    := F(s)

F(s)
    =
integral_from_0_to_infinity(
    exp(-s*t)
    *
    f(t)
    dt
)

s
    :=
sigma + i*omega

s
    -> COMPLEX_FREQUENCY_VARIABLE

# ---------- BILATERAL FORM ----------
BILATERAL_LAPLACE_TRANSFORM:

F(s)
    =
integral_from_minus_infinity_to_infinity(
    exp(-s*t)
    *
    f(t)
    dt
)

UNILATERAL
    and
BILATERAL
    -> distinct_transform_contexts

TRANSFORM_TYPE
    -> must_be_preserved

# ---------- REGION OF CONVERGENCE ----------
REGION_OF_CONVERGENCE
    := set_of(
        s in C
        where
        defining_integral_converges
    )

ROC
    -> essential_part_of(LAPLACE_TRANSFORM)

same_algebraic_expression
    + different_ROC
    -> may_correspond_to(DIFFERENT_SIGNALS_IN_BILATERAL_CONTEXT)

# ---------- EXISTENCE ----------
if
    f
        -> piecewise_continuous_on_finite_intervals

and
    f
        -> of_exponential_order(alpha)

then

unilateral_Laplace_transform
    -> exists_for(Re(s) > alpha)

EXPONENTIAL_ORDER:
    |f(t)|
        <= M*exp(alpha*t)
       for sufficiently_large_t

# ---------- LINEARITY ----------
L{
    a*f(t)
    +
    b*g(t)
}
=
a*F(s)
+
b*G(s)

LAPLACE_TRANSFORM
    -> LINEAR_OPERATOR

# ---------- BASIC TRANSFORMS ----------
L{1}
    =
1/s

for
    Re(s) > 0

L{t^n}
    =
n!/s^(n+1)

for
    n = 0,1,2,...

L{exp(a*t)}
    =
1/(s-a)

for
    Re(s) > Re(a)

# ---------- SINE / COSINE ----------
L{sin(omega0*t)}
    =
omega0
/
(
    s^2 + omega0^2
)

L{cos(omega0*t)}
    =
s
/
(
    s^2 + omega0^2
)

TRIGONOMETRIC_FUNCTIONS
    -> rational_functions_of(s)

# ---------- DERIVATIVE PROPERTY ----------
for unilateral transform:

L{f'(t)}
    =
s*F(s)
-
f(0+)

L{f''(t)}
    =
s^2*F(s)
-
s*f(0+)
-
f'(0+)

more generally:

L{f^(n)(t)}
    =
s^n*F(s)
-
sum_from_k_0_to_nminus1(
    s^(n-1-k)
    *
    f^(k)(0+)
)

DERIVATIVE
    -> algebraic_polynomial_in(s)
       plus(INITIAL_DATA)

# ---------- INTEGRATION PROPERTY ----------
if

g(t)
    :=
integral_from_0_to_t(
    f(tau)
    d_tau
)

then

L{g(t)}
    =
F(s)/s

INTEGRATION
    -> division_by(s)

# ---------- MULTIPLICATION BY t ----------
L{
    t*f(t)
}
=
-
dF/ds

more generally

L{
    t^n*f(t)
}
=
(-1)^n
*
d^nF/ds^n

TIME_MULTIPLICATION
    -> FREQUENCY_DIFFERENTIATION

# ---------- FREQUENCY SHIFT ----------
L{
    exp(a*t)
    *
    f(t)
}
=
F(s-a)

EXPONENTIAL_MULTIPLICATION
    -> TRANSLATION_IN_s_DOMAIN

# ---------- TIME SHIFT ----------
for
    a > 0

L{
    u(t-a)
    *
    f(t-a)
}
=
exp(-a*s)
*
F(s)

u
    -> HEAVISIDE_STEP_FUNCTION

TIME_DELAY
    -> exponential_factor_in(s_DOMAIN)

# ---------- SCALING ----------
for
    a > 0

L{
    f(a*t)
}
=
1/a
*
F(s/a)

TIME_SCALING
    -> inverse_scaling_in(s_DOMAIN)

# ---------- CONVOLUTION ----------
(f*g)(t)
    :=
integral_from_0_to_t(
    f(tau)
    *
    g(t-tau)
    d_tau
)

CONVOLUTION_THEOREM:

L{f*g}
    =
F(s)*G(s)

CONVOLUTION
    -> multiplication_in(LAPLACE_DOMAIN)

# ---------- PERIODIC FUNCTION ----------
if
    f(t+T)
    = f(t)

then

L{f}
    =
[
    integral_from_0_to_T(
        exp(-s*t)*f(t)
        dt
    )
]
/
[
    1-exp(-s*T)
]

under
    convergence_conditions

PERIODIC_FUNCTION
    -> transform_from(ONE_PERIOD)

# ---------- HEAVISIDE FUNCTION ----------
u(t-a)
    :=
0
    for t < a

1
    for t >= a

L{u(t-a)}
    =
exp(-a*s)/s

STEP_FUNCTION
    -> models(SWITCHING_AND_DELAY)

# ---------- DIRAC DELTA ----------
in distributional context:

L{
    delta(t-a)
}
=
exp(-a*s)

for
    a >= 0

IMPULSE
    -> exponential_transform_factor

# ---------- INVERSE LAPLACE TRANSFORM ----------
INVERSE_LAPLACE_TRANSFORM
    -> recovers(f(t)_FROM_F(s))

methods:
    TRANSFORM_TABLE
    PARTIAL_FRACTIONS
    CONVOLUTION
    COMPLEX_INVERSION
    RESIDUE_METHOD

# ---------- BROMWICH INTEGRAL ----------
f(t)
    =
1/(2*pi*i)
*
integral_from_gamma_minus_i_infinity_to_gamma_plus_i_infinity(
    exp(s*t)
    *
    F(s)
    ds
)

gamma
    -> chosen_to_right_of_relevant_singularities

BROMWICH_INVERSION
    -> complex_contour_inverse_transform

# ---------- PARTIAL FRACTIONS ----------
if
    F(s)
        -> rational_function

then

PARTIAL_FRACTION_DECOMPOSITION
    -> separates(SIMPLE_TRANSFORM_COMPONENTS)

INVERSE_TRANSFORM
    -> obtained_from(KNOWN_PAIRS)

# ---------- POLES ----------
POLE_OF_F(s)
    -> often_corresponds_to(EXPONENTIAL_MODE_IN_TIME)

pole_location
    -> controls(GROWTH_DECAY_AND_OSCILLATION)

Re(pole) < 0
    -> decaying_mode

Re(pole) > 0
    -> growing_mode

complex_conjugate_poles
    -> oscillatory_modes_for_real_systems

# ---------- INITIAL VALUE THEOREM ----------
under appropriate hypotheses:

f(0+)
    =
lim_(s->infinity)(
    s*F(s)
)

INITIAL_VALUE_THEOREM
    -> extracts(INITIAL_BEHAVIOUR_FROM_TRANSFORM)

# ---------- FINAL VALUE THEOREM ----------
under stability and pole conditions:

lim_(t->infinity) f(t)
    =
lim_(s->0)(
    s*F(s)
)

FINAL_VALUE_THEOREM
    -> requires(POLES_OF_sF(s)_IN_ALLOWED_REGION)

FINAL_VALUE
    -/> valid_without(STABILITY_CONDITIONS)

# ---------- DIFFERENTIAL EQUATIONS ----------
ODE:
    a_n*y^(n)
    + ...
    + a_1*y'
    + a_0*y
    =
g(t)

apply
    LAPLACE_TRANSFORM

-> algebraic_equation_in(Y(s))

INITIAL_CONDITIONS
    -> incorporated_by(DERIVATIVE_PROPERTY)

solve_for
    Y(s)

then
    inverse_transform

LAPLACE_METHOD
    -> solves(INITIAL_VALUE_PROBLEMS)

# ---------- TRANSFER FUNCTION ----------
for linear time-invariant system
with zero initial conditions:

H(s)
    :=
Y(s)/X(s)

TRANSFER_FUNCTION
    -> input_output_relation_in(LAPLACE_DOMAIN)

POLES
    -> system_modes

ZEROS
    -> frequencies_or_modes_of_attenuation_structure

# ---------- STABILITY ----------
for continuous-time rational LTI system:

all poles_of_transfer_function
    in left_half_plane

-> asymptotic_stability
   under(STANDARD_FINITE_DIMENSIONAL_CAUSAL_CONTEXT)

POLE_LOCATION
    -> central_to(SYSTEM_STABILITY)

# ---------- FOURIER RELATION ----------
set

s
    =
sigma + i*omega

LAPLACE_TRANSFORM
    -> weighted_Fourier_transform_of(
        exp(-sigma*t)*f(t)
    )

FOURIER_TRANSFORM
    -> related_to(LAPLACE_TRANSFORM_ON_IMAGINARY_AXIS)
       when(ROC_INCLUDES_IMAGINARY_AXIS_AND_CONVENTIONS_MATCH)

LAPLACE
    -> generalises(FREQUENCY_ANALYSIS_WITH_EXPONENTIAL_WEIGHTING)

# ---------- APPLICATIONS ----------
LAPLACE_TRANSFORM
    -> applied_to(ORDINARY_DIFFERENTIAL_EQUATIONS)
    -> applied_to(PARTIAL_DIFFERENTIAL_EQUATIONS)
    -> applied_to(CONTROL_THEORY)
    -> applied_to(CIRCUIT_ANALYSIS)
    -> applied_to(SIGNAL_PROCESSING)
    -> applied_to(SYSTEM_DYNAMICS)
    -> applied_to(PROBABILITY)

# ---------- RELATION GRAPH ----------
TIME_FUNCTION
    -> LAPLACE_TRANSFORM
    -> COMPLEX_FREQUENCY_FUNCTION

DERIVATIVE
    -> multiplication_by(s)
       plus(INITIAL_CONDITIONS)

CONVOLUTION
    -> multiplication_in(LAPLACE_DOMAIN)

TIME_SHIFT
    -> exponential_factor

POLES
    -> encode(DYNAMIC_MODES)

INVERSE_LAPLACE_TRANSFORM
    -> reconstructs(TIME_FUNCTION)

FOURIER_TRANSFORM
    -> boundary_or_slice_relation_with(LAPLACE_TRANSFORM)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "Laplace transform" ~= "integral transform from time or real-variable domain to complex frequency domain",
    "inverse Laplace transform" ~= "reconstruction of the original function from its Laplace-domain representation",
    "region of convergence" ~= "set of complex frequencies where the Laplace integral converges",
    "transfer function" ~= "Laplace-domain input-output ratio under zero initial conditions",
    "time shift theorem" ~= "delay in time corresponds to multiplication by an exponential in the Laplace domain",
    "convolution theorem" ~= "Laplace transformation converts causal convolution into multiplication"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    unilateral_and_bilateral_transforms_must_not_be_confused: true,
    region_of_convergence_is_part_of_transform_semantics: true,
    derivative_property_for_unilateral_transform_includes_initial_values: true,
    inverse_transform_requires_valid_analytic_or_table_context: true,
    final_value_theorem_requires_pole_and_stability_conditions: true,
    Fourier_relation_requires_imaginary_axis_to_lie_in_relevant_ROC: true,
    transform_conventions_and_distributional_context_must_be_preserved: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    roc_relation: 0.99,
    derivative_initial_value_relation: 0.99,
    shift_convolution_relation: 0.99,
    inversion_relation: 0.99,
    ode_control_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function_or_system)
    -> identify(unilateral_or_bilateral_context)
    -> identify(complex_frequency_variable_and_ROC)
    -> test(existence_conditions)
    -> compute_or_recognise(transform)
    -> apply(linearity_shift_scaling_derivative_or_convolution_rules)
    -> solve(algebraic_transform_domain_problem_if_present)
    -> analyse(poles_zeros_and_stability_if_relevant)
    -> perform(inverse_transform)
    -> apply(initial_or_final_value_theorem_only_if_valid)
    -> compare_with(Fourier_transform_if_requested)
    -> validate(ROC_initial_data_and_pole_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed Laplace-transform semantic graph",
    primary_entity: LAPLACE_TRANSFORM,
    preserve: [
        input_function,
        transform_type,
        complex_frequency_variable,
        region_of_convergence,
        initial_conditions,
        poles,
        zeros,
        normalisation
    ],
    infer_through: [
        inverse_transforms,
        derivative_properties,
        time_shifts,
        frequency_shifts,
        convolutions,
        differential_equations,
        transfer_functions,
        stability
    ],
    avoid: [
        omitting_ROC,
        dropping_initial_conditions_in unilateral derivative transforms,
        applying_final_value_theorem_without pole conditions,
        confusing_Laplace_and_Fourier transforms,
        treating_distributional_impulses_as ordinary functions,
        ignoring_causality_or_transform_type
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + LAPLACE_TRANSFORM
    + INVERSE_LAPLACE_TRANSFORM
    + REGION_OF_CONVERGENCE
    + DERIVATIVE_PROPERTY
    + TIME_SHIFT
    + CONVOLUTION
    + INITIAL_VALUE_THEOREM
    + FINAL_VALUE_THEOREM
    + TRANSFER_FUNCTION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> LAPLACE_TRANSFORM
    -> FUNCTION_SYSTEM_IDENTIFICATION
    -> TRANSFORM_TYPE_ANALYSIS
    -> ROC_EXISTENCE_ANALYSIS
    -> TRANSFORM_COMPUTATION
    -> PROPERTY_APPLICATION
    -> ALGEBRAIC_DOMAIN_SOLUTION
    -> POLE_ZERO_STABILITY_ANALYSIS
    -> INVERSE_TRANSFORM
    -> VALUE_THEOREM_ANALYSIS
    -> FOURIER_RELATION_ANALYSIS
    -> HYPOTHESIS_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW