Implicit Differentiation Ontology

flow "ImplicitDifferentiationOntology" v1.0

# ============================================================
# IMPLICIT DIFFERENTIATION ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
IMPLICIT_DIFFERENTIATION := {
    type: DifferentiationMethod,
    domain: DifferentialCalculus,
    purpose: "Differentiate relationships in which a dependent variable is defined implicitly rather than isolated explicitly as a function of the independent variable."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    IMPLICIT_RELATION,
    INDEPENDENT_VARIABLE,
    DEPENDENT_VARIABLE,
    DERIVATIVE,
    PARTIAL_DERIVATIVE,
    CHAIN_RULE,
    IMPLICIT_FUNCTION,
    IMPLICIT_FUNCTION_THEOREM,
    TOTAL_DERIVATIVE,
    LEVEL_SET,
    TANGENT_SLOPE,
    DIFFERENTIABILITY
}

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

IMPLICIT_RELATION
    -> constrains(x,y)
    -> may_define(y_as_function_of_x_locally)
       under(APPROPRIATE_CONDITIONS)

EXPLICIT_RELATION
    := y = f(x)

IMPLICIT_DIFFERENTIATION
    -> avoids(REQUIRING_GLOBAL_EXPLICIT_SOLUTION_FOR_y)

# ---------- VARIABLE ROLES ----------
within
    F(x,y) = 0

x
    -> commonly(INDEPENDENT_VARIABLE)

y
    -> treated_as(DEPENDENT_VARIABLE)
    -> treated_as(function_of(x))

DEPENDENT_VARIABLE
    -> must_receive(CHAIN_RULE_FACTOR)
       when differentiated_with_respect_to(x)

# ---------- BASIC PROCEDURE ----------
IMPLICIT_DIFFERENTIATION_PROCESS:
    start(F(x,y)=0)
    -> differentiate(BOTH_SIDES_WITH_RESPECT_TO_x)
    -> apply(CHAIN_RULE_TO_TERMS_CONTAINING_y)
    -> collect(TERMS_CONTAINING_dy_dx)
    -> solve_for(dy_dx)
    -> validate(DOMAIN_AND_DENOMINATOR_CONDITIONS)

# ---------- PARTIAL DERIVATIVE FORM ----------
if
    F(x,y) = 0
    AND F is sufficiently_differentiable
    AND partial_F/partial_y != 0
then

dy/dx
    = -(partial_F/partial_x)
      /(partial_F/partial_y)

IMPLICIT_DERIVATIVE
    -> determined_by(PARTIAL_DERIVATIVES_OF_RELATION)

# ---------- TOTAL DIFFERENTIAL FORM ----------
F(x,y) = 0

dF
    = F_x dx + F_y dy
    = 0

if
    F_y != 0
then

dy/dx
    = -F_x/F_y

TOTAL_DIFFERENTIAL
    -> provides(ALTERNATIVE_DERIVATION)

# ---------- CHAIN RULE ----------
if
    term = g(y)
    AND y = y(x)
then

d/dx[g(y)]
    = g_prime(y) * dy/dx

CHAIN_RULE
    -> essential_to(IMPLICIT_DIFFERENTIATION)

d/dx[y^n]
    = n*y^(n-1)*dy/dx

# ---------- EXAMPLE STRUCTURE ----------
relation:
    x^2 + y^2 = r^2

differentiate_with_respect_to(x):

2x + 2y*(dy/dx) = 0

therefore:

dy/dx = -x/y
    when(y != 0)

IMPLICIT_DIFFERENTIATION
    -> computes(TANGENT_SLOPE_WITHOUT_SOLVING_GLOBALLY_FOR_y)

# ---------- IMPLICIT FUNCTION THEOREM ----------
if
    F(a,b) = 0
    AND F continuously_differentiable_near(a,b)
    AND F_y(a,b) != 0
then

there_exists(local_function y=f(x))
    near(a,b)

such_that
    F(x,f(x)) = 0

and

f_prime(x)
    = -F_x/F_y

IMPLICIT_FUNCTION_THEOREM
    -> provides(LOCAL_EXISTENCE_AND_DIFFERENTIABILITY_CONDITIONS)

# ---------- VERTICAL TANGENTS ----------
if
    F_y = 0
    AND F_x != 0
then
    dy/dx_formula
        -> undefined_or_unbounded

VERTICAL_TANGENT
    -> may_occur
       under(appropriate_local_conditions)

ALTERNATIVE_PARAMETERISATION
    -> may_use(x_as_function_of_y)

dx/dy
    = -F_y/F_x
       when(F_x != 0)

# ---------- HIGHER DERIVATIVES ----------
SECOND_IMPLICIT_DERIVATIVE
    -> obtained_by(DIFFERENTIATING_FIRST_IMPLICIT_DERIVATIVE_AGAIN)

d2y/dx2
    -> may_depend_on(x,y,dy/dx)

HIGHER_IMPLICIT_DERIVATIVES
    -> require(REPEATED_CHAIN_RULE_APPLICATION)

# ---------- MULTIVARIABLE GENERALISATION ----------
IMPLICIT_SYSTEM
    := F(x,y) = 0

where
    x in R^n
    y in R^m

if
    J_y F
        -> invertible
       under(implicit_function_theorem_conditions)
then

Dy/Dx
    = -(J_y F)^(-1) * J_x F

IMPLICIT_DIFFERENTIATION
    -> generalises_to(SYSTEMS_OF_EQUATIONS)

# ---------- LEVEL SET INTERPRETATION ----------
LEVEL_SET
    := F(x,y) = c

GRADIENT(F)
    -> normal_to(LEVEL_SET)
       at(REGULAR_POINTS)

TANGENT_DIRECTION
    -> orthogonal_to(GRADIENT)

IMPLICIT_DERIVATIVE
    -> encodes(TANGENT_DIRECTION_IN_COORDINATE_FORM)

# ---------- APPLICATIONS ----------
IMPLICIT_DIFFERENTIATION
    -> applied_to(IMPLICIT_CURVES)
    -> applied_to(CONSTRAINED_RELATIONS)
    -> applied_to(RELATED_RATES)
    -> applied_to(LEVEL_SETS)
    -> applied_to(NONLINEAR_SYSTEMS)
    -> applied_to(GEOMETRIC_CURVES)

# ---------- RELATION GRAPH ----------
IMPLICIT_RELATION
    -> differentiated_by(IMPLICIT_DIFFERENTIATION)

CHAIN_RULE
    -> enables(DERIVATIVE_OF_DEPENDENT_TERMS)

PARTIAL_DERIVATIVES
    -> determine(IMPLICIT_DERIVATIVE)

IMPLICIT_FUNCTION_THEOREM
    -> justifies(LOCAL_FUNCTION_REPRESENTATION)

GRADIENT
    -> normal_to(REGULAR_LEVEL_SET)

IMPLICIT_DERIVATIVE
    -> determines(TANGENT_SLOPE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "implicit differentiation" ~= "differentiation of an equation while treating the dependent variable as a function of the independent variable",
    "implicit derivative" ~= "derivative obtained from an implicit relation",
    "F_x" ~= "partial derivative of F with respect to x",
    "F_y" ~= "partial derivative of F with respect to y",
    "implicit curve" ~= "curve represented by a relation such as F(x,y)=0",
    "local implicit function" ~= "locally defined dependent variable guaranteed under suitable implicit-function conditions"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    dependent_variable_must_be_treated_as_function: true,
    chain_rule_required_for_dependent_variable_terms: true,
    formula_minus_Fx_over_Fy_requires_Fy_nonzero: true,
    implicit_relation_need_not_define_global_single_valued_function: true,
    implicit_function_theorem_is_local: true,
    denominator_zero_requires_separate_analysis: true,
    tangent_interpretation_requires_regular_point_conditions: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_method: 0.99,
    chain_rule_relation: 0.99,
    partial_derivative_formula: 0.99,
    implicit_function_theorem_relation: 0.99,
    level_set_relation: 0.98,
    multivariable_generalisation: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(implicit_relation)
    -> identify(independent_and_dependent_variables)
    -> determine(local_domain)
    -> differentiate(both_sides)
    -> apply(chain_rule_to_dependent_terms)
    -> collect(derivative_terms)
    -> solve_for(requested_derivative)
    -> test(denominator_and_regular_point_conditions)
    -> invoke(implicit_function_theorem_if_relevant)
    -> analyse(tangent_or_higher_derivative_if_required)
    -> validate(mathematical_consistency)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed implicit-differentiation semantic graph",
    primary_entity: IMPLICIT_DIFFERENTIATION,
    preserve: [
        variable_roles,
        chain_rule_dependencies,
        partial_derivative_structure,
        denominator_conditions,
        local_function_conditions,
        regular_point_conditions
    ],
    infer_through: [
        derivatives,
        partial_derivatives,
        total_differentials,
        implicit_function_theorem,
        gradients,
        level_sets,
        higher_derivatives
    ],
    avoid: [
        differentiating_y_as_constant,
        omitting_dy_dx_chain_factor,
        dividing_by_Fy_when_zero,
        assuming_global_explicit_function_exists,
        treating_local_implicit_function_result_as_global
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + IMPLICIT_RELATION
    + IMPLICIT_DIFFERENTIATION
    + CHAIN_RULE
    + TOTAL_DIFFERENTIAL
    + IMPLICIT_FUNCTION_THEOREM
    + LEVEL_SET
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> IMPLICIT_DIFFERENTIATION
    -> RELATION_IDENTIFICATION
    -> VARIABLE_ROLE_ANALYSIS
    -> DOMAIN_ANALYSIS
    -> DIFFERENTIATION
    -> CHAIN_RULE_APPLICATION
    -> DERIVATIVE_ISOLATION
    -> REGULARITY_ANALYSIS
    -> IMPLICIT_FUNCTION_ANALYSIS
    -> TANGENT_ANALYSIS
    -> HIGHER_DERIVATIVE_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW