Independent Variable Ontology

flow "IndependentVariableOntology" v1.0

# ============================================================
# INDEPENDENT VARIABLE ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
INDEPENDENT_VARIABLE := {
    type: MathematicalVariable,
    domain: Mathematics,
    purpose: "Represent an input quantity whose admissible value is selected or varied within a mathematical model and upon which one or more dependent quantities may depend."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    INDEPENDENT_VARIABLE,
    DEPENDENT_VARIABLE,
    VARIABLE,
    INPUT,
    OUTPUT,
    DOMAIN,
    FUNCTION,
    RELATION,
    PARAMETER,
    CONSTANT,
    LIMIT,
    DERIVATIVE,
    PARTIAL_DERIVATIVE,
    COORDINATE,
    TIME_VARIABLE
}

# ---------- BASIC STRUCTURE ----------
INDEPENDENT_VARIABLE
    -> subtype_of(VARIABLE)
    -> commonly_represents(INPUT)
    -> takes_values_from(DOMAIN)
    -> may_determine(DEPENDENT_VARIABLE)
       through(FUNCTION_OR_RELATION)

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

INDEPENDENT_VARIABLE
    -/> means(VALUE_WITHOUT_ANY_CONSTRAINT)

INDEPENDENT_VARIABLE
    -> constrained_by(DOMAIN)
    -> may_be_constrained_by(MODEL_CONDITIONS)

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

INPUT
    -> supplied_by(INDEPENDENT_VARIABLE)

OUTPUT
    -> generated_by(FUNCTION)

DEPENDENT_VARIABLE
    -> represents(OUTPUT_OR_RESPONSE)

x in DOMAIN
    -> f(x) in CODOMAIN

# ---------- DOMAIN ----------
DOMAIN
    -> specifies(ALLOWED_INPUT_VALUES)

INDEPENDENT_VARIABLE
    -> must_respect(DOMAIN)

DOMAIN
    -> may_be(INTERVAL)
    -> may_be(REAL_NUMBERS)
    -> may_be(INTEGERS)
    -> may_be(VECTOR_SPACE)
    -> may_be(OTHER_SET)

# ---------- CALCULUS ROLE ----------
CALCULUS
    -> studies(DEPENDENT_CHANGE_WITH_RESPECT_TO_INDEPENDENT_VARIABLE)

LIMIT
    -> may_take_form(x -> a)

limit(f(x), x -> a)
    -> analyses(FUNCTION_BEHAVIOUR)
       as(INDEPENDENT_VARIABLE_APPROACHES_VALUE)

DERIVATIVE
    := rate_of_change(
        DEPENDENT_VARIABLE,
        with_respect_to(INDEPENDENT_VARIABLE)
    )

dy/dx
    -> y classified_as(DEPENDENT_VARIABLE)
    -> x classified_as(INDEPENDENT_VARIABLE)
       within_standard_functional_context

# ---------- DIFFERENCE QUOTIENT ----------
AVERAGE_RATE_OF_CHANGE
    := (f(x2)-f(x1))/(x2-x1)

DIFFERENCE_QUOTIENT
    := (f(x+h)-f(x))/h

h -> 0
    -> DIFFERENCE_QUOTIENT
    -> DERIVATIVE
       when_limit_exists

INDEPENDENT_VARIABLE
    -> supplies(REFERENCE_AXIS_FOR_CHANGE)

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

x1, x2, ..., xn
    -> may_each_be(INDEPENDENT_VARIABLE)

DEPENDENT_VARIABLE
    := f(x1, x2, ..., xn)

PARTIAL_DERIVATIVE
    -> measures(CHANGE_WITH_RESPECT_TO_ONE_INDEPENDENT_VARIABLE)
    -> holds(OTHER_INDEPENDENT_VARIABLES_FIXED)
       under_defined_conditions

# ---------- COORDINATES ----------
COORDINATE_VARIABLE
    -> may_function_as(INDEPENDENT_VARIABLE)

examples:
    x -> spatial_coordinate
    y -> spatial_coordinate
    z -> spatial_coordinate
    t -> time_coordinate

INDEPENDENT_VARIABLE
    -> role_determined_by(MATHEMATICAL_CONTEXT)

# ---------- TIME ----------
TIME_VARIABLE
    -> commonly_used_as(INDEPENDENT_VARIABLE)
       in(DYNAMICAL_SYSTEMS)

STATE_VARIABLE
    -> may_depend_on(TIME_VARIABLE)

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

# ---------- PARAMETER DISTINCTION ----------
PARAMETER
    -> configures(MODEL_OR_FUNCTION_FAMILY)
    -> often_held_fixed_during(SINGLE_ANALYSIS)

INDEPENDENT_VARIABLE
    -> actively_varied_over(DOMAIN)

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

ROLE
    -> depends_on(CONTEXT)

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

MATHEMATICAL_INDEPENDENT_VARIABLE
    -/> automatically_equivalent_to(CAUSAL_EXPERIMENTAL_FACTOR)

MATHEMATICAL_DEPENDENCE
    -/> establishes(CAUSATION)

# ---------- STATISTICAL DISTINCTION ----------
INDEPENDENT_VARIABLE
    -/> means(STATISTICALLY_INDEPENDENT_RANDOM_VARIABLE)

STATISTICAL_INDEPENDENCE
    -> separate_concept_from(FUNCTIONAL_INPUT_ROLE)

# ---------- TRANSFORMATIONS ----------
CHANGE_OF_VARIABLE
    -> may_replace(OLD_INDEPENDENT_VARIABLE, NEW_INDEPENDENT_VARIABLE)

SUBSTITUTION
    -> must_preserve(DOMAIN_AND_RELATION_CONDITIONS)

COORDINATE_TRANSFORMATION
    -> maps(INDEPENDENT_VARIABLE_SET, NEW_COORDINATE_SET)

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

DOMAIN
    -> constrains(INDEPENDENT_VARIABLE)

FUNCTION
    -> maps(INDEPENDENT_VARIABLE, OUTPUT)

DEPENDENT_VARIABLE
    -> depends_on(INDEPENDENT_VARIABLE)
       under(FUNCTION_OR_RELATION)

LIMIT
    -> tracks(INDEPENDENT_VARIABLE_APPROACH)

DERIVATIVE
    -> measures(DEPENDENT_CHANGE_RELATIVE_TO_INDEPENDENT_CHANGE)

PARTIAL_DERIVATIVE
    -> isolates(ONE_INDEPENDENT_DIRECTION_OF_CHANGE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "independent variable" ~= "input variable in an appropriate mathematical context",
    "input variable" ~= "variable supplying arguments to a function",
    "variable of differentiation" ~= "independent variable with respect to which differentiation is performed in the specified context",
    "x-axis variable" ~= "independent variable only under conventional graphing context",
    "time variable" ~= "independent variable in many dynamical models"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    role_is_context_dependent: true,
    values_must_respect_domain: true,
    independent_does_not_mean_unconstrained: true,
    independent_does_not_mean_statistically_independent: true,
    mathematical_dependence_does_not_prove_causation: true,
    multiple_independent_variables_are_allowed: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    function_relations: 0.99,
    calculus_relations: 0.99,
    multivariable_relations: 0.99,
    parameter_distinction: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(variable)
    -> determine(context)
    -> determine(domain)
    -> determine(function_or_relation)
    -> classify(input_output_role)
    -> identify(dependent_variables)
    -> identify(parameters)
    -> analyse(limit_or_derivative_role)
    -> validate(domain_constraints)
    -> distinguish_from(statistical_independence)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed mathematical variable graph",
    primary_entity: INDEPENDENT_VARIABLE,
    preserve: [
        domain,
        functional_role,
        dependency_direction,
        differentiation_context,
        parameter_distinction,
        semantic_scope
    ],
    infer_through: [
        functions,
        limits,
        derivatives,
        partial_derivatives,
        coordinate_systems,
        dynamical_systems
    ],
    avoid: [
        treating_independent_as_unconstrained,
        confusing_input_role_with_statistical_independence,
        inferring_causation_from_functional_dependence,
        assuming_x_is_always_independent,
        ignoring_multivariable_context
    ]
}

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

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

# ---------- EXECUTION ----------
INPUT(query)
    -> INDEPENDENT_VARIABLE
    -> CONTEXT_IDENTIFICATION
    -> DOMAIN_ANALYSIS
    -> FUNCTION_RELATION_ANALYSIS
    -> INPUT_OUTPUT_CLASSIFICATION
    -> CALCULUS_ROLE_ANALYSIS
    -> MULTIVARIABLE_ANALYSIS
    -> PARAMETER_DISTINCTION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW