Quadratic Function Ontology

FLOW Quadratic_Function_Ontology_v1.0

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

DEFINE QuadraticFunctionOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: QuadraticFunction,
    parent_entities: [Function, PolynomialFunction, AlgebraicFunction],
    related_entities: [
      Variable,
      Coefficient,
      Constant,
      QuadraticEquation,
      Polynomial,
      Parabola,
      Vertex,
      AxisOfSymmetry,
      Root,
      Zero,
      XIntercept,
      YIntercept,
      Discriminant,
      Maximum,
      Minimum,
      Domain,
      Range
    ]
  },

  DEFINITION: {
    meaning:
      "A polynomial function of degree exactly two in one principal variable.",
    standard_form:
      f(x)=a*x^2+b*x+c,
    constraint:
      a != 0,
    degree:
      2
  },

  SEMANTIC_PRIMITIVES: {
    QuadraticCoefficient:
      a,
    LinearCoefficient:
      b,
    ConstantTerm:
      c,
    Vertex:
      turning_point_of_parabola,
    AxisOfSymmetry:
      vertical_line_through_vertex,
    Root:
      x_value_where_f(x)=0,
    Discriminant:
      b^2-4*a*c,
    Parabola:
      graph_of_quadratic_function
  },

  FUNCTION_MODEL: {
    mapping:
      f: Domain -> Codomain,
    rule:
      x -> a*x^2+b*x+c,
    default_real_domain:
      RealNumbers,
    single_valuedness:
      TRUE
  },

  CLASSIFICATION: {

    StandardQuadraticFunction: {
      form:
        f(x)=a*x^2+b*x+c
    },

    VertexFormQuadratic: {
      form:
        f(x)=a*(x-h)^2+k
    },

    FactoredFormQuadratic: {
      form:
        f(x)=a*(x-r_1)*(x-r_2)
    },

    PerfectSquareQuadratic: {
      form:
        f(x)=a*(x-h)^2
    },

    MonicQuadraticFunction: {
      condition:
        a=1
    },

    NonMonicQuadraticFunction: {
      condition:
        a!=1
    }
  },

  COEFFICIENT_MODEL: {
    a:
      quadratic_coefficient_and_vertical_scale,
    b:
      linear_coefficient,
    c:
      constant_term_and_y_intercept
  },

  GRAPH_SEMANTICS: {
    graph_entity:
      Parabola,

    orientation: {
      a>0:
        opens_upward,
      a<0:
        opens_downward
    },

    width_relation:
      larger_absolute_a_means_narrower_parabola_in_standard_scaling_context,

    reflection:
      sign_change_of_a_reflects_graph_across_x_axis_relative_to_matching_base_form
  },

  AXIS_OF_SYMMETRY: {
    standard_form:
      x=-b/(2*a),

    vertex_form:
      x=h
  },

  VERTEX: {
    x_coordinate:
      -b/(2*a),

    y_coordinate:
      f(-b/(2*a)),

    vertex_form:
      (h,k)
  },

  VERTEX_VALUE: {
    formula:
      k=c-b^2/(4*a),

    equivalent:
      k=-D/(4*a)
  },

  MAXIMUM_MINIMUM: {
    IF a>0:
      vertex_is_global_minimum,
      minimum_value=k,

    IF a<0:
      vertex_is_global_maximum,
      maximum_value=k
  },

  DOMAIN_RANGE: {
    standard_real_domain:
      RealNumbers,

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

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

  Y_INTERCEPT: {
    method:
      evaluate_f(0),

    result:
      f(0)=c,

    coordinate:
      (0,c)
  },

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

    corresponding_equation:
      a*x^2+b*x+c=0,

    graph_relation:
      real_roots_correspond_to_x_intercepts
  },

  DISCRIMINANT_MODEL: {
    D:
      b^2-4*a*c,

    IF D>0:
      two_distinct_real_roots,
      two_x_intercepts,

    IF D=0:
      one_repeated_real_root,
      parabola_touches_x_axis_at_vertex,

    IF D<0:
      no_real_roots,
      no_real_x_intercepts
  },

  QUADRATIC_FORMULA_RELATION: {
    roots:
      x=(-b ± sqrt(D))/(2*a),

    condition:
      solve_f(x)=0
  },

  FACTORED_FORM: {
    form:
      f(x)=a*(x-r_1)*(x-r_2),

    roots:
      [r_1,r_2],

    semantic_advantage:
      roots_and_multiplicities_explicit
  },

  VERTEX_FORM: {
    form:
      f(x)=a*(x-h)^2+k,

    vertex:
      (h,k),

    axis:
      x=h,

    semantic_advantage:
      transformation_and_extremum_properties_explicit
  },

  STANDARD_TO_VERTEX_TRANSFORMATION: {
    START:
      a*x^2+b*x+c,

    COMPLETE_SQUARE:
      a*(x+b/(2*a))^2 + c-b^2/(4*a),

    RESULT:
      a*(x-h)^2+k,

    h:
      -b/(2*a),

    k:
      c-b^2/(4*a)
  },

  STANDARD_TO_FACTORED_TRANSFORMATION: {
    condition:
      roots_are_available,

    result:
      a*(x-r_1)*(x-r_2)
  },

  FORM_EQUIVALENCE: {
    StandardForm:
      a*x^2+b*x+c,

    VertexForm:
      a*(x-h)^2+k,

    FactoredForm:
      a*(x-r_1)*(x-r_2),

    condition:
      all_forms_expand_to_same_polynomial
  },

  SYMMETRY: {
    axis:
      x=h,

    property:
      f(h-d)=f(h+d)
      FOR all_valid_d
  },

  MONOTONICITY: {
    IF a>0:
      decreasing_on=(-infinity,h],
      increasing_on=[h,infinity),

    IF a<0:
      increasing_on=(-infinity,h],
      decreasing_on=[h,infinity)
  },

  RATE_OF_CHANGE: {
    not_constant:
      TRUE,

    average_rate_between_x1_x2:
      (f(x2)-f(x1))/(x2-x1),

    derivative_relation:
      f'(x)=2*a*x+b
  },

  DERIVATIVE_RELATION: {
    derivative:
      2*a*x+b,

    stationary_point:
      solve_f'(x)=0,

    result:
      x=-b/(2*a),

    semantic_link:
      stationary_point_equals_vertex_x_coordinate
  },

  SECOND_DERIVATIVE_RELATION: {
    second_derivative:
      f''(x)=2*a,

    IF a>0:
      concave_up,

    IF a<0:
      concave_down
  },

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

  TRANSFORMATIONS_FROM_PARENT: {
    parent_function:
      y=x^2,

    general_transform:
      y=a*(x-h)^2+k,

    h:
      horizontal_shift,

    k:
      vertical_shift,

    a:
      vertical_scale_and_possible_reflection
  },

  HORIZONTAL_SHIFT: {
    y=(x-h)^2:
      shift_right_by_h_when_h>0
  },

  VERTICAL_SHIFT: {
    y=x^2+k:
      shift_up_by_k_when_k>0
  },

  REFLECTION: {
    y=-x^2:
      reflection_of_y=x^2_across_x_axis
  },

  VERTICAL_SCALE: {
    y=a*x^2:
      absolute_a_controls_vertical_stretch_or_compression
  },

  ROOT_SUM_PRODUCT: {
    roots:
      r_1,r_2,

    sum:
      r_1+r_2=-b/a,

    product:
      r_1*r_2=c/a
  },

  MULTIPLICITY_GRAPH_RELATION: {
    simple_real_root:
      graph_crosses_x_axis,

    repeated_real_root:
      graph_touches_x_axis_and_turns
  },

  INTERSECTION_WITH_LINEAR_FUNCTION: {
    quadratic:
      f(x)=a*x^2+b*x+c,

    linear:
      g(x)=m*x+n,

    intersection_equation:
      a*x^2+(b-m)*x+(c-n)=0,

    possible_real_intersection_counts:
      [0,1,2]
  },

  INTERSECTION_OF_TWO_QUADRATICS: {
    f(x)=a_1*x^2+b_1*x+c_1,
    g(x)=a_2*x^2+b_2*x+c_2,

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

    difference:
      (a_1-a_2)*x^2+(b_1-b_2)*x+(c_1-c_2)=0,

    resulting_degree:
      at_most_2_after_simplification
  },

  COMPOSITION: {
    quadratic_after_linear:
      f(g(x))
      may_remain_quadratic_if_g_is_linear,

    linear_after_quadratic:
      g(f(x))
      remains_quadratic_if_g_is_nonconstant_linear,

    quadratic_after_quadratic:
      generally_degree_4
  },

  INVERSE_RELATION: {
    global_inverse_over_full_real_domain:
      generally_does_not_exist_due_to_noninjectivity,

    restricted_domain_inverse:
      possible_on_one_monotonic_branch,

    example:
      f(x)=x^2 restricted_to_x>=0
      has_inverse_sqrt(x)
  },

  INJECTIVITY: {
    full_real_domain:
      FALSE,

    restricted_domain:
      may_be_TRUE_on_x>=h_or_x<=h
  },

  SURJECTIVITY: {
    depends_on:
      declared_codomain,

    natural_real_range:
      half_line_determined_by_vertex_and_orientation
  },

  BIJECTIVITY: {
    possible_with:
      suitable_domain_restriction_and_matching_codomain
  },

  TABLE_RECOGNITION: {
    equally_spaced_inputs:
      quadratic_pattern_has_constant_second_differences,

    condition:
      second_difference_constant_and_nonzero
  },

  SECOND_DIFFERENCE_MODEL: {
    unit_input_spacing:
      second_difference=2*a,

    general_equal_spacing_delta:
      second_difference=2*a*(delta^2)
  },

  PARAMETER_REASONING: {
    family:
      f_(a,b,c)(x)=a*x^2+b*x+c,

    parameter_a:
      controls_orientation_and_scale,

    parameter_b:
      contributes_to_axis_location,

    parameter_c:
      controls_y_intercept,

    derived_parameters: {
      h=-b/(2*a),
      k=c-b^2/(4*a),
      D=b^2-4*a*c
    }
  },

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

    NORMALISE_FIRST: [
      "f(x)=(x+2)^2-3",
      "y=x(x-5)+6"
    ],

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

  NATURAL_LANGUAGE_MAPPING: {
    "parabola":
      likely_quadratic_function_graph,

    "turning point":
      vertex,

    "axis of symmetry":
      x=h,

    "opens upwards":
      a>0,

    "opens downwards":
      a<0,

    "maximum or minimum value":
      vertex_y_coordinate
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [
      identify_input_and_output,
      detect_quadratic_relationship,
      assign_variables,
      construct_quadratic_function,
      determine_relevant_domain,
      analyse_vertex_roots_or_values,
      verify_context_constraints,
      interpret_result
    ],

    common_contexts: [
      projectile_motion,
      area_models,
      optimisation,
      revenue_models,
      geometric_path_models
    ]
  },

  UNIT_SEMANTICS: {
    coefficient_units:
      a_has_output_units_per_input_units_squared,
      b_has_output_units_per_input_unit,
      c_has_output_units,

    requirement:
      dimensional_consistency
  },

  ERROR_DETECTION: {
    ZeroQuadraticCoefficient:
      a=0
      -> redirect_to_lower_degree_function,

    IncorrectVertexFormula:
      -> flag,

    DiscriminantError:
      -> flag,

    RangeOrientationError:
      mismatch_between_sign_of_a_and_range_direction
      -> flag,

    GlobalInverseError:
      inverse_claimed_without_domain_restriction
      -> flag,

    RootInterceptConfusion:
      complex_roots_are_not_real_graph_x_intercepts
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "QuadraticFunction IS_A PolynomialFunction",
      "QuadraticFunction IS_A Function"
    ],

    RELATED_TO: [
      "QuadraticFunction RELATED_TO QuadraticEquation",
      "QuadraticFunction RELATED_TO Parabola",
      "QuadraticFunction RELATED_TO Vertex",
      "QuadraticFunction RELATED_TO Discriminant",
      "QuadraticFunction RELATED_TO Optimisation",
      "QuadraticFunction RELATED_TO CoordinateGeometry"
    ],

    DEPENDS_ON: [
      FunctionSemantics,
      PolynomialDegree,
      RealNumberArithmetic,
      CoordinateSystem
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    function_equivalence:
      same_domain
      AND same_output_for_every_input,

    examples: [
      "x^2-6x+9 <=> (x-3)^2",
      "x^2-5x+6 <=> (x-2)(x-3)"
    ],

    requirement:
      forms_must_expand_to_same_polynomial_on_same_domain
  },

  CONFIDENCE: {
    classification_confidence:
      IF simplified_polynomial_degree=2 AND a!=0
      THEN 1.0,

    vertex_confidence:
      IF coefficient_extraction_verified
      THEN 1.0,

    root_confidence:
      IF roots_verify_f(root)=0
      THEN 1.0,

    semantic_mapping_confidence:
      based_on [
        degree_detection,
        domain_resolution,
        coefficient_extraction,
        graph_property_consistency
      ]
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_quadratic_function,
      normalise_function_rule,
      extract_coefficients,
      convert_between_standard_vertex_and_factored_forms,
      compute_axis_of_symmetry,
      compute_vertex,
      compute_discriminant,
      find_roots,
      infer_x_and_y_intercepts,
      determine_range,
      determine_maximum_or_minimum,
      analyse_monotonicity,
      identify_second_difference,
      analyse_transformations,
      restrict_domain_for_inverse,
      solve_intersections,
      map_word_problems,
      detect_reasoning_errors,
      link_related_ontologies
    ],

    preferred_representation:
      typed_polynomial_function_graph,

    reasoning_mode:
      recursive_form_conversion_and_geometric_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseQuadraticFunction(F,Context):

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

      IF not IsFunction(simplified):
        RETURN RedirectToRelationOntology

      polynomial := ExtractPolynomialRule(simplified)

      IF Degree(polynomial)<2:
        RETURN RedirectToLowerDegreeFunctionOntology

      IF Degree(polynomial)>2:
        RETURN RedirectToHigherDegreePolynomialFunctionOntology

      [a,b,c] := ExtractCoefficients(polynomial)

      IF a=0:
        RETURN RedirectToLinearFunctionOntology

      h := -b/(2*a)
      k := Evaluate(simplified,h)
      D := b^2-4*a*c
      roots := SolveQuadraticEquation(a*x^2+b*x+c=0)

      properties := {
        vertex:(h,k),
        axis:x=h,
        orientation:SignOf(a),
        discriminant:D,
        roots:roots,
        range:InferRange(a,k)
      }

      verified := VerifyQuadraticProperties(simplified,properties)

      RETURN {
        function:simplified,
        coefficients:[a,b,c],
        properties,
        verified
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      polynomial_degree_is_exactly_two=TRUE,

    invariant_2:
      vertex_lies_on_graph=TRUE,

    invariant_3:
      symmetry_about_axis_is_preserved=TRUE,

    invariant_4:
      real_roots_match_real_x_intercepts=TRUE,

    invariant_5:
      standard_vertex_and_factored_forms_are_semantically_consistent=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      quadratic_function_definition,
      coefficient_model,
      vertex_semantics,
      discriminant_model,
      graph_relations,
      transformation_rules
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      degree_exactly_two,
      nonzero_quadratic_coefficient,
      parabola_graph_semantics,
      vertex_axis_relationship,
      discriminant_root_relationship
    ],

    revision_triggers: [
      semantic_conflict,
      FunctionOntology_update,
      QuadraticEquationOntology_update,
      new_representation_standard
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      QuadraticFunction,
      Function,
      PolynomialFunction,
      QuadraticEquation,
      Parabola,
      Vertex,
      AxisOfSymmetry,
      Root,
      Discriminant,
      Maximum,
      Minimum,
      Domain,
      Range
    ],

    edges: [
      QuadraticFunction -> IS_A -> PolynomialFunction,
      QuadraticFunction -> GRAPH_IS -> Parabola,
      QuadraticFunction -> HAS_VERTEX -> Vertex,
      Parabola -> HAS_AXIS -> AxisOfSymmetry,
      QuadraticFunction -> HAS_ROOT -> Root,
      QuadraticFunction -> HAS_DISCRIMINANT -> Discriminant,
      QuadraticFunction -> HAS_DOMAIN -> Domain,
      QuadraticFunction -> HAS_RANGE -> Range,
      QuadraticFunction -> RELATED_TO -> QuadraticEquation
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    FunctionOntology:
      direct_parent,

    PolynomialOntology:
      degree_two_polynomial_structure,

    QuadraticEquationOntology:
      root_and_intercept_semantics,

    LinearFunctionOntology:
      intersection_and_lower_degree_relation,

    CoordinateGeometryOntology:
      parabola_vertex_axis_intercepts,

    CalculusOntology:
      derivative_extrema_concavity,

    InequalityOntology:
      range_and_sign_analysis,

    OptimisationOntology:
      maximum_and_minimum_models
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      quadratic_function_defined,
      coefficient_model_defined,
      major_forms_defined,
      vertex_and_axis_defined,
      root_and_discriminant_semantics_defined,
      graph_semantics_defined,
      domain_range_defined,
      transformation_rules_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Quadratic_Function_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyFunction
    -> SimplifyRule
    -> ValidatePolynomialDegree
    -> ExtractCoefficients
    -> ResolveDomain
    -> ComputeAxisOfSymmetry
    -> ComputeVertex
    -> ComputeDiscriminant
    -> FindRootsAndIntercepts
    -> DetermineOrientationAndRange
    -> ConvertBetweenRepresentations
    -> AnalyseTransformationsAndIntersections
    -> VerifyGraphAndAlgebraicConsistency
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    standard_form,
    vertex_form,
    factored_form,
    coefficients,
    domain,
    range,
    vertex,
    axis_of_symmetry,
    discriminant,
    roots,
    x_intercepts,
    y_intercept,
    orientation,
    maximum_or_minimum,
    monotonicity,
    graph_semantics,
    transformations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Quadratic_Function_Ontology_v1.0