Variable Ontology

flow "VariableOntology" v1.0

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

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

# ---------- CORE ENTITY ----------
VARIABLE := {
    type: MathematicalEntity,
    domain: Mathematics,
    purpose: "Represent a quantity, value, element or object that may vary, be unknown, or act as a symbolic placeholder within a mathematical structure."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    VARIABLE,
    VALUE,
    SYMBOL,
    DOMAIN,
    CONSTANT,
    PARAMETER,
    INDEPENDENT_VARIABLE,
    DEPENDENT_VARIABLE,
    BOUND_VARIABLE,
    FREE_VARIABLE,
    RANDOM_VARIABLE,
    STATE_VARIABLE,
    FUNCTION,
    EXPRESSION,
    EQUATION
}

# ---------- BASIC STRUCTURE ----------
VARIABLE
    -> represented_by(SYMBOL)
    -> takes_values_from(DOMAIN)
    -> may_have(CURRENT_VALUE)
    -> may_be_constrained_by(CONDITIONS)
    -> participates_in(EXPRESSION)
    -> participates_in(EQUATION)
    -> participates_in(FUNCTION)

SYMBOL
    -/> necessarily_is(VARIABLE)

VARIABLE
    -/> necessarily_means(UNKNOWN)

# ---------- DOMAIN ----------
DOMAIN
    -> specifies(ALLOWED_VALUES)

VARIABLE x
    -> x in DOMAIN

DOMAIN
    -> may_be(REAL_NUMBERS)
    -> may_be(COMPLEX_NUMBERS)
    -> may_be(INTEGERS)
    -> may_be(NATURAL_NUMBERS)
    -> may_be(BOOLEAN_VALUES)
    -> may_be(VECTOR_SPACE)
    -> may_be(OTHER_MATHEMATICAL_SET)

VARIABLE_VALIDITY
    -> depends_on(DOMAIN_CONSTRAINTS)

# ---------- INDEPENDENT VARIABLE ----------
INDEPENDENT_VARIABLE
    -> provides(INPUT)
    -> may_be_selected_or_varied_independently_within(MODEL_CONSTRAINTS)

FUNCTION
    := mapping(INDEPENDENT_VARIABLE -> DEPENDENT_VARIABLE)

x
    -> commonly_represents(INDEPENDENT_VARIABLE)

# ---------- DEPENDENT VARIABLE ----------
DEPENDENT_VARIABLE
    -> determined_by(FUNCTION_OR_RELATION)
    -> changes_in_response_to(INDEPENDENT_VARIABLES)

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

DEPENDENCE
    -> may_involve(MULTIPLE_VARIABLES)

# ---------- CONSTANT ----------
CONSTANT
    -> has(FIXED_VALUE_WITHIN_GIVEN_CONTEXT)

VARIABLE
    <-> distinguished_from(CONSTANT)

SYMBOL
    -> may_represent(VARIABLE)
    -> may_represent(CONSTANT)

CONTEXT
    -> determines(SYMBOLIC_ROLE)

# ---------- PARAMETER ----------
PARAMETER
    -> controls(FAMILY_OF_OBJECTS_OR_FUNCTIONS)
    -> often_fixed_within(SINGLE_INSTANCE)
    -> may_vary_across(INSTANCES)

if
    y = a*x + b
then
    x -> VARIABLE
    a -> PARAMETER_OR_CONSTANT_WITHIN_CONTEXT
    b -> PARAMETER_OR_CONSTANT_WITHIN_CONTEXT

# ---------- FREE AND BOUND VARIABLES ----------
FREE_VARIABLE
    -> value_not_fixed_by(BINDING_OPERATOR)

BOUND_VARIABLE
    -> governed_by(BINDING_OPERATOR)

BINDING_OPERATOR
    -> may_be(QUANTIFIER)
    -> may_be(SUMMATION)
    -> may_be(INTEGRATION)
    -> may_be(LAMBDA_BINDING)

example:
    integral(f(x), x=a..b)

x
    -> BOUND_VARIABLE_WITHIN_INTEGRAL_EXPRESSION

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

INDEPENDENT_VARIABLE
    -> approaches(LIMIT_POINT)

DEPENDENT_VARIABLE
    -> changes_according_to(FUNCTION)

LIMIT
    -> evaluates(BEHAVIOUR_AS_VARIABLE_APPROACHES_VALUE)

DERIVATIVE
    -> measures(RATE_OF_CHANGE_OF_DEPENDENT_VARIABLE_WITH_RESPECT_TO_INDEPENDENT_VARIABLE)

dy/dx
    -> relates(change_in(y), change_in(x))

INTEGRAL
    -> accumulates_with_respect_to(INTEGRATION_VARIABLE)

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

MULTIVARIABLE_FUNCTION
    -> depends_on(MULTIPLE_INDEPENDENT_VARIABLES)

PARTIAL_DERIVATIVE
    -> differentiates_with_respect_to(ONE_VARIABLE)
    -> holds_other_variables_fixed_under_defined_conditions)

# ---------- RANDOM VARIABLE ----------
RANDOM_VARIABLE
    -> maps(SAMPLE_SPACE, NUMERICAL_VALUE_SPACE)
    -> belongs_to(PROBABILITY_THEORY)

RANDOM_VARIABLE
    -/> simply_means(VARIABLE_WITH_RANDOMLY_CHANGING_SYMBOL)

RANDOM_VARIABLE
    -> has(PROBABILITY_DISTRIBUTION)

# ---------- STATE VARIABLE ----------
STATE_VARIABLE
    -> represents(COMPONENT_OF_SYSTEM_STATE)
    -> used_in(DYNAMICAL_SYSTEMS)
    -> may_change_with(TIME)

STATE_VECTOR
    -> composed_of(STATE_VARIABLES)

# ---------- DUMMY VARIABLE ----------
DUMMY_VARIABLE
    -> local_symbol_used_within(EXPRESSION_OR_OPERATION)
    -> may_be_renamed_without_changing_mathematical_meaning_when_binding_is_preserved)

integral(f(x), x=a..b)
    ~= integral(f(t), t=a..b)
       under_consistent_variable_substitution

# ---------- VARIABLE SUBSTITUTION ----------
SUBSTITUTION
    -> replaces(VARIABLE_OR_EXPRESSION)
    -> preserves(SEMANTIC_AND_ALGEBRAIC_CONSISTENCY_WHEN_VALID)

VARIABLE_TRANSFORMATION
    -> maps(OLD_VARIABLES, NEW_VARIABLES)

CHANGE_OF_VARIABLE
    -> used_in(INTEGRATION)
    -> used_in(DIFFERENTIAL_EQUATIONS)
    -> used_in(COORDINATE_TRANSFORMATIONS)

# ---------- RELATION GRAPH ----------
VARIABLE
    -> takes_value_from(DOMAIN)

VARIABLE
    -> represented_by(SYMBOL)

INDEPENDENT_VARIABLE
    -> influences(DEPENDENT_VARIABLE)
       through(FUNCTION_OR_RELATION)

FUNCTION
    -> maps(INPUT_VARIABLES, OUTPUT_VALUES)

PARAMETER
    -> configures(MATHEMATICAL_MODEL)

BOUND_VARIABLE
    -> scoped_by(BINDING_OPERATOR)

FREE_VARIABLE
    -> remains_available_for(ASSIGNMENT_OR_INTERPRETATION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "independent variable" ~= "input variable in an appropriate functional context",
    "dependent variable" ~= "output quantity determined by a relation or function",
    "dummy variable" ~= "bound local variable whose name may be changed consistently",
    "variable of integration" ~= "bound variable used by an integral",
    "variable domain" ~= "set of admissible values",
    "parameter" ~= "contextually fixed quantity indexing or configuring a family of mathematical objects"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    variable_role_is_context_dependent: true,
    variable_values_must_respect_domain: true,
    independent_does_not_mean_statistically_independent: true,
    bound_and_free_status_depends_on_scope: true,
    parameter_and_variable_distinction_can_be_contextual: true,
    symbol_identity_does_not_guarantee_semantic_role_identity: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    variable_definition: 0.99,
    domain_relations: 0.99,
    dependent_independent_relations: 0.99,
    bound_free_relations: 0.99,
    calculus_relations: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(variable_symbol)
    -> determine(scope)
    -> determine(domain)
    -> classify(role)
    -> identify(binding_status)
    -> identify(functional_dependencies)
    -> resolve(parameters_and_constants)
    -> trace(calculus_relationships)
    -> validate(domain_and_scope_constraints)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed mathematical variable graph",
    primary_entity: VARIABLE,
    preserve: [
        domain,
        scope,
        variable_role,
        dependency_direction,
        binding_structure,
        context
    ],
    infer_through: [
        functions,
        equations,
        limits,
        derivatives,
        integrals,
        substitutions,
        variable_transformations
    ],
    avoid: [
        treating_every_symbol_as_variable,
        treating_every_variable_as_unknown,
        confusing mathematical independence with statistical independence,
        ignoring bound-variable scope,
        assuming parameters are globally constant,
        substituting variables without preserving domain conditions
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + VARIABLE
    + DOMAIN
    + INDEPENDENT_VARIABLE
    + DEPENDENT_VARIABLE
    + PARAMETER
    + BOUND_VARIABLE
    + FREE_VARIABLE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> VARIABLE
    -> SYMBOL_IDENTIFICATION
    -> DOMAIN_ANALYSIS
    -> SCOPE_ANALYSIS
    -> ROLE_CLASSIFICATION
    -> DEPENDENCY_ANALYSIS
    -> BINDING_ANALYSIS
    -> CALCULUS_RELATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW