Quotient Rule Ontology

flow "QuotientRuleOntology" v1.0

# ============================================================
# QUOTIENT RULE ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
QUOTIENT_RULE := {
    type: DifferentiationRule,
    domain: DifferentialCalculus,
    purpose: "Determine the derivative of a quotient of differentiable functions where the denominator is nonzero."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    QUOTIENT_FUNCTION,
    NUMERATOR,
    DENOMINATOR,
    DERIVATIVE,
    DIFFERENTIATION,
    PRODUCT_RULE,
    CHAIN_RULE,
    RECIPROCAL_FUNCTION,
    DOMAIN,
    PARTIAL_DERIVATIVE,
    LOGARITHMIC_DIFFERENTIATION
}

# ---------- QUOTIENT STRUCTURE ----------
QUOTIENT_FUNCTION
    := h(x) = f(x)/g(x)

NUMERATOR
    := f(x)

DENOMINATOR
    := g(x)

DOMAIN
    -> excludes(points_where(g(x)=0))

# ---------- BASIC QUOTIENT RULE ----------
if
    f differentiable_at(x)
    AND g differentiable_at(x)
    AND g(x) != 0
then

h_prime(x)
    = [f_prime(x)*g(x) - f(x)*g_prime(x)]
      / [g(x)]^2

QUOTIENT_RULE
    := (f/g)'
       = (f'*g - f*g') / g^2

# ---------- STRUCTURAL INTERPRETATION ----------
QUOTIENT_DERIVATIVE_NUMERATOR
    := derivative_of_numerator * denominator
       - numerator * derivative_of_denominator

QUOTIENT_DERIVATIVE_DENOMINATOR
    := denominator^2

QUOTIENT_RULE
    -> combines(NUMERATOR_CHANGE, DENOMINATOR_CHANGE)

# ---------- DERIVATION VIA PRODUCT RULE ----------
f/g
    = f * g^(-1)

differentiate:

D(f*g^(-1))
    = f_prime*g^(-1)
      + f*D(g^(-1))

using(CHAIN_RULE):

D(g^(-1))
    = -g^(-2)*g_prime

therefore:

D(f/g)
    = f_prime/g
      - f*g_prime/g^2

    = (f_prime*g - f*g_prime)/g^2

QUOTIENT_RULE
    -> derivable_from(PRODUCT_RULE + CHAIN_RULE)

# ---------- RECIPROCAL RULE ----------
RECIPROCAL_FUNCTION
    := 1/g(x)

if
    g(x) != 0
then

D[1/g]
    = -g_prime/g^2

RECIPROCAL_RULE
    -> special_case_of(QUOTIENT_RULE)

# ---------- CONSTANT NUMERATOR ----------
if
    c constant
then

D[c/g]
    = -c*g_prime/g^2

CONSTANT_NUMERATOR_QUOTIENT
    -> follows_from(QUOTIENT_RULE)

# ---------- CONSTANT DENOMINATOR ----------
if
    c != 0 constant
then

D[f/c]
    = f_prime/c

CONSTANT_DENOMINATOR
    -> reduces_to(CONSTANT_MULTIPLE_RULE)

# ---------- DOMAIN CONDITIONS ----------
g(x) = 0
    -> quotient_function_undefined_at(x)

QUOTIENT_RULE
    -> applicable_only_where(DENOMINATOR_NONZERO)

DERIVATIVE_OF_QUOTIENT
    -> cannot_be_assigned_by_rule_at(EXCLUDED_DOMAIN_POINT)

DOMAIN_ANALYSIS
    -> precedes(QUOTIENT_RULE_APPLICATION)

# ---------- PARTIAL DERIVATIVE FORM ----------
for
    h(x1,...,xn)
        = f(x1,...,xn)/g(x1,...,xn)

if
    g != 0
then

partial_h/partial_x_i
    = [
        (partial_f/partial_x_i)*g
        - f*(partial_g/partial_x_i)
      ] / g^2

QUOTIENT_RULE
    -> extends_to(PARTIAL_DIFFERENTIATION)

# ---------- GRADIENT FORM ----------
for scalar fields f,g
    with g != 0:

gradient(f/g)
    = [g*gradient(f) - f*gradient(g)] / g^2

GRADIENT_QUOTIENT_RULE
    -> vector_collection_of(PARTIAL_QUOTIENT_RULES)

# ---------- COMPOSITE NUMERATOR / DENOMINATOR ----------
if
    f = F(u(x))
    AND g = G(v(x))
then

QUOTIENT_RULE
    -> handles(OUTER_QUOTIENT_STRUCTURE)

CHAIN_RULE
    -> handles(COMPOSITE_FACTORS)

COMPOSITE_QUOTIENT
    -> may_require(QUOTIENT_RULE + CHAIN_RULE)

# ---------- LOGARITHMIC DIFFERENTIATION ----------
if
    y = f/g
    AND relevant_sign_or_complex_log_conditions_hold
then

ln(y)
    = ln(f) - ln(g)

differentiate:

y_prime/y
    = f_prime/f - g_prime/g

LOGARITHMIC_DIFFERENTIATION
    -> alternative_method_for(COMPLEX_PRODUCTS_AND_QUOTIENTS)

# ---------- HIGHER DERIVATIVES ----------
HIGHER_DERIVATIVE_OF_QUOTIENT
    -> obtained_by(REPEATED_DIFFERENTIATION)

REPEATED_QUOTIENT_RULE
    -> may_be_used

ALTERNATIVE_REPRESENTATION
    := f * g^(-1)

HIGHER_DERIVATIVES
    -> may_be_simplified_using(PRODUCT_RULE + CHAIN_RULE)

# ---------- RATIONAL FUNCTIONS ----------
RATIONAL_FUNCTION
    := P(x)/Q(x)

Q(x) != 0
    -> quotient_rule_applicable_if(P,Q differentiable)

RATIONAL_FUNCTION_DERIVATIVE
    = [P_prime*Q - P*Q_prime]/Q^2

RATIONAL_FUNCTION
    -> may_have(DOMAIN_EXCLUSIONS_AT_ZEROS_OF_Q)

# ---------- APPLICATIONS ----------
QUOTIENT_RULE
    -> applied_to(RATIONAL_FUNCTIONS)
    -> applied_to(TRIGONOMETRIC_QUOTIENTS)
    -> applied_to(RATE_EXPRESSIONS)
    -> applied_to(NORMALISED_FUNCTIONS)
    -> applied_to(PROBABILITY_DENSITY_TRANSFORMATIONS)
    -> applied_to(MULTIVARIABLE_SCALAR_FIELDS)

# ---------- RELATION GRAPH ----------
QUOTIENT_FUNCTION
    -> differentiated_by(QUOTIENT_RULE)

PRODUCT_RULE
    -> helps_derive(QUOTIENT_RULE)

CHAIN_RULE
    -> differentiates(RECIPROCAL_DENOMINATOR)

DENOMINATOR
    -> constrains(DOMAIN)

RECIPROCAL_RULE
    -> special_case_of(QUOTIENT_RULE)

PARTIAL_DERIVATIVE
    -> supports(MULTIVARIABLE_QUOTIENT_RULE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "quotient rule" ~= "differentiation rule for a ratio of functions",
    "derivative of a quotient" ~= "difference of numerator and denominator derivative contributions divided by denominator squared",
    "reciprocal rule" ~= "special quotient-rule case for 1/g",
    "ratio differentiation" ~= "quotient differentiation",
    "rational function derivative" ~= "quotient-rule derivative when numerator and denominator are polynomials"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    denominator_must_be_nonzero: true,
    numerator_and_denominator_require_relevant_differentiability: true,
    quotient_derivative_is_not_quotient_of_derivatives: true,
    subtraction_order_must_be_preserved: true,
    denominator_is_squared_in_standard_formula: true,
    domain_exclusions_must_be_preserved_after_algebraic_simplification: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    basic_quotient_rule: 0.99,
    product_chain_derivation: 0.99,
    reciprocal_relation: 0.99,
    domain_conditions: 0.99,
    partial_derivative_extension: 0.99,
    rational_function_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(quotient_expression)
    -> identify(numerator)
    -> identify(denominator)
    -> determine(domain)
    -> verify(denominator_nonzero_at_target)
    -> verify(differentiability)
    -> differentiate(numerator)
    -> differentiate(denominator)
    -> construct(f_prime*g - f*g_prime)
    -> divide_by(g^2)
    -> apply(chain_or_product_rules_inside_components_if_required)
    -> preserve(original_domain_exclusions)
    -> simplify(result)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed quotient-rule semantic graph",
    primary_entity: QUOTIENT_RULE,
    preserve: [
        numerator_identity,
        denominator_identity,
        subtraction_order,
        denominator_square,
        domain_exclusions,
        differentiability_conditions
    ],
    infer_through: [
        derivatives,
        quotient_functions,
        product_rule,
        chain_rule,
        reciprocal_rule,
        partial_derivatives,
        rational_functions
    ],
    avoid: [
        dividing_derivatives_directly,
        reversing_numerator_subtraction_order,
        forgetting_denominator_square,
        applying_rule_where_denominator_is_zero,
        losing_domain_exclusions_after_cancellation,
        omitting_chain_rule_inside_composite_terms
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + QUOTIENT_RULE
    + QUOTIENT_FUNCTION
    + RECIPROCAL_RULE
    + DOMAIN
    + GRADIENT_QUOTIENT_RULE
    + RATIONAL_FUNCTION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> QUOTIENT_RULE
    -> QUOTIENT_IDENTIFICATION
    -> NUMERATOR_DENOMINATOR_DECOMPOSITION
    -> DOMAIN_ANALYSIS
    -> DIFFERENTIABILITY_CHECK
    -> COMPONENT_DERIVATIVE_ANALYSIS
    -> QUOTIENT_FORMULA_CONSTRUCTION
    -> NESTED_RULE_ANALYSIS
    -> DOMAIN_PRESERVATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW