Function Analysis Ontology

flow "FunctionAnalysisOntology" v1.0

# ============================================================
# FUNCTION ANALYSIS ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/foundations-of-calculus/function-analysis-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Foundations of Calculus"
ENTITY := "Function Analysis"

# ---------- CORE ENTITY ----------
FUNCTION_ANALYSIS := {
    type: MathematicalAnalysisFramework,
    domain: Mathematics,
    purpose: "Represent and analyse functions through their domains, codomains, mappings, limits, continuity, rates of change, extrema, asymptotic behaviour and integrability."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    FUNCTION,
    DOMAIN,
    CODOMAIN,
    RANGE,
    INPUT,
    OUTPUT,
    VARIABLE,
    GRAPH,
    LIMIT,
    CONTINUITY,
    DERIVATIVE,
    INTEGRAL,
    MONOTONICITY,
    EXTREMUM,
    CONVEXITY,
    ASYMPTOTE,
    ZERO,
    SINGULARITY
}

# ---------- FUNCTION STRUCTURE ----------
FUNCTION
    := mapping(DOMAIN -> CODOMAIN)

FUNCTION
    -> assigns(EACH_INPUT, EXACTLY_ONE_OUTPUT)
    -> has(DOMAIN)
    -> has(CODOMAIN)
    -> produces(RANGE)
    -> may_be_represented_by(EXPRESSION)
    -> may_be_represented_by(GRAPH)
    -> may_be_represented_by(TABLE)
    -> may_be_represented_by(ALGORITHM)

RANGE
    -> subset_of(CODOMAIN)

# ---------- VARIABLE RELATIONS ----------
INDEPENDENT_VARIABLE
    -> supplies(INPUT)

DEPENDENT_VARIABLE
    -> represents(OUTPUT)

OUTPUT
    := FUNCTION(INPUT)

FUNCTION_ANALYSIS
    -> examines(INPUT_OUTPUT_RELATIONSHIP)
    -> examines(LOCAL_BEHAVIOUR)
    -> examines(GLOBAL_BEHAVIOUR)

# ---------- DOMAIN ANALYSIS ----------
DOMAIN_ANALYSIS
    -> identify(ALLOWED_INPUTS)
    -> detect(EXCLUDED_VALUES)
    -> detect(BOUNDARIES)
    -> detect(INTERVALS)

DOMAIN_RESTRICTION
    -> may_result_from(DIVISION_BY_ZERO)
    -> may_result_from(EVEN_ROOT_CONSTRAINTS_OVER_REALS)
    -> may_result_from(LOGARITHM_ARGUMENT_CONSTRAINTS)
    -> may_result_from(MODEL_SPECIFIC_CONDITIONS)

# ---------- INTERCEPTS AND ZEROS ----------
ZERO_OF_FUNCTION
    iff
    f(x) = 0

ZERO_OF_FUNCTION
    -> corresponds_to(X_INTERCEPT)
       when graph uses y = f(x)

Y_INTERCEPT
    -> occurs_at(x = 0)
       if 0 in DOMAIN

ROOT_ANALYSIS
    -> identify(SOLUTIONS_OF_f(x)=0)

# ---------- LIMIT ANALYSIS ----------
LIMIT
    -> describes(BEHAVIOUR_NEAR_POINT)
    -> describes(BEHAVIOUR_AT_INFINITY)
    -> supports(CONTINUITY_ANALYSIS)
    -> supports(DERIVATIVE_ANALYSIS)

limit(f(x), x -> a) = L

iff

forall epsilon > 0
    exists delta > 0
        such_that
        0 < abs(x-a) < delta
        -> abs(f(x)-L) < epsilon

ONE_SIDED_LIMIT
    -> may_be(LEFT_HAND_LIMIT)
    -> may_be(RIGHT_HAND_LIMIT)

# ---------- CONTINUITY ----------
continuous(f, a)
    iff
    defined(f(a))
    AND limit(f(x), x -> a) exists
    AND limit(f(x), x -> a) = f(a)

DISCONTINUITY
    -> may_be(REMOVABLE)
    -> may_be(JUMP)
    -> may_be(INFINITE)
    -> may_have(OTHER_CONTEXT_DEPENDENT_CLASSIFICATION)

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

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

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

DERIVATIVE
    -> measures(INSTANTANEOUS_RATE_OF_CHANGE)
    -> determines(LOCAL_SLOPE)

f_prime(x) > 0
    -> indicates(LOCALLY_INCREASING_BEHAVIOUR)

f_prime(x) < 0
    -> indicates(LOCALLY_DECREASING_BEHAVIOUR)

f_prime(x) = 0
    -> identifies(CRITICAL_POINT_CANDIDATE)

CRITICAL_POINT
    -> may_correspond_to(LOCAL_MAXIMUM)
    -> may_correspond_to(LOCAL_MINIMUM)
    -> may_correspond_to(OTHER_STATIONARY_BEHAVIOUR)

# ---------- SECOND DERIVATIVE ----------
SECOND_DERIVATIVE
    -> measures(CHANGE_OF_SLOPE)
    -> supports(CONCAVITY_ANALYSIS)

f_double_prime(x) > 0
    -> indicates(CONCAVE_UP_LOCAL_BEHAVIOUR)

f_double_prime(x) < 0
    -> indicates(CONCAVE_DOWN_LOCAL_BEHAVIOUR)

INFLECTION_POINT
    -> requires(CHANGE_IN_CONCAVITY)

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

# ---------- MONOTONICITY ----------
MONOTONICITY
    -> describes(ORDERED_CHANGE_OVER_INTERVAL)

FUNCTION
    -> may_be(INCREASING)
    -> may_be(DECREASING)
    -> may_be(CONSTANT)
    -> may_be(NONDECREASING)
    -> may_be(NONINCREASING)

DERIVATIVE_SIGN
    -> supports(MONOTONICITY_CLASSIFICATION)

# ---------- EXTREMA ----------
EXTREMUM
    -> may_be(LOCAL_MAXIMUM)
    -> may_be(LOCAL_MINIMUM)
    -> may_be(GLOBAL_MAXIMUM)
    -> may_be(GLOBAL_MINIMUM)

EXTREMA_ANALYSIS
    -> uses(CRITICAL_POINTS)
    -> uses(ENDPOINTS)
    -> uses(DERIVATIVE_SIGN)
    -> may_use(SECOND_DERIVATIVE_TEST)

# ---------- CONVEXITY ----------
CONVEXITY
    -> describes(SHAPE_RELATIVE_TO_CHORDS)

for differentiable contexts:
    SECOND_DERIVATIVE
        -> may_support(CONVEXITY_OR_CONCAVITY_ANALYSIS)

CONVEX_FUNCTION
    -> important_in(OPTIMISATION)

# ---------- ASYMPTOTIC BEHAVIOUR ----------
ASYMPTOTIC_ANALYSIS
    -> studies(BEHAVIOUR_NEAR_BOUNDARIES)
    -> studies(BEHAVIOUR_AS_x_TO_INFINITY)
    -> studies(BEHAVIOUR_AS_x_TO_NEGATIVE_INFINITY)

VERTICAL_ASYMPTOTE
    -> associated_with(UNBOUNDED_FUNCTION_BEHAVIOUR_NEAR_FINITE_INPUT)

HORIZONTAL_ASYMPTOTE
    -> associated_with(FINITE_LIMIT_AT_POSITIVE_OR_NEGATIVE_INFINITY)

OBLIQUE_ASYMPTOTE
    -> associated_with(LINEAR_ASYMPTOTIC_BEHAVIOUR)

# ---------- INTEGRAL ANALYSIS ----------
DEFINITE_INTEGRAL
    -> measures(SIGNED_ACCUMULATION)
    -> may_represent(SIGNED_AREA)

INTEGRABILITY
    -> property_of(FUNCTION_ON_DOMAIN)

FUNCTION_ANALYSIS
    -> may_evaluate(INTEGRABILITY)
    -> may_evaluate(ANTIDERIVATIVES)
    -> may_evaluate(ACCUMULATED_CHANGE)

# ---------- FUNCTION CLASSIFICATION ----------
FUNCTION
    -> may_be(POLYNOMIAL)
    -> may_be(RATIONAL)
    -> may_be(EXPONENTIAL)
    -> may_be(LOGARITHMIC)
    -> may_be(TRIGONOMETRIC)
    -> may_be(PIECEWISE)
    -> may_be(ABSOLUTE_VALUE)
    -> may_be(COMPOSITE)
    -> may_be(INVERSE_WHEN_CONDITIONS_HOLD)

INJECTIVE_FUNCTION
    -> distinct_inputs_have_distinct_outputs

SURJECTIVE_FUNCTION
    -> range_equals(CODOMAIN)

BIJECTIVE_FUNCTION
    -> is(INJECTIVE)
    -> is(SURJECTIVE)
    -> has(INVERSE_FUNCTION)

# ---------- COMPOSITION ----------
COMPOSITION(f, g)
    := f(g(x))

COMPOSITION
    -> requires(RANGE_OF_g_COMPATIBLE_WITH_DOMAIN_OF_f)

CHAIN_RULE
    -> governs(DERIVATIVE_OF_COMPOSITION)

# ---------- FUNCTION TRANSFORMATIONS ----------
FUNCTION_TRANSFORMATION
    -> may_include(TRANSLATION)
    -> may_include(SCALING)
    -> may_include(REFLECTION)

TRANSFORMATION
    -> modifies(GRAPH)
    -> preserves_or_changes(PROPERTIES_DEPENDING_ON_OPERATION)

# ---------- SEMANTIC RELATION GRAPH ----------
DOMAIN
    -> constrains(INPUT)

FUNCTION
    -> maps(INPUT, OUTPUT)

LIMIT
    -> reveals(LOCAL_OR_ASYMPTOTIC_BEHAVIOUR)

CONTINUITY
    -> characterises(LIMIT_VALUE_ALIGNMENT)

DERIVATIVE
    -> reveals(LOCAL_CHANGE)

SECOND_DERIVATIVE
    -> reveals(CURVATURE_BEHAVIOUR)

INTEGRAL
    -> reveals(ACCUMULATION)

FUNCTION_ANALYSIS
    -> synthesises(
        DOMAIN_ANALYSIS,
        RANGE_ANALYSIS,
        LIMIT_ANALYSIS,
        CONTINUITY_ANALYSIS,
        DERIVATIVE_ANALYSIS,
        EXTREMA_ANALYSIS,
        ASYMPTOTIC_ANALYSIS,
        INTEGRAL_ANALYSIS
    )

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "root of a function" ~= "zero of a function",
    "function value" ~= "output for a specified input",
    "instantaneous slope" ~= "derivative at a point",
    "turning behaviour" ~= "local extrema behaviour when mathematically applicable",
    "end behaviour" ~= "asymptotic behaviour",
    "increasing interval" ~= "interval over which function values increase according to the chosen monotonicity definition"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    each_input_has_exactly_one_output: true,
    range_is_subset_of_codomain: 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,
    inverse_requires_appropriate_bijective_or_restricted_domain_conditions: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    function_structure: 0.99,
    domain_range_relations: 0.99,
    limit_continuity_relations: 0.99,
    derivative_relations: 0.99,
    extrema_relations: 0.98,
    asymptotic_relations: 0.98,
    semantic_equivalence: 0.96
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function)
    -> determine(domain)
    -> determine(codomain_and_range_context)
    -> classify(function_type)
    -> locate(zeros_and_intercepts)
    -> analyse(limits)
    -> test(continuity)
    -> analyse(first_derivative)
    -> analyse(second_derivative)
    -> determine(monotonicity)
    -> determine(extrema)
    -> analyse(asymptotic_behaviour)
    -> evaluate(integrability_if_required)
    -> validate(mathematical_consistency)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed mathematical function-analysis graph",
    primary_entity: FUNCTION_ANALYSIS,
    preserve: [
        domain_constraints,
        mapping_structure,
        limit_conditions,
        implication_direction,
        derivative_sign_logic,
        extrema_conditions,
        asymptotic_conditions
    ],
    infer_through: [
        domain,
        range,
        limits,
        continuity,
        derivatives,
        monotonicity,
        extrema,
        concavity,
        integrals
    ],
    avoid: [
        confusing_range_with_codomain,
        assuming_continuity_implies_differentiability,
        treating_every_stationary_point_as_extremum,
        treating_second_derivative_zero_as_automatic_inflection,
        assuming_inverse_exists_without required conditions
    ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
    validate(new_information)
    -> classify(function_property)
    -> compare(existing_relations)
    -> preserve(mathematical_invariants)
    -> update(affected_entities)
    -> update(affected_edges)
    -> recompute(CONFIDENCE)
    -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + FUNCTION
    + DOMAIN_ANALYSIS
    + LIMIT
    + CONTINUITY
    + DERIVATIVE
    + EXTREMUM
    + ASYMPTOTIC_ANALYSIS
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> FUNCTION_ANALYSIS
    -> FUNCTION_IDENTIFICATION
    -> DOMAIN_RANGE_ANALYSIS
    -> LIMIT_ANALYSIS
    -> CONTINUITY_ANALYSIS
    -> DERIVATIVE_ANALYSIS
    -> MONOTONICITY_ANALYSIS
    -> EXTREMA_ANALYSIS
    -> CONCAVITY_ANALYSIS
    -> ASYMPTOTIC_ANALYSIS
    -> INTEGRAL_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW