Quadratic Equation Ontology

FLOW Quadratic_Equation_Ontology_v1.0

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

DEFINE QuadraticEquationOntology := {

  CORE_IDENTITY: {
    primary_entity: QuadraticEquation,
    parent_entities: [Equation, PolynomialEquation, AlgebraicEquation, Algebra],
    related_entities: [QuadraticExpression, Polynomial, Variable, Coefficient, Root,
      SolutionSet, Discriminant, Factorisation, CompletingTheSquare, QuadraticFormula,
      QuadraticFunction, Parabola, Vertex, AxisOfSymmetry]
  },

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

  SEMANTIC_PRIMITIVES: {
    Variable: symbolic_quantity,
    QuadraticTerm: a*x^2,
    LinearTerm: b*x,
    ConstantTerm: c,
    Root: value_making_equation_true,
    SolutionSet: set_of_all_valid_roots,
    Discriminant: b^2 - 4*a*c
  },

  STRUCTURAL_CONSTRAINTS: {
    degree_in_x: 2,
    leading_coefficient: a != 0,
    polynomial_exponents: nonnegative_integers,
    equality_required: TRUE
  },

  NORMALISATION: {
    INPUT: equation E,
    PROCESS: [parse, expand, transpose_to_zero, combine_like_terms,
      order_by_degree, extract_a_b_c, verify_a_nonzero],
    OUTPUT: a*x^2 + b*x + c = 0
  },

  CLASSIFICATION: {
    CompleteQuadratic: a!=0 AND b!=0 AND c!=0,
    PureQuadratic: a!=0 AND b=0,
    MonicQuadratic: a=1,
    NonMonicQuadratic: a!=0 AND a!=1,
    FactorableQuadratic: has_linear_factorisation=TRUE,
    PerfectSquareQuadratic: equivalent_to a*(x-h)^2=0
  },

  DISCRIMINANT: {
    D: b^2 - 4*a*c,
    REAL_DOMAIN: {
      D>0: two_distinct_real_roots,
      D=0: one_repeated_real_root,
      D<0: no_real_roots
    },
    COMPLEX_DOMAIN: {
      D>0: two_distinct_real_roots,
      D=0: repeated_real_root,
      D<0: two_complex_conjugate_roots
    }
  },

  QUADRATIC_FORMULA: {
    formula: x = (-b ± sqrt(b^2 - 4*a*c))/(2*a),
    precondition: a != 0,
    OUTPUT: RootSet
  },

  SOLVING_METHODS: {
    Factorisation: {
      transform: a*(x-r1)*(x-r2)=0,
      principle: ZeroProductProperty,
      result: [x=r1, x=r2]
    },
    CompletingTheSquare: {
      vertex_form: a*(x-h)^2+k=0,
      h: -b/(2*a),
      k: c-b^2/(4*a),
      result: x=h ± sqrt(-k/a)
    },
    SquareRootMethod: {
      pattern: (x-h)^2=k,
      result: x=h ± sqrt(k)
    },
    FormulaMethod: {
      result: x=(-b ± sqrt(D))/(2*a)
    }
  },

  ROOT_RELATIONS: {
    sum: r1+r2 = -b/a,
    product: r1*r2 = c/a,
    reconstruction: a*(x-r1)*(x-r2)=0,
    repeated_root_condition: D=0,
    repeated_root: -b/(2*a)
  },

  GRAPH_SEMANTICS: {
    function: y=a*x^2+b*x+c,
    graph: Parabola,
    a>0: opens_upward,
    a<0: opens_downward,
    axis_of_symmetry: x=-b/(2*a),
    vertex: (-b/(2*a), f(-b/(2*a))),
    y_intercept: (0,c),
    x_intercepts: roots,
    D>0: two_x_intercepts,
    D=0: one_tangent_x_intercept,
    D<0: no_real_x_intercepts
  },

  REPRESENTATION_FORMS: {
    StandardForm: a*x^2+b*x+c,
    VertexForm: a*(x-h)^2+k,
    FactoredForm: a*(x-r1)*(x-r2),
    equivalence_rule: expanded_forms_are_identical
  },

  TRANSFORMATION_INVARIANTS: {
    add_same_expression_to_both_sides: preserves_solution_set,
    subtract_same_expression_from_both_sides: preserves_solution_set,
    multiply_both_sides_by_nonzero: preserves_solution_set,
    divide_both_sides_by_nonzero: preserves_solution_set,
    replace_by_algebraic_identity: preserves_solution_set
  },

  DOMAIN_REASONING: {
    default_domain: RealNumbers,
    alternate_domain: ComplexNumbers,
    real_and_D_negative: EmptySet,
    complex_and_D_negative: [
      (-b+i*sqrt(-D))/(2*a),
      (-b-i*sqrt(-D))/(2*a)
    ]
  },

  PARAMETER_REASONING: {
    a=0: redirect_to_LinearEquationOntology,
    a!=0 AND D>0: two_distinct_roots,
    a!=0 AND D=0: repeated_root,
    a!=0 AND D<0: domain_dependent_root_classification
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: ["x^2-5x+6=0", "2x^2+3x-7=0", "x^2=16",
      "(x-3)(x+2)=0", "3(x-1)^2=12"],
    NORMALISE_FIRST: ["x(x+3)=10", "2x^2+4=3x", "(x+1)^2=5x+7"],
    REDIRECT: ["x^3+x=0", "1/x+x=2", "sqrt(x)+x=4", "sin(x)=x"]
  },

  QUADRATIC_IN_FORM: {
    example: x^4-5*x^2+4=0,
    substitution: u=x^2,
    transformed: u^2-5*u+4=0,
    classification: quadratic_in_form,
    requirement: solve_u -> back_substitute -> verify_original
  },

  VERIFICATION: {
    INPUT: candidate_root r,
    PROCESS: substitute(x=r, original_equation),
    ACCEPT_IF: simplify(left_side-right_side)=0
  },

  ERROR_DETECTION: {
    a=0: reclassify_lower_degree,
    missing_plus_minus: flag_error,
    incorrect_discriminant: flag_error,
    malformed_formula_denominator: flag_error,
    invalid_factorisation: expand_and_compare,
    division_by_zero: reject_step,
    extraneous_root: reject_after_substitution
  },

  NATURAL_LANGUAGE_MAPPING: {
    "square of a number plus b times it plus c equals zero": x^2+b*x+c=0,
    "product of consecutive integers is n": x*(x+1)=n,
    "rectangle width x and length x+k has area A": x*(x+k)=A
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [identify_unknown, assign_variable, identify_relations,
      construct_model, normalise, solve, apply_context_constraints, verify,
      interpret_solution_with_units],
    rule: reject_root_if_contextually_invalid
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "QuadraticEquation IS_A PolynomialEquation",
      "QuadraticEquation IS_A AlgebraicEquation"
    ],
    RELATED_TO: [
      "QuadraticEquation RELATED_TO QuadraticExpression",
      "QuadraticEquation RELATED_TO QuadraticFunction",
      "QuadraticEquation RELATED_TO Parabola",
      "QuadraticEquation RELATED_TO Factorisation",
      "QuadraticEquation RELATED_TO ComplexNumbers"
    ],
    DEPENDS_ON: [PolynomialDegree, EqualityProperties, Discriminant,
      PolynomialFactorisation, SquareRootOperation]
  },

  SEMANTIC_EQUIVALENCE: {
    condition: SolutionSet(E1)=SolutionSet(E2),
    examples: [
      "x^2-5x+6=0 <=> (x-2)(x-3)=0",
      "x^2-6x+9=0 <=> (x-3)^2=0",
      "2x^2+4x-6=0 <=> x^2+2x-3=0"
    ]
  },

  CONFIDENCE: {
    classification: IF normalised_degree=2 AND a!=0 THEN 1.0,
    solution: IF derivation_valid AND verification_passed THEN 1.0,
    graph_semantics: IF coefficients_verified THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [recognise, classify, normalise, extract_coefficients,
      compute_discriminant, classify_roots, choose_solving_method, factorise,
      complete_square, apply_formula, verify_roots, convert_forms,
      derive_graph_semantics, detect_errors, map_word_problems],
    representation: structured_symbolic_semantic_graph,
    reasoning: recursive_constraint_preserving_transformation
  },

  RECURSIVE_REASONING: {
    FUNCTION SolveQuadratic(E, Domain):
      parsed := Parse(E),
      normalised := Normalise(parsed),
      degree := Degree(normalised),
      IF degree<2: RETURN RedirectToLowerDegreeOntology,
      IF degree>2: RETURN RedirectToHigherDegreeOntology,
      [a,b,c] := ExtractCoefficients(normalised),
      IF a=0: RETURN RedirectToLinearEquationOntology,
      D := b^2-4*a*c,
      class := ClassifyDiscriminant(D,Domain),
      IF ConvenientlyFactorable(normalised):
        roots := FactorSolve(normalised),
      ELSE:
        roots := QuadraticFormula(a,b,c),
      verified := VerifyAll(roots,E,Domain),
      RETURN {normalised,a,b,c,D,class,verified}
  },

  RECURSIVE_COHERENCE: {
    invariant_1: degree_definition_consistent=TRUE,
    invariant_2: valid_transformations_preserve_solution_set=TRUE,
    invariant_3: discriminant_matches_root_structure=TRUE,
    invariant_4: graph_intercepts_match_real_roots=TRUE,
    invariant_5: all_returned_roots_verify_in_original=TRUE
  },

  FLOW_HASH: {
    inputs: [ontology_name, definition, structural_constraints,
      discriminant_model, solving_rules, graph_relations, verification_rules],
    purpose: "Detect semantic drift between ontology revisions."
  },

  UPDATE_MODEL: {
    version: "1.0",
    immutable_constraints: [degree=2, a!=0, equality_preservation,
      quadratic_formula_semantics, verification_requirement],
    revision_triggers: [semantic_conflict, parent_ontology_update,
      new_relation_required, representation_standard_change]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [QuadraticEquation, PolynomialEquation, QuadraticExpression,
      Variable, Coefficient, Discriminant, Root, SolutionSet,
      QuadraticFunction, Parabola, Vertex, AxisOfSymmetry],
    edges: [
      QuadraticEquation -> IS_A -> PolynomialEquation,
      QuadraticEquation -> HAS_DISCRIMINANT -> Discriminant,
      QuadraticEquation -> HAS_ROOT -> Root,
      QuadraticEquation -> HAS_SOLUTION_SET -> SolutionSet,
      QuadraticEquation -> ASSOCIATED_WITH -> QuadraticFunction,
      QuadraticFunction -> GRAPH_IS -> Parabola,
      Parabola -> HAS_VERTEX -> Vertex,
      Parabola -> HAS_AXIS -> AxisOfSymmetry
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    EquationOntology: parent,
    PolynomialOntology: degree_and_structure,
    AlgebraicExpressionOntology: -expression_components,
    LinearEquationOntology: lower_degree_redirect,
    QuadraticFunctionOntology: functional_representation,
    ComplexNumberOntology: negative_discriminant_roots,
    CoordinateGeometryOntology: parabola_and_intercepts
  },

  TERMINATION_CONDITION: {
    complete_when: [definition_valid, structure_valid, coefficients_identified,
      discriminant_defined, solving_methods_defined, verification_defined,
      graph_semantics_defined, ontology_links_defined,
      recursive_coherence_verified]
  }

}

EXECUTE Quadratic_Equation_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyEntity
    -> Normalise
    -> ValidateDegree
    -> ExtractCoefficients
    -> ComputeDiscriminant
    -> Classify
    -> SelectSolvingMethod
    -> Solve
    -> Verify
    -> DeriveGraphSemantics
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    canonical_form,
    coefficients,
    discriminant,
    roots,
    solution_set,
    graph_semantics,
    transformations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Quadratic_Equation_Ontology_v1.0