Derivative Ontology

flow "DerivativeOntology" v1.0

# ============================================================
# DERIVATIVE ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/differential-calculus/derivative-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Differential Calculus"
ENTITY := "Derivative"

# ---------- CORE ENTITY ----------
DERIVATIVE := {
    type: MathematicalOperatorResult,
    domain: DifferentialCalculus,
    purpose: "Represent the instantaneous rate of change of a function with respect to a variable and the local linear behaviour of that function."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    FUNCTION,
    VARIABLE,
    LIMIT,
    DIFFERENCE_QUOTIENT,
    DERIVATIVE,
    DIFFERENTIATION,
    DIFFERENTIABILITY,
    TANGENT_LINE,
    RATE_OF_CHANGE,
    SLOPE,
    DIFFERENTIAL,
    HIGHER_DERIVATIVE,
    PARTIAL_DERIVATIVE,
    DIRECTIONAL_DERIVATIVE
}

# ---------- DEFINITION ----------
DERIVATIVE(f, x)
    := limit(
        (f(x+h)-f(x))/h,
        h -> 0
    )

DERIVATIVE_AT_POINT(f, a)
    := limit(
        (f(a+h)-f(a))/h,
        h -> 0
    )

DERIVATIVE
    -> exists_when(DIFFERENCE_QUOTIENT_LIMIT_EXISTS_AS_FINITE_VALUE)

# ---------- DIFFERENCE QUOTIENT ----------
DIFFERENCE_QUOTIENT
    := (f(x+h)-f(x))/h

DIFFERENCE_QUOTIENT
    -> measures(AVERAGE_RATE_OF_CHANGE_OVER_INCREMENT_h)

h -> 0
    -> secant_slope
    -> tangent_slope
       when(DERIVATIVE_EXISTS)

# ---------- RATE OF CHANGE ----------
AVERAGE_RATE_OF_CHANGE
    := delta_y / delta_x

INSTANTANEOUS_RATE_OF_CHANGE
    := DERIVATIVE

DERIVATIVE
    -> quantifies(LOCAL_CHANGE)
    -> relates(DEPENDENT_VARIABLE_CHANGE, INDEPENDENT_VARIABLE_CHANGE)

# ---------- GEOMETRIC INTERPRETATION ----------
DERIVATIVE_AT_POINT
    -> equals(TANGENT_LINE_SLOPE)
       in(standard_graph_context)

TANGENT_LINE_AT_a
    := y - f(a)
       = f_prime(a)*(x-a)

DERIVATIVE
    -> provides(LOCAL_LINEAR_APPROXIMATION)

# ---------- NOTATION ----------
DERIVATIVE_NOTATION := {
    "f'(x)",
    "df/dx",
    "D_x f",
    "y'",
    "dy/dx"
}

NOTATION
    -> context_dependent_representation_of(DERIVATIVE)

# ---------- DIFFERENTIABILITY ----------
DIFFERENTIABLE_AT(f, a)
    iff
    DERIVATIVE_AT_POINT(f, a) exists

DIFFERENTIABLE_AT(f, a)
    -> implies(CONTINUOUS_AT(f, a))

CONTINUOUS_AT(f, a)
    -/> necessarily_implies(DIFFERENTIABLE_AT(f, a))

# ---------- BASIC DERIVATIVE RULES ----------
CONSTANT_RULE:
    d/dx(c) = 0

POWER_RULE:
    d/dx(x^n) = n*x^(n-1)
    under(appropriate_domain_conditions)

SUM_RULE:
    d/dx(f+g)
        = f_prime + g_prime

DIFFERENCE_RULE:
    d/dx(f-g)
        = f_prime - g_prime

CONSTANT_MULTIPLE_RULE:
    d/dx(c*f)
        = c*f_prime

PRODUCT_RULE:
    d/dx(f*g)
        = f_prime*g + f*g_prime

QUOTIENT_RULE:
    d/dx(f/g)
        = (f_prime*g - f*g_prime)/(g^2)
        when(g != 0)

CHAIN_RULE:
    d/dx[f(g(x))]
        = f_prime(g(x))*g_prime(x)
        when(required_differentiability_conditions_hold)

# ---------- COMMON DERIVATIVES ----------
d/dx(e^x)
    = e^x

d/dx(ln(x))
    = 1/x
    for(x > 0 in real_context)

d/dx(sin(x))
    = cos(x)

d/dx(cos(x))
    = -sin(x)

d/dx(tan(x))
    = sec(x)^2
    where(tan_defined)

# ---------- HIGHER DERIVATIVES ----------
FIRST_DERIVATIVE
    := f_prime

SECOND_DERIVATIVE
    := derivative(f_prime)

THIRD_DERIVATIVE
    := derivative(f_double_prime)

NTH_DERIVATIVE
    := repeated_derivative(n)

HIGHER_DERIVATIVES
    -> represent(HIGHER_ORDER_CHANGE)

SECOND_DERIVATIVE
    -> may_describe(CHANGE_OF_RATE)
    -> supports(CONCAVITY_ANALYSIS)

# ---------- PARTIAL DERIVATIVE ----------
MULTIVARIABLE_FUNCTION
    := f(x1, x2, ..., xn)

PARTIAL_DERIVATIVE
    -> differentiates_with_respect_to(ONE_VARIABLE)
    -> holds(OTHER_VARIABLES_FIXED)
       under(defined_context)

partial_f/partial_x_i
    -> measures(LOCAL_CHANGE_ALONG_COORDINATE_DIRECTION)

# ---------- DIRECTIONAL DERIVATIVE ----------
DIRECTIONAL_DERIVATIVE
    -> measures(LOCAL_RATE_OF_CHANGE_ALONG_DIRECTION)

for differentiable scalar field f:
    D_u f
        = gradient(f) dot u
        when(u_is_unit_direction)

GRADIENT
    -> collects(PARTIAL_DERIVATIVES)

# ---------- DIFFERENTIAL ----------
DIFFERENTIAL
    := dy = f_prime(x)*dx

DIFFERENTIAL
    -> first_order_approximation_of(CHANGE_IN_OUTPUT)

for small delta_x:
    delta_y ~= f_prime(x)*delta_x

# ---------- MONOTONICITY ----------
if
    f_prime(x) > 0
    throughout(interval)
then
    f -> increasing_on(interval)
       under(standard_conditions)

if
    f_prime(x) < 0
    throughout(interval)
then
    f -> decreasing_on(interval)
       under(standard_conditions)

DERIVATIVE_SIGN
    -> informs(MONOTONICITY)

# ---------- CRITICAL POINTS ----------
CRITICAL_NUMBER
    -> domain_value(c)
       where(
           f_prime(c) = 0
           OR f_prime(c) does_not_exist
       )

CRITICAL_NUMBER
    -> candidate_location_for(LOCAL_EXTREMUM)

f_prime(c) = 0
    -/> guarantees(EXTREMUM)

# ---------- SECOND DERIVATIVE ----------
if
    f_double_prime(x) > 0
then
    -> local_concavity(CONCAVE_UP)

if
    f_double_prime(x) < 0
then
    -> local_concavity(CONCAVE_DOWN)

INFLECTION_POINT
    -> requires(CHANGE_IN_CONCAVITY)

f_double_prime(c) = 0
    -/> sufficient_for(INFLECTION_POINT)

# ---------- PHYSICAL INTERPRETATION ----------
if
    position = s(t)
then
    velocity
        := ds/dt

    acceleration
        := d2s/dt2

DERIVATIVE
    -> maps(POSITION, VELOCITY)
    -> maps(VELOCITY, ACCELERATION)

# ---------- MARGINAL INTERPRETATION ----------
DERIVATIVE
    -> may_represent(MARGINAL_CHANGE)
       in(ECONOMIC_MODELS)

MARGINAL_COST
    := derivative(COST_FUNCTION)

MARGINAL_REVENUE
    := derivative(REVENUE_FUNCTION)

# ---------- NONDIFFERENTIABLE CASES ----------
DERIVATIVE
    -> may_fail_to_exist_at(DISCONTINUITY)
    -> may_fail_to_exist_at(CORNER)
    -> may_fail_to_exist_at(CUSP)
    -> may_fail_to_exist_at(VERTICAL_TANGENT_IN_FINITE_DERIVATIVE_CONTEXT)
    -> may_fail_to_exist_due_to(OSCILLATION)

NONDIFFERENTIABLE
    -/> necessarily_implies(DISCONTINUOUS)

# ---------- RELATION GRAPH ----------
LIMIT
    -> defines(DERIVATIVE)

DIFFERENCE_QUOTIENT
    -> approaches(DERIVATIVE)

DERIVATIVE
    -> represents(INSTANTANEOUS_RATE_OF_CHANGE)

DERIVATIVE
    -> determines(TANGENT_SLOPE)

DERIVATIVE
    -> supports(MONOTONICITY_ANALYSIS)

DERIVATIVE
    -> supports(EXTREMA_ANALYSIS)

SECOND_DERIVATIVE
    -> supports(CONCAVITY_ANALYSIS)

DERIVATIVE
    -> supports(LOCAL_LINEARISATION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "derivative" ~= "instantaneous rate of change",
    "first derivative" ~= "derivative of the original function",
    "tangent slope" ~= "derivative at a point in standard Cartesian graph context",
    "differential coefficient" ~= "derivative in traditional terminology",
    "rate of change at a point" ~= "derivative when the relevant limit exists",
    "local linear coefficient" ~= "derivative in first-order approximation context"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    derivative_requires_limit: true,
    differentiability_implies_continuity: true,
    continuity_does_not_imply_differentiability: true,
    derivative_zero_does_not_guarantee_extremum: true,
    second_derivative_zero_does_not_guarantee_inflection: true,
    derivative_rules_require_domain_conditions: true,
    finite_derivative_distinguished_from_infinite_slope: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    derivative_definition: 0.99,
    rate_of_change_relation: 0.99,
    geometric_relation: 0.99,
    derivative_rules: 0.99,
    higher_derivative_relations: 0.99,
    multivariable_relations: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function)
    -> identify(variable_of_differentiation)
    -> determine(domain)
    -> construct(difference_quotient)
    -> evaluate(limit)
    -> determine(differentiability)
    -> apply(valid_derivative_rules)
    -> derive(higher_or_partial_derivatives_if_required)
    -> interpret(rate_of_change)
    -> analyse(monotonicity_or_extrema_if_required)
    -> validate(domain_and_limit_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed derivative semantic graph",
    primary_entity: DERIVATIVE,
    preserve: [
        variable_of_differentiation,
        limit_definition,
        domain_conditions,
        differentiation_rules,
        implication_direction,
        derivative_order
    ],
    infer_through: [
        limits,
        functions,
        difference_quotients,
        continuity,
        higher_derivatives,
        partial_derivatives,
        monotonicity,
        extrema
    ],
    avoid: [
        treating_average_rate_as_instantaneous_rate,
        assuming_continuity_implies_differentiability,
        treating_zero_derivative_as_automatic_extremum,
        applying_derivative_rules_outside_domain,
        treating_infinite_slope_as_ordinary_finite_derivative
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + DERIVATIVE
    + DIFFERENCE_QUOTIENT
    + DIFFERENTIABILITY
    + DERIVATIVE_NOTATION
    + HIGHER_DERIVATIVES
    + PARTIAL_DERIVATIVE
    + DIRECTIONAL_DERIVATIVE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> DERIVATIVE
    -> FUNCTION_IDENTIFICATION
    -> VARIABLE_IDENTIFICATION
    -> DOMAIN_ANALYSIS
    -> DIFFERENCE_QUOTIENT_ANALYSIS
    -> LIMIT_ANALYSIS
    -> DIFFERENTIABILITY_ANALYSIS
    -> DERIVATIVE_RULE_ANALYSIS
    -> HIGHER_DERIVATIVE_ANALYSIS
    -> INTERPRETATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW