Linear Function Ontology

FLOW Linear_Function_Ontology_v1.0

PAGE:
  title: "Linear Function Ontology"
  canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/linear-function-ontology.html"
  language: "en-GB"
  domain: "Mathematics > Algebra > Functions > Linear Functions"

DEFINE LinearFunctionOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: LinearFunction,
    parent_entities: [Function, AlgebraicFunction, PolynomialFunction],
    related_entities: [
      Variable,
      IndependentVariable,
      DependentVariable,
      Coefficient,
      Constant,
      Slope,
      Gradient,
      Intercept,
      RateOfChange,
      StraightLine,
      LinearEquation,
      AffineFunction,
      ProportionalFunction,
      Coordinate,
      Domain,
      Range
    ]
  },

  DEFINITION: {
    meaning:
      "A one-variable real function whose graph is a straight line and whose rate of change is constant.",
    common_school_form:
      f(x)=m*x+b,
    slope:
      m,
    vertical_intercept:
      b
  },

  TERMINOLOGY_PRECISION: {
    strict_linear_algebra_definition:
      f(x)=m*x
      AND f(0)=0,

    elementary_algebra_usage:
      "linear function" commonly includes affine functions f(x)=m*x+b,

    ontology_policy:
      represent_both_usages_explicitly_to_avoid_semantic_ambiguity
  },

  CLASSIFICATION: {

    AffineLinearFunction: {
      form:
        f(x)=m*x+b
    },

    StrictLinearFunction: {
      form:
        f(x)=m*x,
      intercept:
        0
    },

    ConstantFunction: {
      form:
        f(x)=b,
      slope:
        0,
      degree:
        0,
      inclusion_note:
        graph_is_a_straight_line_but_polynomial_degree_is_zero
    },

    ProportionalFunction: {
      form:
        f(x)=m*x,
      relation:
        output_is_directly_proportional_to_input
    }
  },

  SEMANTIC_PRIMITIVES: {
    Slope:
      constant_change_in_output_per_unit_change_in_input,

    Gradient:
      synonym_of_slope_in_common_UK_usage,

    Intercept:
      coordinate_where_line_meets_axis,

    RateOfChange:
      Delta_y/Delta_x,

    StraightLine:
      graph_with_constant_slope,

    IndependentVariable:
      input_x,

    DependentVariable:
      output_y_or_f(x)
  },

  FUNCTION_MODEL: {
    mapping:
      f: Domain -> Codomain,

    rule:
      x -> m*x+b,

    single_valuedness:
      TRUE,

    standard_real_domain:
      RealNumbers,

    standard_real_codomain:
      RealNumbers
  },

  COEFFICIENT_MODEL: {
    m:
      slope_or_gradient,

    b:
      y_intercept,

    x:
      independent_variable,

    f(x):
      dependent_value
  },

  SLOPE_SEMANTICS: {
    formula_between_two_points:
      m=(y_2-y_1)/(x_2-x_1),

    condition:
      x_2 != x_1,

    interpretation:
      output_change_per_unit_input_change
  },

  CONSTANT_RATE_OF_CHANGE: {
    FOR_ANY x_1,x_2 IN Domain
    WITH x_1 != x_2:

      (f(x_2)-f(x_1))/(x_2-x_1)=m
  },

  FIRST_DIFFERENCE_MODEL: {
    equal_input_step:
      Delta_x=k,

    output_difference:
      Delta_y=m*k,

    unit_input_step:
      Delta_x=1 -> Delta_y=m
  },

  GRAPH_SEMANTICS: {
    equation:
      y=m*x+b,

    graph_entity:
      StraightLine,

    slope:
      m,

    y_intercept:
      (0,b),

    x_intercept:
      (-b/m,0)
      WHERE m != 0
  },

  ORIENTATION_CLASSIFICATION: {
    m>0:
      increasing_line,

    m<0:
      decreasing_line,

    m=0:
      horizontal_line
  },

  VERTICAL_LINE_EXCLUSION: {
    relation:
      x=c,

    classification:
      vertical_line,

    function_of_x:
      FALSE,

    reason:
      one_x_value_corresponds_to_multiple_y_values
  },

  DOMAIN_RANGE: {
    nonconstant_real_linear_function: {
      Domain:
        RealNumbers,
      Range:
        RealNumbers
    },

    constant_function: {
      Domain:
        commonly_RealNumbers,
      Range:
        {b}
    },

    restricted_domain:
      range_must_be_recomputed_from_domain_and_rule
  },

  ROOT_ZERO_X_INTERCEPT: {
    solve:
      f(x)=0,

    equation:
      m*x+b=0,

    IF m != 0:
      root:
        x=-b/m,

    IF m=0 AND b!=0:
      no_zero,

    IF m=0 AND b=0:
      every_domain_value_is_zero
  },

  Y_INTERCEPT: {
    method:
      evaluate_f(0),

    result:
      f(0)=b
  },

  POINT_SLOPE_FORM: {
    form:
      y-y_1=m*(x-x_1),

    requirements:
      known_point_(x_1,y_1)
      AND known_slope_m,

    conversion:
      expand_and_rearrange_to_y=m*x+b
  },

  TWO_POINT_CONSTRUCTION: {
    INPUT:
      P_1=(x_1,y_1),
      P_2=(x_2,y_2),

    condition:
      x_1 != x_2,

    slope:
      m=(y_2-y_1)/(x_2-x_1),

    intercept:
      b=y_1-m*x_1,

    OUTPUT:
      f(x)=m*x+b
  },

  SLOPE_INTERCEPT_FORM: {
    form:
      y=m*x+b,

    semantic_advantages: [
      slope_explicit,
      y_intercept_explicit
    ]
  },

  STANDARD_LINE_FORM_RELATION: {
    equation:
      A*x+B*y=C,

    IF B != 0:
      function_form:
        y=(-A/B)*x+(C/B),

    slope:
      -A/B,

    intercept:
      C/B
  },

  LINEAR_EQUATION_RELATION: {
    function_statement:
      y=m*x+b,

    equation_statement:
      y-m*x-b=0,

    semantic_relation:
      graph_of_linear_function_equals_solution_set_of_corresponding_two_variable_linear_equation
  },

  POLYNOMIAL_RELATION: {
    nonconstant_affine_expression:
      m*x+b,

    polynomial_degree:
      1 WHERE m != 0,

    constant_case:
      degree=0 WHERE m=0
  },

  DIRECT_PROPORTION: {
    form:
      y=k*x,

    constant_of_proportionality:
      k,

    required_property:
      passes_through_origin,

    ratio_property:
      y/x=k
      WHERE x != 0
  },

  TRANSLATION_FROM_PROPORTIONAL: {
    base:
      y=m*x,

    vertical_translation:
      y=m*x+b,

    result:
      affine_line
  },

  PARALLEL_LINES: {
    condition:
      m_1=m_2,

    distinct_parallel_lines:
      b_1 != b_2,

    coincident_lines:
      m_1=m_2 AND b_1=b_2
  },

  PERPENDICULAR_LINES: {
    standard_nonvertical_case:
      m_1*m_2=-1,

    equivalent:
      m_2=-1/m_1,

    condition:
      m_1 != 0,

    horizontal_vertical_special_case:
      horizontal_line_is_perpendicular_to_vertical_line
  },

  INTERSECTION_OF_LINEAR_FUNCTIONS: {
    functions:
      f(x)=m_1*x+b_1,
      g(x)=m_2*x+b_2,

    intersection_condition:
      f(x)=g(x),

    IF m_1 != m_2:
      x=(b_2-b_1)/(m_1-m_2),
      unique_intersection=TRUE,

    IF m_1=m_2 AND b_1!=b_2:
      no_intersection=TRUE,

    IF m_1=m_2 AND b_1=b_2:
      infinitely_many_common_points=TRUE
  },

  COMPOSITION: {
    f(x)=m_1*x+b_1,
    g(x)=m_2*x+b_2,

    composition:
      (f∘g)(x)=m_1*m_2*x+(m_1*b_2+b_1),

    closure:
      composition_of_affine_functions_is_affine
  },

  INVERSE_FUNCTION: {
    function:
      f(x)=m*x+b,

    invertibility_condition:
      m != 0,

    inverse:
      f^(-1)(x)=(x-b)/m,

    inverse_slope:
      1/m,

    domain_range_swap:
      TRUE
  },

  STRICT_LINEAR_MAP_PROPERTIES: {
    form:
      L(x)=m*x,

    additive:
      L(x+y)=L(x)+L(y),

    homogeneous:
      L(c*x)=c*L(x),

    zero_preserving:
      L(0)=0
  },

  AFFINE_VS_STRICT_LINEAR: {
    affine:
      f(x)=m*x+b,

    strict_linear:
      L(x)=m*x,

    strict_linear_condition:
      b=0,

    important_semantic_rule:
      do_not_conflate_affine_and_linear_map_meanings_when_context_is_linear_algebra
  },

  MONOTONICITY: {
    m>0:
      strictly_increasing,

    m<0:
      strictly_decreasing,

    m=0:
      constant
  },

  CONTINUITY: {
    real_affine_function:
      continuous_on_RealNumbers=TRUE
  },

  DIFFERENTIABILITY: {
    f(x)=m*x+b,

    derivative:
      f'(x)=m,

    interpretation:
      derivative_equals_constant_rate_of_change
  },

  INTEGRAL_RELATION: {
    antiderivative:
      F(x)=(m/2)*x^2+b*x+C
  },

  SEQUENCE_RELATION: {
    arithmetic_sequence:
      a_n=a_1+(n-1)*d,

    relation:
      linear_function_of_integer_index,

    common_difference:
      d
  },

  TABLE_RECOGNITION: {
    ordered_pairs:
      [(x_1,y_1),...,(x_n,y_n)],

    linearity_test:
      equal_slopes_between_all_distinct_point_pairs_when_defined,

    equally_spaced_input_test:
      constant_first_differences_in_output
  },

  DATA_MODEL_CAUTION: {
    exact_collinearity:
      defines_exact_linear_function_relation,

    approximate_collinearity:
      belongs_to_linear_regression_or_statistical_model,

    rule:
      do_not_equate_best_fit_line_with_exact_linear_function_without_context
  },

  FUNCTION_TRANSFORMATIONS: {
    vertical_shift:
      f(x)+k = m*x+(b+k),

    vertical_scale:
      a*f(x)=a*m*x+a*b,

    horizontal_shift:
      f(x-h)=m*x+(b-m*h),

    reflection_x_axis:
      -f(x)=-m*x-b,

    reflection_y_axis:
      f(-x)=-m*x+b
  },

  PARAMETER_REASONING: {
    family:
      f_(m,b)(x)=m*x+b,

    parameter_m:
      controls_slope,

    parameter_b:
      controls_vertical_position,

    special_cases: {
      m=0:
        constant_function,
      b=0:
        proportional_or_strict_linear_function
    }
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "f(x)=2x+3",
      "y=-4x+1",
      "g(t)=7t",
      "h(x)=5",
      "2x+3y=6 after solving for y"
    ],

    REDIRECT_NONLINEAR: [
      "f(x)=x^2",
      "y=1/x",
      "y=sqrt(x)",
      "y=2^x",
      "y=sin(x)"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "constant rate of change":
      slope_m,

    "gradient":
      slope_m,

    "starts at b and increases by m per unit":
      f(x)=m*x+b,

    "directly proportional":
      f(x)=k*x,

    "straight line function":
      affine_linear_function_in_elementary_context
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [
      identify_input_and_output,
      identify_initial_value,
      identify_constant_rate,
      assign_variables,
      construct_f(x)=m*x+b,
      apply_domain_constraints,
      evaluate_or_solve,
      interpret_units
    ],

    common_contexts: [
      fixed_fee_plus_unit_cost,
      distance_at_constant_speed,
      temperature_conversion,
      simple_salary_models,
      depreciation_at_constant_amount,
      direct_proportion
    ]
  },

  UNIT_SEMANTICS: {
    slope_units:
      output_units_per_input_unit,

    intercept_units:
      output_units,

    requirement:
      dimensional_consistency
  },

  ERROR_DETECTION: {
    VariableSlopeError:
-
      expression_has_nonconstant_rate_of_change
      -> reject_linear_classification,

    VerticalLineAsFunctionError:
      x=c
      -> reject_as_function_of_x,

    SlopeDivisionByZero:
      x_2=x_1
      -> slope_undefined,

    InterceptConfusion:
      b_is_y_intercept_not_x_intercept
      -> flag,

    ProportionConfusion:
      b!=0
      -> not_direct_proportion,

    LinearAffineAmbiguity:
      context_is_linear_algebra AND b!=0
      -> classify_as_affine_not_linear_map
  },

  SEMANTIC_EQUIVALENCE: {
    function_equivalence:
      same_domain
      AND same_output_for_every_input,

    algebraic_example:
      2*(x+1)+1
      <=> 2*x+3,

    line_equivalence:
      y=2*x+3
      <=> 2*x-y+3=0
      WHEN interpreting_same_graph_relation
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "LinearFunction IS_A Function",
      "AffineLinearFunction IS_A PolynomialFunction",
      "ProportionalFunction IS_A LinearFunctionInElementaryAlgebra",
      "StrictLinearFunction IS_A LinearMapInOneDimension"
    ],

    RELATED_TO: [
      "LinearFunction RELATED_TO LinearEquation",
      "LinearFunction RELATED_TO StraightLine",
      "LinearFunction RELATED_TO RateOfChange",
      "LinearFunction RELATED_TO ArithmeticSequence",
      "LinearFunction RELATED_TO CoordinateGeometry",
      "LinearFunction RELATED_TO LinearRegression"
    ],

    DEPENDS_ON: [
      FunctionSemantics,
      RealNumberArithmetic,
      CoordinateSystem,
      Ratio,
      Equality
    ]
  },

  CONFIDENCE: {
    classification_confidence:
      IF simplified_function_rule_has_form_m*x+b
      THEN 1.0,

    slope_confidence:
      IF coefficients_extracted_and_verified
      THEN 1.0,

    graph_confidence:
      IF rule_and_domain_verified
      THEN 1.0,

    semantic_context_confidence:
      depends_on [
        elementary_algebra_vs_linear_algebra_context,
        domain_resolution,
        representation_resolution
      ]
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_linear_function,
      distinguish_affine_from_strict_linear_map,
      extract_slope,
      extract_intercept,
      calculate_rate_of_change,
      construct_function_from_points,
      construct_function_from_slope_and_point,
      find_intercepts,
      test_parallelism,
      test_perpendicularity,
      find_line_intersection,
      construct_inverse,
      compose_linear_functions,
      infer_domain_and_range,
      interpret_tables,
      map_word_problems,
      detect_linear_function_errors,
      link_related_ontologies
    ],

    preferred_representation:
      typed_function_line_graph,

    reasoning_mode:
      recursive_constant_rate_mapping
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseLinearFunction(F,Context):

      parsed := ParseFunction(F)
      simplified := Simplify(parsed)

      IF not IsFunction(simplified):
        RETURN RedirectToRelationOntology

      form := DetectAffineForm(simplified)

      IF form = NONE:
        RETURN RedirectToFunctionOntology

      m,b := ExtractSlopeIntercept(form)

      IF Context = LinearAlgebra AND b != 0:
        semantic_type := AffineMap
      ELSE IF b = 0:
        semantic_type := StrictLinearOrProportionalFunction
      ELSE:
        semantic_type := AffineLinearFunction

      properties := {
        slope:m,
        intercept:b,
        monotonicity:ClassifySlope(m),
        root:SolveZeroIfPossible(m,b),
        inverse:ConstructInverseIf(m!=0)
      }

      verified := VerifyConstantRate(simplified,m)

      RETURN {
        function:simplified,
        semantic_type,
        properties,
        verified
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      slope_is_constant_across_domain=TRUE,

    invariant_2:
      graph_matches_straight_line_semantics=TRUE,

    invariant_3:
      y_intercept_equals_f(0)=TRUE,

    invariant_4:
      root_matches_x_intercept_when_real_and_defined=TRUE,

    invariant_5:
      affine_vs_strict_linear_context_distinction_preserved=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      linear_function_definition,
      slope_semantics,
      intercept_semantics,
      affine_linear_distinction,
      graph_relations,
      verification_rules
    ],

    purpose:
      "Detect semantic drift between revisions of the ontology."
  },

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      exactly_one_output_per_input,
      constant_rate_of_change,
      slope_semantics,
      intercept_semantics,
      strict_linear_map_requires_zero_intercept
    ],

    revision_triggers: [
      semantic_conflict,
      FunctionOntology_update,
      LinearEquationOntology_update,
      terminology_policy_revision,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      LinearFunction,
      Function,
      AffineFunction,
      StrictLinearFunction,
      ProportionalFunction,
      Slope,
      Intercept,
      RateOfChange,
      StraightLine,
      LinearEquation,
      Domain,
      Range
    ],

    edges: [
      LinearFunction -> IS_A -> Function,
      LinearFunction -> HAS_SLOPE -> Slope,
      LinearFunction -> HAS_INTERCEPT -> Intercept,
      Slope -> REPRESENTS -> RateOfChange,
      LinearFunction -> GRAPH_IS -> StraightLine,
      LinearFunction -> RELATED_TO -> LinearEquation,
      ProportionalFunction -> PASSES_THROUGH -> Origin,
      StrictLinearFunction -> HAS_INTERCEPT -> Zero,
      LinearFunction -> HAS_DOMAIN -> Domain,
      LinearFunction -> HAS_RANGE -> Range
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    FunctionOntology:
      direct_parent,

    LinearEquationOntology:
      graph_and_equation_relation,

    PolynomialOntology:
      degree_one_polynomial_structure,

    CoordinateGeometryOntology:
      line_slope_intercept_representation,

    RatioOntology:
      slope_as_rate,

    SequenceOntology:
      arithmetic_sequence_relation,

    CalculusOntology:
      constant_derivative,

    LinearAlgebraOntology:
      strict_linear_map_semantics,

    StatisticsOntology:
      distinguish_exact_line_from_linear_regression
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      linear_function_defined,
      affine_vs_strict_linear_distinction_defined,
      slope_defined,
      intercept_defined,
      graph_semantics_defined,
      construction_methods_defined,
      inverse_and_composition_defined,
      domain_range_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Linear_Function_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyFunction
    -> SimplifyRule
    -> ResolveDomain
    -> DetectLinearOrAffineForm
    -> ExtractSlopeAndIntercept
    -> ResolveTerminologyContext
    -> AnalyseRateOfChange
    -> DeriveIntercepts
    -> AnalyseGraphRelations
    -> ConstructInverseOrCompositionWhenRequested
    -> VerifyConstantRate
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    canonical_form,
    slope,
    intercept,
    rate_of_change,
    domain,
    range,
    root,
    graph_semantics,
    parallel_perpendicular_relations,
    inverse,
    composition,
    transformations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Linear_Function_Ontology_v1.0