Absolute Value Function Ontology

FLOW Absolute_Value_Function_Ontology_v1.0

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

DEFINE AbsoluteValueFunctionOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: AbsoluteValueFunction,
    parent_entities: [Function, PiecewiseFunction, AlgebraicFunction],
    related_entities: [
      AbsoluteValue,
      Modulus,
      Distance,
      PiecewiseDefinition,
      Domain,
      Range,
      Vertex,
      Reflection,
      Translation,
      Inequality,
      Equation,
      LinearFunction,
      Graph,
      VShape
    ]
  },

  DEFINITION: {
    meaning:
      "A function defined using absolute value, commonly representing the nonnegative magnitude or distance of a real-valued expression from zero.",
    canonical_form:
      f(x)=|x|,
    transformed_form:
      f(x)=a*|x-h|+k
  },

  SEMANTIC_PRIMITIVES: {
    AbsoluteValue:
      nonnegative_magnitude_of_real_number,
    DistanceFromZero:
      |x|,
    DistanceFromPoint:
      |x-h|,
    Vertex:
      point_where_absolute_value_branches_meet,
    PiecewiseBranch:
-
      expression_selected_by_sign_condition
  },

  ABSOLUTE_VALUE_DEFINITION: {
    |x| = {
      x     IF x>=0,
      -x    IF x<0
    }
  },

  PIECEWISE_FUNCTION_MODEL: {
    canonical:
      f(x)={
        x   IF x>=0,
        -x  IF x<0
      },

    transformed:
      f(x)=a*|x-h|+k
  },

  FUNCTION_MODEL: {
    mapping:
      f: RealNumbers -> NonnegativeRealNumbers
      for_canonical_absolute_value,

    single_valuedness:
      TRUE,

    default_domain:
      RealNumbers
  },

  DOMAIN_RANGE: {
    canonical_function: {
      Domain:
        RealNumbers,
      Range:
        [0,infinity)
    },

    transformed_function: {
      f(x)=a*|x-h|+k,

      IF a>0:
        Range=[k,infinity),

      IF a<0:
        Range=(-infinity,k],

      IF a=0:
        Range={k}
    }
  },

  VERTEX: {
    canonical:
      (0,0),

    transformed:
      (h,k)
  },

  AXIS_OF_SYMMETRY: {
    canonical:
      x=0,

    transformed:
      x=h
  },

  GRAPH_SEMANTICS: {
    canonical_shape:
      VShape,

    left_branch:
      slope=-1,

    right_branch:
      slope=1,

    transformed_form:
      slopes=[-a,a],

    symmetry:
      reflection_about_vertical_line_x=h
  },

  ORIENTATION: {
    IF a>0:
      opens_upward,

    IF a<0:
      opens_downward,

    IF a=0:
      constant_function
  },

  TRANSFORMATIONS: {
    parent:
      y=|x|,

    vertical_scale:
      y=a*|x|,

    horizontal_shift:
      y=|x-h|,

    vertical_shift:
      y=|x|+k,

    reflection_x_axis:
      y=-|x|
  },

  DISTANCE_INTERPRETATION: {
    |x|:
      distance_between_x_and_0,

    |x-h|:
      distance_between_x_and_h,

    metric_relation:
      d(x,h)=|x-h|
  },

  ROOTS_AND_INTERCEPTS: {
    x_intercepts:
      solve_a*|x-h|+k=0,

    y_intercept:
      f(0)=a*|h|+k
      with_sign_handled_by_absolute_value
  },

  SOLVING_ABSOLUTE_VALUE_EQUATIONS: {
    canonical_pattern:
      |g(x)|=c,

    CASE c<0:
      no_real_solution,

    CASE c=0:
      g(x)=0,

    CASE c>0:
      g(x)=c
      OR
      g(x)=-c
  },

  SOLVING_SHIFTED_FUNCTION_ZERO: {
    equation:
      a*|x-h|+k=0,

    condition:
      a!=0,

    transform:
      |x-h|=-k/a,

    CASE -k/a<0:
      no_real_roots,

    CASE -k/a=0:
      x=h,

    CASE -k/a>0:
      x=h ± (-k/a)
  },

  ABSOLUTE_VALUE_INEQUALITY_RELATION: {
    |g(x)|<c:
      -c<g(x)<c
      for_c>0,

    |g(x)|<=c:
      -c<=g(x)<=c
      for_c>=0,

    |g(x)|>c:
      g(x)<-c OR g(x)>c
      for_c>=0,

    |g(x)|>=c:
      g(x)<=-c OR g(x)>=c
      for_c>=0
  },

  MONOTONICITY: {
    canonical:
      decreasing_on=(-infinity,0],
      increasing_on=[0,infinity),

    transformed_a_positive:
      decreasing_on=(-infinity,h],
      increasing_on=[h,infinity),

    transformed_a_negative:
      increasing_on=(-infinity,h],
      decreasing_on=[h,infinity)
  },

  CONTINUITY: {
    absolute_value_function:
      continuous_on_RealNumbers=TRUE
  },

  DIFFERENTIABILITY: {
    canonical:
      differentiable_everywhere_except_x=0,

    transformed:
      differentiable_everywhere_except_x=h
      WHEN a!=0,

    branch_derivatives:
      left=-a,
      right=a
  },

  CORNER_POINT: {
    canonical:
      x=0,

    transformed:
      x=h,

    semantic_type:
      nondifferentiable_corner
  },

  DERIVATIVE_RELATION: {
    for_x!=0:
      d/dx |x| = sign(x),

    transformed:
      d/dx [a*|x-h|+k]
      =
      {
        -a IF x<h,
        a IF x>h
      }
  },

  SIGN_FUNCTION_RELATION: {
    derivative_of_absolute_value:
      sign(x)
      for_x!=0,

    sign_function:
      {
        -1 IF x<0,
         0 IF x=0,
         1 IF x>0
      }
  },

  CONVEXITY: {
    canonical_absolute_value:
      convex=TRUE,

    transformed:
      IF a>0:
        convex,
      IF a<0:
        concave
  },

  TRIANGLE_INEQUALITY_RELATION: {
    property:
      |x+y| <= |x|+|y|,

    semantic_link:
      absolute_value_as_metric_magnitude
  },

  REVERSE_TRIANGLE_INEQUALITY: {
    property:
      ||x|-|y|| <= |x-y|
  },

  MULTIPLICATIVE_PROPERTIES: {
    |x*y|:
      |x|*|y|,

    |x/y|:
      |x|/|y|
      WHERE y!=0
  },

  POWER_PROPERTIES: {
    |x|^2:
      x^2,

    sqrt(x^2):
      |x|
      over_real_numbers
  },

  EVEN_FUNCTION_PROPERTY: {
    canonical:
      f(-x)=f(x),

    classification:
      even_function
  },

  COMPOSITION: {
    outer_absolute_value:
      h(x)=|g(x)|,

    range:
      nonnegative_outputs,

    semantic_effect:
      reflects_negative_portions_of_g_across_x_axis
  },

  ABSOLUTE_VALUE_OF_FUNCTION: {
    graph_transformation:
      y=|f(x)|,

    rule:
      retain_nonnegative_graph_portions,
      reflect_negative_graph_portions_above_x_axis
  },

  FUNCTION_OF_ABSOLUTE_INPUT: {
    form:
      y=f(|x|),

    symmetry:
      even_about_y_axis,

    graph_rule:
      right_side_behaviour_reflected_to_left_side
  },

  PARAMETER_REASONING: {
    family:
      f_(a,h,k)(x)=a*|x-h|+k,

    parameter_a:
      controls_vertical_scale_and_orientation,

    parameter_h:
      controls_horizontal_vertex_location,

    parameter_k:
      controls_vertical_vertex_location
  },

  LINEAR_BRANCH_RELATION: {
    transformed_function:
      a*|x-h|+k,

    left_branch:
      -a*(x-h)+k
      for_x<h,

    right_branch:
      a*(x-h)+k
      for_x>=h
  },

  PIECEWISE_CONVERSION: {
    INPUT:
      a*|x-h|+k,

    OUTPUT:
      {
        -a*(x-h)+k IF x<h,
         a*(x-h)+k IF x>=h
      }
  },

  TABLE_RECOGNITION: {
    characteristic_pattern:
      values_change_linearly_on_each_side_of_vertex,

    slope_change:
      from_-a_to_a_at_vertex
  },

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

    NORMALISE_FIRST: [
      "f(x)=sqrt(x^2)",
      "y=|-(x-2)|"
    ],

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

  NATURAL_LANGUAGE_MAPPING: {
    "distance from zero":
      |x|,

    "distance from h":
      |x-h|,

    "magnitude":
      absolute_value_when_real_scalar_context,

    "V-shaped graph":
      likely_absolute_value_function,

    "minimum at h,k":
      possible_a_positive_absolute_value_model
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [
      identify_reference_value,
      identify_distance_or_deviation_quantity,
      construct_absolute_value_expression,
      determine_scale_and_shift,
      establish_domain,
      solve_or_evaluate,
      interpret_symmetric_cases,
      verify_context
    ],

    common_contexts: [
      distance_from_target,
      tolerance,
      deviation,
      measurement_error,
      scheduling_difference,
      temperature_difference
    ]
  },

  UNIT_SEMANTICS: {
    absolute_value:
      preserves_units_of_input_quantity,

    |x-h|:
      x_and_h_must_have_same_units
  },

  ERROR_DETECTION: {
    NegativeAbsoluteValueError:
      |x|<0_asserted_as_possible_value
      -> flag,

    MissingTwoBranchSolution:
      |g(x)|=c_with_c>0_but_only_one_branch_solved
      -> flag,

    IncorrectPiecewiseBoundary:
      branch_sign_conditions_wrong
      -> flag,

    VertexError:
      transformed_vertex_not_equal_(h,k)
      -> flag,

    DifferentiabilityError:
      derivative_claimed_at_corner_without_special_case
      -> flag,

    SquareRootSquareConfusion:
      sqrt(x^2)=x_without_domain_sign_condition
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "AbsoluteValueFunction IS_A Function",
      "AbsoluteValueFunction IS_A PiecewiseFunction"
    ],

    RELATED_TO: [
      "AbsoluteValueFunction RELATED_TO AbsoluteValue",
      "AbsoluteValueFunction RELATED_TO Distance",
      "AbsoluteValueFunction RELATED_TO Inequality",
      "AbsoluteValueFunction RELATED_TO PiecewiseLinearFunction",
      "AbsoluteValueFunction RELATED_TO Metric"
    ],

    DEPENDS_ON: [
      FunctionSemantics,
      RealNumberOrder,
      PiecewiseDefinition,
      DistanceSemantics
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    examples: [
      "|x| <=> sqrt(x^2)",
      "|x-h| <=> distance(x,h)"
    ],

    function_equivalence:
      same_domain
      AND same_output_for_every_input
  },

  CONFIDENCE: {
    classification_confidence:
      IF absolute_value_operation_is_primary_function_structure
      THEN 1.0,

    vertex_confidence:
      IF transformed_form_parameters_extracted
      THEN 1.0,

    solution_confidence:
      IF both_required_branches_processed
      AND candidates_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_absolute_value_function,
      convert_to_piecewise_form,
      identify_vertex,
      identify_axis_of_symmetry,
      determine_domain_and_range,
      solve_absolute_value_equations,
      solve_absolute_value_inequalities,
      analyse_graph_transformations,
      detect_corner_nondifferentiability,
      apply_distance_interpretation,
      analyse_composition_with_absolute_value,
      detect_branch_errors,
      map_word_problems,
      link_related_ontologies
    ],

    preferred_representation:
      typed_piecewise_distance_function_graph,

    reasoning_mode:
      recursive_sign_partition_and_symmetry_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseAbsoluteValueFunction(F,Context):

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

      IF not IsFunction(simplified):
        RETURN RedirectToRelationOntology

      form := DetectAbsoluteValueForm(simplified)

      IF form = NONE:
        RETURN RedirectToFunctionOntology

      [a,h,k,inner] := ExtractAbsoluteValueParameters(form)

      domain := ResolveDomain(inner,Context)

      branches := ConvertToPiecewise(form)

      properties := {
        vertex:(h,k),
        axis:x=h,
        orientation:SignOf(a),
        range:InferRange(a,k),
        continuity:TRUE,
        differentiability:
          DifferentiableExceptAtVertexIfNonzeroScale(a)
      }

      verified := VerifyAbsoluteValueProperties(form,branches,properties)

      RETURN {
        function:simplified,
        parameters:[a,h,k],
        branches,
        properties,
        verified
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      absolute_value_outputs_nonnegative_before_outer_transform=TRUE,

    invariant_2:
      piecewise_form_matches_absolute_value_form=TRUE,

    invariant_3:
      vertex_and_symmetry_consistent=TRUE,

    invariant_4:
      equation_solution_branches_complete=TRUE,

    invariant_5:
      distance_interpretation_matches_absolute_difference=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      absolute_value_definition,
      piecewise_semantics,
      distance_semantics,
      graph_transformation_rules,
      equation_and_inequality_rules,
      verification_rules
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      absolute_value_nonnegative_magnitude,
      two_branch_piecewise_definition,
      distance_interpretation,
      vertex_symmetry_relation,
      branch_complete_equation_solving
    ],

    revision_triggers: [
      semantic_conflict,
      FunctionOntology_update,
      InequalityOntology_update,
      PiecewiseFunctionOntology_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      AbsoluteValueFunction,
      Function,
      AbsoluteValue,
      Distance,
      PiecewiseFunction,
      Vertex,
      AxisOfSymmetry,
      Domain,
      Range,
      Inequality,
      Equation
    ],

    edges: [
      AbsoluteValueFunction -> IS_A -> Function,
      AbsoluteValueFunction -> IS_A -> PiecewiseFunction,
      AbsoluteValueFunction -> USES -> AbsoluteValue,
      AbsoluteValue -> REPRESENTS -> Distance,
      AbsoluteValueFunction -> HAS_VERTEX -> Vertex,
      AbsoluteValueFunction -> HAS_AXIS -> AxisOfSymmetry,
      AbsoluteValueFunction -> HAS_DOMAIN -> Domain,
      AbsoluteValueFunction -> HAS_RANGE -> Range,
      AbsoluteValueFunction -> RELATED_TO -> Inequality,
      AbsoluteValueFunction -> RELATED_TO -> Equation
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    FunctionOntology:
      direct_parent,

    PiecewiseFunctionOntology:
      branch_representation,

    LinearFunctionOntology:
      linear_branches,

    InequalityOntology:
      absolute_value_inequalities,

    EquationOntology:
      absolute_value_equations,

    MetricOntology:
      distance_interpretation,

    CoordinateGeometryOntology:
      vertex_axis_and_graph_shape,

    CalculusOntology:
      continuity_derivative_and_corner
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      absolute_value_function_defined,
      piecewise_definition_defined,
      distance_semantics_defined,
      domain_range_defined,
      vertex_and_axis_defined,
      transformation_rules_defined,
      equation_and_inequality_rules_defined,
      continuity_and_differentiability_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Absolute_Value_Function_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyFunction
    -> DetectAbsoluteValueStructure
    -> ExtractParameters
    -> ResolveDomain
    -> ConvertToPiecewiseBranches
    -> IdentifyVertexAndAxis
    -> DetermineOrientationAndRange
    -> AnalyseRootsAndIntercepts
    -> SolveAbsoluteValueEquationOrInequalityWhenRequested
    -> AnalyseContinuityAndDifferentiability
    -> VerifyBranchAndDistanceSemantics
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    canonical_form,
    transformed_form,
    piecewise_form,
    parameters,
    domain,
    range,
    vertex,
    axis_of_symmetry,
    orientation,
    roots,
    x_intercepts,
    y_intercept,
    monotonicity,
    continuity,
    differentiability,
    graph_semantics,
    transformations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Absolute_Value_Function_Ontology_v1.0