Differential Calculus

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

flow "DifferentialCalculusOntology" v1.0

# ============================================================
# DIFFERENTIAL CALCULUS — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
DIFFERENTIAL_CALCULUS := {
    type: MathematicalDiscipline,
    domain: Mathematics,
    parent: Calculus,
    purpose: "Study instantaneous rates of change, derivatives, local function behaviour, approximation, extrema and related differential structures."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    FUNCTION,
    VARIABLE,
    LIMIT,
    CONTINUITY,
    DIFFERENCE_QUOTIENT,
    DERIVATIVE,
    DIFFERENTIATION,
    DIFFERENTIAL,
    TANGENT,
    RATE_OF_CHANGE,
    CRITICAL_POINT,
    EXTREMUM,
    MONOTONICITY,
    CONCAVITY,
    INFLECTION_POINT,
    HIGHER_DERIVATIVE
}

# ---------- FOUNDATIONAL STRUCTURE ----------
DIFFERENTIAL_CALCULUS
    -> branch_of(CALCULUS)
    -> depends_on(FUNCTIONS)
    -> depends_on(LIMITS)
    -> studies(LOCAL_CHANGE)
    -> studies(DERIVATIVES)
    -> supports(OPTIMISATION)
    -> supports(APPROXIMATION)
    -> supports(DIFFERENTIAL_EQUATIONS)

# ---------- AVERAGE RATE OF CHANGE ----------
AVERAGE_RATE_OF_CHANGE
    := (f(b)-f(a))/(b-a)

SECANT_SLOPE
    ~= AVERAGE_RATE_OF_CHANGE

AVERAGE_RATE_OF_CHANGE
    -> measures(CHANGE_OVER_FINITE_INTERVAL)

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

DIFFERENCE_QUOTIENT
    -> represents(AVERAGE_RATE_OVER_INTERVAL_OF_WIDTH_h)

h -> 0
    -> DIFFERENCE_QUOTIENT
    -> DERIVATIVE
       when(limit_exists)

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

DERIVATIVE
    -> measures(INSTANTANEOUS_RATE_OF_CHANGE)
    -> represents(TANGENT_SLOPE)
    -> describes(LOCAL_LINEAR_BEHAVIOUR)

DERIVATIVE_AT_POINT
    -> exists_only_when(DIFFERENCE_QUOTIENT_LIMIT_EXISTS_FINITE)

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

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

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

NONDIFFERENTIABILITY
    -> may_result_from(DISCONTINUITY)
    -> may_result_from(CORNER)
    -> may_result_from(CUSP)
    -> may_result_from(VERTICAL_TANGENT)
    -> may_result_from(OSCILLATORY_DIFFERENCE_QUOTIENT)

# ---------- DIFFERENTIATION ----------
DIFFERENTIATION
    -> operation_on(FUNCTION)
    -> produces(DERIVATIVE_FUNCTION)

f
    -> differentiate
    -> f_prime

DIFFERENTIATION
    -> may_be(SYMBOLIC)
    -> may_be(NUMERICAL)
    -> may_be(AUTOMATIC_IN_COMPUTATIONAL_CONTEXT)

# ---------- BASIC 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

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)

# ---------- IMPLICIT DIFFERENTIATION ----------
IMPLICIT_RELATION
    := F(x,y) = 0

IMPLICIT_DIFFERENTIATION
    -> differentiates(BOTH_SIDES_WITH_RESPECT_TO_x)
    -> treats(y_as_function_of_x)
       when(local_function_conditions_hold)

dy/dx
    -> solved_from(DIFFERENTIATED_RELATION)

# ---------- HIGHER DERIVATIVES ----------
SECOND_DERIVATIVE
    := derivative(DERIVATIVE)

THIRD_DERIVATIVE
    := derivative(SECOND_DERIVATIVE)

NTH_DERIVATIVE
    := repeated_differentiation(n)

HIGHER_DERIVATIVE
    -> describes(HIGHER_ORDER_LOCAL_CHANGE)

SECOND_DERIVATIVE
    -> supports(CONCAVITY_ANALYSIS)
    -> may_represent(ACCELERATION)
       when(first_derivative_represents_velocity)

# ---------- MONOTONICITY ----------
if
    f_prime(x) > 0
    over(interval)
then
    f -> increasing_on(interval)

if
    f_prime(x) < 0
    over(interval)
then
    f -> decreasing_on(interval)

DERIVATIVE_SIGN
    -> supports(MONOTONICITY_ANALYSIS)

# ---------- CRITICAL POINTS ----------
CRITICAL_POINT
    -> occurs_at(INTERIOR_DOMAIN_POINT)
       where(
           f_prime(x) = 0
           OR f_prime(x) does_not_exist
       )

CRITICAL_POINT
    -> candidate_for(LOCAL_EXTREMUM)

CRITICAL_POINT
    -/> necessarily_is(EXTREMUM)

# ---------- EXTREMA ----------
LOCAL_MAXIMUM
    -> function_value_greater_than_or_equal_to(NEARBY_VALUES)

LOCAL_MINIMUM
    -> function_value_less_than_or_equal_to(NEARBY_VALUES)

FIRST_DERIVATIVE_TEST
    -> classifies(CRITICAL_POINTS)
       using(DERIVATIVE_SIGN_CHANGE)

SECOND_DERIVATIVE_TEST:
    if
        f_prime(a) = 0
        AND f_double_prime(a) > 0
    then
        a -> LOCAL_MINIMUM

    if
        f_prime(a) = 0
        AND f_double_prime(a) < 0
    then
        a -> LOCAL_MAXIMUM

# ---------- CONCAVITY ----------
if
    f_double_prime(x) > 0
    over(interval)
then
    f -> concave_up_on(interval)

if
    f_double_prime(x) < 0
    over(interval)
then
    f -> concave_down_on(interval)

INFLECTION_POINT
    -> requires(CHANGE_IN_CONCAVITY)

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

# ---------- LINEAR APPROXIMATION ----------
LINEARISATION_AT_a
    := f(a) + f_prime(a)*(x-a)

LINEARISATION
    -> approximates(FUNCTION_NEAR_POINT)
    -> uses(TANGENT_LINE)

DIFFERENTIAL
    := dy = f_prime(x)*dx

DIFFERENTIAL
    -> approximates(SMALL_OUTPUT_CHANGE)
       for(SMALL_INPUT_CHANGE)

# ---------- MEAN VALUE THEOREM ----------
if
    f continuous_on([a,b])
    AND f differentiable_on((a,b))
then
    exists c in (a,b)
        such_that
        f_prime(c)
        = (f(b)-f(a))/(b-a)

MEAN_VALUE_THEOREM
    -> connects(AVERAGE_RATE_OF_CHANGE, INSTANTANEOUS_RATE_OF_CHANGE)

# ---------- ROLLE'S THEOREM ----------
if
    f continuous_on([a,b])
    AND f differentiable_on((a,b))
    AND f(a) = f(b)
then
    exists c in (a,b)
        such_that
        f_prime(c) = 0

ROLLES_THEOREM
    -> special_case_of(MEAN_VALUE_THEOREM)

# ---------- APPLICATIONS ----------
DIFFERENTIAL_CALCULUS
    -> applied_to(MOTION)
    -> applied_to(OPTIMISATION)
    -> applied_to(SENSITIVITY_ANALYSIS)
    -> applied_to(ECONOMICS)
    -> applied_to(PHYSICS)
    -> applied_to(ENGINEERING)
    -> applied_to(BIOLOGY)
    -> applied_to(MACHINE_LEARNING)

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

DERIVATIVE
    -> measures(LOCAL_CHANGE)

DERIVATIVE
    -> determines(TANGENT_SLOPE)

DERIVATIVE_SIGN
    -> informs(MONOTONICITY)

SECOND_DERIVATIVE
    -> informs(CONCAVITY)

CRITICAL_POINTS
    -> support(EXTREMA_ANALYSIS)

DERIVATIVE
    -> supports(LINEAR_APPROXIMATION)

DIFFERENTIAL_CALCULUS
    -> connects_to(INTEGRAL_CALCULUS)
       through(FUNDAMENTAL_THEOREM_OF_CALCULUS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "instantaneous rate of change" ~= "derivative",
    "slope of tangent" ~= "derivative in standard Cartesian function context",
    "first derivative" ~= "derivative of the original function",
    "second derivative" ~= "derivative of the first derivative",
    "stationary point" ~= "point where first derivative equals zero",
    "linear approximation" ~= "first-order local approximation using tangent information"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    derivative_requires_limit: true,
    differentiability_implies_continuity: true,
    continuity_does_not_imply_differentiability: true,
    stationary_point_does_not_guarantee_extremum: true,
    second_derivative_zero_does_not_guarantee_inflection: true,
    derivative_rules_require_their_domain_conditions: true,
    local_derivative_information_does_not_automatically_determine_global_behaviour: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    discipline_structure: 0.99,
    derivative_definition: 0.99,
    differentiation_rules: 0.99,
    extrema_relations: 0.99,
    approximation_relations: 0.98,
    theorem_relations: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function)
    -> determine(domain)
    -> evaluate(limit_requirements)
    -> determine(differentiability)
    -> compute_or_reason_about(first_derivative)
    -> analyse(derivative_sign)
    -> identify(critical_points)
    -> compute_or_reason_about(second_derivative)
    -> analyse(concavity_and_inflection)
    -> analyse(extrema)
    -> construct(local_approximation_if_required)
    -> apply(relevant_theorems)
    -> validate(mathematical_consistency)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed differential-calculus semantic graph",
    primary_entity: DIFFERENTIAL_CALCULUS,
    preserve: [
        derivative_definition,
        limit_dependency,
        domain_conditions,
        implication_direction,
        differentiation_rules,
        theorem_hypotheses
    ],
    infer_through: [
        limits,
        continuity,
        derivatives,
        critical_points,
        monotonicity,
        extrema,
        concavity,
        approximation
    ],
    avoid: [
        assuming_continuity_implies_differentiability,
        classifying_every_stationary_point_as_extremum,
        classifying_second_derivative_zero as automatic inflection,
        applying derivative rules outside their domains,
        inferring global behaviour from isolated local information
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + DIFFERENCE_QUOTIENT
    + DERIVATIVE
    + DIFFERENTIABILITY
    + DIFFERENTIATION
    + CRITICAL_POINT
    + EXTREMUM
    + CONCAVITY
    + MEAN_VALUE_THEOREM
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> DIFFERENTIAL_CALCULUS
    -> FUNCTION_IDENTIFICATION
    -> DOMAIN_ANALYSIS
    -> LIMIT_ANALYSIS
    -> DIFFERENTIABILITY_ANALYSIS
    -> DERIVATIVE_ANALYSIS
    -> MONOTONICITY_ANALYSIS
    -> CRITICAL_POINT_ANALYSIS
    -> EXTREMA_ANALYSIS
    -> CONCAVITY_ANALYSIS
    -> APPROXIMATION_ANALYSIS
    -> THEOREM_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW