Dependent Variable Ontology

flow "DependentVariableOntology" v1.0

# ============================================================
# DEPENDENT VARIABLE ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
DEPENDENT_VARIABLE := {
    type: MathematicalVariable,
    domain: Mathematics,
    purpose: "Represent an output or response quantity whose value is determined by one or more independent variables through a function, relation, equation or mathematical model."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    DEPENDENT_VARIABLE,
    INDEPENDENT_VARIABLE,
    VARIABLE,
    INPUT,
    OUTPUT,
    DOMAIN,
    CODOMAIN,
    RANGE,
    FUNCTION,
    RELATION,
    EQUATION,
    DERIVATIVE,
    PARTIAL_DERIVATIVE,
    DIFFERENTIAL_EQUATION,
    STATE_VARIABLE
}

# ---------- BASIC STRUCTURE ----------
DEPENDENT_VARIABLE
    -> subtype_of(VARIABLE)
    -> commonly_represents(OUTPUT)
    -> determined_by(FUNCTION_OR_RELATION)
    -> may_depend_on(ONE_OR_MORE_INDEPENDENT_VARIABLES)

if
    y = f(x)
then
    x -> INDEPENDENT_VARIABLE
    y -> DEPENDENT_VARIABLE

DEPENDENT_VARIABLE
    -> takes_values_from(CODOMAIN_OR_OUTPUT_SPACE)

ACTUAL_OUTPUT_VALUES
    -> form(RANGE)

# ---------- FUNCTIONAL DEPENDENCE ----------
FUNCTION
    := mapping(DOMAIN -> CODOMAIN)

INDEPENDENT_VARIABLE
    -> supplies(INPUT)

FUNCTION
    -> transforms(INPUT, OUTPUT)

DEPENDENT_VARIABLE
    -> represents(OUTPUT)

y = f(x)
    -> value_of(y) determined_by(value_of(x), f)

# ---------- MULTIVARIABLE DEPENDENCE ----------
MULTIVARIABLE_FUNCTION
    := f(x1, x2, ..., xn)

y = f(x1, x2, ..., xn)

x1, x2, ..., xn
    -> may_be(INDEPENDENT_VARIABLES)

y
    -> DEPENDENT_VARIABLE

DEPENDENT_VARIABLE
    -> may_depend_on(MULTIPLE_INPUTS)

# ---------- CALCULUS ROLE ----------
CALCULUS
    -> analyses(CHANGE_OF_DEPENDENT_VARIABLE)

DERIVATIVE
    -> measures(RATE_OF_CHANGE_OF_DEPENDENT_VARIABLE)
       with_respect_to(INDEPENDENT_VARIABLE)

dy/dx
    -> numerator_represents(DIFFERENTIAL_CHANGE_IN_DEPENDENT_VARIABLE)
    -> denominator_represents(DIFFERENTIAL_CHANGE_IN_INDEPENDENT_VARIABLE)

DERIVATIVE_OF_FUNCTION
    -> describes(LOCAL_RESPONSE_OF_DEPENDENT_VARIABLE)

# ---------- PARTIAL DERIVATIVES ----------
PARTIAL_DERIVATIVE
    -> measures(DEPENDENT_VARIABLE_CHANGE)
       with_respect_to(ONE_INDEPENDENT_VARIABLE)

OTHER_INDEPENDENT_VARIABLES
    -> held_fixed(UNDER_PARTIAL_DIFFERENTIATION_CONTEXT)

partial(y)/partial(x_i)
    -> local_sensitivity_of(y, x_i)

# ---------- DIFFERENTIAL EQUATIONS ----------
DIFFERENTIAL_EQUATION
    -> relates(DEPENDENT_VARIABLE, DERIVATIVES)

DEPENDENT_VARIABLE
    -> may_be(UNKNOWN_FUNCTION_TO_BE_SOLVED)

example:
    dy/dx = F(x, y)

x
    -> INDEPENDENT_VARIABLE

y
    -> DEPENDENT_VARIABLE

dy/dx
    -> RATE_OF_CHANGE_OF_DEPENDENT_VARIABLE

# ---------- STATE VARIABLES ----------
STATE_VARIABLE
    -> may_function_as(DEPENDENT_VARIABLE)
       in(DYNAMICAL_SYSTEM)

x(t)
    -> t classified_as(INDEPENDENT_VARIABLE)
    -> x classified_as(DEPENDENT_STATE_VARIABLE)

STATE_VECTOR
    -> contains(MULTIPLE_DEPENDENT_STATE_VARIABLES)

# ---------- EXPLICIT AND IMPLICIT RELATIONS ----------
EXPLICIT_FUNCTION
    -> may_express(DEPENDENT_VARIABLE_DIRECTLY)

y = f(x)
    -> explicit_dependence(y, x)

IMPLICIT_RELATION
    := F(x, y) = 0

IMPLICIT_RELATION
    -> may_define(y_as_function_of_x_locally)
       when(REQUIRED_CONDITIONS_HOLD)

DEPENDENT_ROLE
    -> may_be_assigned_by(CONTEXT)

# ---------- GRAPHICAL REPRESENTATION ----------
GRAPH_OF_FUNCTION
    -> represents(ORDERED_PAIRS)

(x, y)
    where
    y = f(x)

x
    -> commonly_plotted_on(HORIZONTAL_AXIS)

y
    -> commonly_plotted_on(VERTICAL_AXIS)

AXIS_CONVENTION
    -/> defines_variable_role_in_all_contexts

# ---------- RANGE ----------
RANGE
    -> set_of(ACTUAL_DEPENDENT_VARIABLE_VALUES)

RANGE
    -> subset_of(CODOMAIN)

DEPENDENT_VARIABLE
    -> constrained_by(FUNCTION)
    -> constrained_by(INPUT_DOMAIN)
    -> constrained_by(MODEL_CONDITIONS)

# ---------- PARAMETER DISTINCTION ----------
PARAMETER
    -> configures(FUNCTION_OR_MODEL)

DEPENDENT_VARIABLE
    -> changes_as(INPUT_CHANGES)

if
    y = a*x + b
then
    y -> DEPENDENT_VARIABLE
    x -> INDEPENDENT_VARIABLE
    a -> PARAMETER_OR_CONSTANT_IN_CONTEXT
    b -> PARAMETER_OR_CONSTANT_IN_CONTEXT

# ---------- EXPERIMENTAL TERMINOLOGY ----------
DEPENDENT_VARIABLE
    -> may_have_related_meaning_in(EXPERIMENTAL_DESIGN)

MATHEMATICAL_DEPENDENT_VARIABLE
    -/> automatically_equivalent_to(MEASURED_EXPERIMENTAL_RESPONSE)

FUNCTIONAL_DEPENDENCE
    -/> establishes(CAUSATION)

# ---------- COMPOSITION ----------
if
    y = f(u)
    AND u = g(x)
then
    y = f(g(x))

y
    -> depends_on(u)
    -> indirectly_depends_on(x)

CHAIN_RULE
    -> propagates(RATE_OF_CHANGE_THROUGH_DEPENDENCY_CHAIN)

dy/dx
    = (dy/du) * (du/dx)
       when_required_conditions_hold

# ---------- RELATION GRAPH ----------
INDEPENDENT_VARIABLE
    -> supplies(INPUT)

FUNCTION
    -> maps(INPUT, OUTPUT)

DEPENDENT_VARIABLE
    -> represents(OUTPUT)

DEPENDENT_VARIABLE
    -> constrained_by(RANGE)

DERIVATIVE
    -> measures(DEPENDENT_CHANGE)

PARTIAL_DERIVATIVE
    -> measures(PARTIAL_DEPENDENT_RESPONSE)

DIFFERENTIAL_EQUATION
    -> constrains(DEPENDENT_VARIABLE_EVOLUTION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "dependent variable" ~= "output variable in an appropriate functional context",
    "response variable" ~= "dependent variable in many modelling contexts",
    "function value" ~= "value taken by the dependent output for a specified input",
    "y-variable" ~= "dependent variable only under conventional context",
    "state variable" ~= "dependent variable when its evolution is determined relative to an independent variable such as time"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    role_is_context_dependent: true,
    dependent_variable_may_depend_on_multiple_inputs: true,
    range_is_subset_of_codomain: true,
    functional_dependence_does_not_prove_causation: true,
    y_is_not_always_dependent: true,
    implicit_dependence_requires_appropriate_conditions_for_local_function_representation: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    functional_dependence: 0.99,
    calculus_relations: 0.99,
    multivariable_relations: 0.99,
    differential_equation_relations: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(variable)
    -> determine(context)
    -> identify(function_or_relation)
    -> identify(independent_variables)
    -> determine(output_space)
    -> determine(range_constraints)
    -> analyse(dependency_chain)
    -> analyse(derivative_role)
    -> analyse(multivariable_dependence)
    -> validate(functional_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed mathematical dependency graph",
    primary_entity: DEPENDENT_VARIABLE,
    preserve: [
        dependency_direction,
        input_output_structure,
        range_constraints,
        differentiation_context,
        multivariable_dependencies,
        semantic_scope
    ],
    infer_through: [
        functions,
        relations,
        derivatives,
        partial_derivatives,
        differential_equations,
        composition,
        state systems
    ],
    avoid: [
        inferring_causation_from_functional_dependence,
        assuming_y_is_always_dependent,
        confusing_range_with_codomain,
        ignoring_indirect_dependencies,
        treating_implicit_relations_as_global_functions_without conditions
    ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
    validate(new_information)
    -> determine(dependency_context)
    -> compare(existing_relations)
    -> preserve(function_and_domain_invariants)
    -> update(affected_entities)
    -> update(affected_edges)
    -> recompute(CONFIDENCE)
    -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + DEPENDENT_VARIABLE
    + INDEPENDENT_VARIABLE
    + FUNCTION
    + RANGE
    + DERIVATIVE
    + PARTIAL_DERIVATIVE
    + DIFFERENTIAL_EQUATION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> DEPENDENT_VARIABLE
    -> CONTEXT_IDENTIFICATION
    -> FUNCTION_RELATION_ANALYSIS
    -> INPUT_OUTPUT_CLASSIFICATION
    -> RANGE_ANALYSIS
    -> DEPENDENCY_CHAIN_ANALYSIS
    -> CALCULUS_ROLE_ANALYSIS
    -> MULTIVARIABLE_ANALYSIS
    -> DIFFERENTIAL_EQUATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW