Simultaneous Equations Ontology

FLOW Simultaneous_Equations_Ontology_v1.0

PAGE:
  title: "Simultaneous Equations Ontology"
  canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/simultaneous-equations-ontology.html"
  language: "en-GB"
  domain: "Mathematics > Algebra > Equations > Simultaneous Equations"

DEFINE SimultaneousEquationsOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: SimultaneousEquations,
    parent_entities: [SystemOfEquations, EquationSet, Algebra],
    related_entities: [
      Equation,
      LinearEquation,
      NonlinearEquation,
      Variable,
      Unknown,
      Solution,
      SolutionSet,
      Substitution,
      Elimination,
      GraphicalSolution,
      MatrixEquation,
      Intersection,
      Constraint
    ]
  },

  DEFINITION: {
    meaning:
      "Two or more equations involving shared variables that are solved together so that the resulting values satisfy every equation simultaneously.",
    canonical_semantics:
      solve(E_1 AND E_2 AND ... AND E_m),
    shared_variables_required:
      TRUE
  },

  SEMANTIC_PRIMITIVES: {
    Equation: equality_relation,
    SharedVariable: variable_occurring_across_multiple_equations,
    Constraint: condition_imposed_by_an_equation,
    SimultaneousSolution:
      assignment_satisfying_all_equations_at_once,
    SolutionSet:
      intersection_of_equation_solution_sets
  },

  CORE_LOGIC: {
    system:
      E_1 AND E_2 AND ... AND E_m,

    candidate_solution:
      assignment_to_all_required_variables,

    valid_solution:
      FOR_EACH E_i:
        E_i(candidate_solution)=TRUE
  },

  RELATION_TO_SYSTEM_OF_EQUATIONS: {
    equivalence:
      SimultaneousEquations IS_A SystemOfEquations,

    usage_note:
      term_is_commonly_used_for_small_systems_solved_together,

    semantic_distinction:
      none_required_at_core_mathematical_level
  },

  CLASSIFICATION: {

    LinearSimultaneousEquations: {
      condition:
        all_equations_linear_in_shared_variables
    },

    NonlinearSimultaneousEquations: {
      condition:
        at_least_one_equation_nonlinear
    },

    TwoEquationSystem: {
      equation_count: 2
    },

    MultiEquationSystem: {
      equation_count: m WHERE m>2
    },

    Consistent: {
      condition:
        common_solution_exists
    },

    Inconsistent: {
      condition:
        no_common_solution_exists
    },

    Independent: {
      linear_case:
        unique_solution
    },

    Dependent: {
      linear_case:
        infinitely_many_solutions_due_to_equivalent_constraints
    }
  },

  TWO_VARIABLE_LINEAR_FORM: {
    equations:
      {
        a_1*x + b_1*y = c_1,
        a_2*x + b_2*y = c_2
      },

    variables:
      [x,y]
  },

  SUBSTITUTION_METHOD: {
    PURPOSE:
      solve_one_equation_for_one_variable_then_substitute,

    PROCESS: [
      select_equation,
      isolate_variable,
      substitute_expression_into_other_equation,
      simplify_to_single_variable_equation,
      solve_reduced_equation,
      back_substitute,
      verify_both_equations
    ],

    invariant:
      derived_expression_must_be_equivalent_to_source_equation
  },

  ELIMINATION_METHOD: {
    PURPOSE:
      remove_one_variable_by_combining_equations,

    PROCESS: [
      align_equations,
      multiply_equation_if_required,
      add_or_subtract_equations,
      eliminate_target_variable,
      solve_remaining_variable,
      back_substitute,
      verify
    ],

    semantic_basis:
      valid_linear_combinations_preserve_common_solution_set
  },

  GRAPHICAL_METHOD: {
    PURPOSE:
      identify_common_intersection_points,

    linear_two_variable_cases: {
      one_intersection:
        unique_solution,

      parallel_distinct_lines:
        no_solution,

      coincident_lines:
        infinitely_many_solutions
    },

    nonlinear_case:
      solutions_are_common_graph_intersections
  },

  EQUAL_COEFFICIENT_ELIMINATION: {
    condition:
      target_variable_coefficients_are_equal_or_opposite,

    action:
      add_or_subtract_equations_directly
  },

  SCALING_FOR_ELIMINATION: {
    condition:
      target_coefficients_not_immediately_eliminable,

    action:
      multiply_one_or_more_equations_by_nonzero_constants,

    invariant:
      scaling_by_nonzero_constant_preserves_equation_solution_set
  },

  MATRIX_REPRESENTATION: {
    linear_system:
      A*x=b,

    coefficient_matrix:
      A,

    variable_vector:
      x,

    constant_vector:
      b,

    augmented_matrix:
      [A|b]
  },

  DETERMINANT_RELATION_2X2: {
    determinant:
      D = a_1*b_2 - a_2*b_1,

    IF D != 0:
      unique_solution = TRUE,

    IF D = 0:
      require_dependency_or_inconsistency_test
  },

  CRAMERS_RULE: {
    applicability:
      square_linear_system AND det(A)!=0,

    variable_solution:
      x_i = det(A_i)/det(A),

    semantic_status:
      exact_linear_solution_method
  },

  CONSISTENCY_ANALYSIS: {

    UniqueSolution: {
      linear_condition:
        rank(A)=rank([A|b])=number_of_variables
    },

    InfiniteSolutions: {
      linear_condition:
        rank(A)=rank([A|b])<number_of_variables
    },

    NoSolution: {
      linear_condition:
        rank(A)!=rank([A|b])
    }
  },

  SOLUTION_SET_MODEL: {
    definition:
      INTERSECTION[
        SolutionSet(E_1),
        SolutionSet(E_2),
        ...,
        SolutionSet(E_m)
      ],

    empty_intersection:
      inconsistent,

    singleton_intersection:
      unique_solution,

    multi_or_infinite_intersection:
      multiple_or_infinite_solutions
  },

  TRANSFORMATION_GRAPH: {
    nodes: [
      OriginalSimultaneousEquations,
      NormalisedEquations,
      IsolatedVariableForm,
      EliminatedSystem,
      ReducedEquation,
      CandidateSolution,
      VerifiedSolutionSet
    ],

    edges: [
      normalise,
      rearrange,
      isolate,
      substitute,
      scale,
      add_equations,
      subtract_equations,
      solve_reduced_equation,
      back_substitute,
      verify
    ],

    invariant:
      common_solution_set_preserved
  },

  EQUIVALENCE_RULES: {
    replace_equation_with_equivalent_equation:
      valid,

    multiply_equation_by_nonzero_constant:
      valid,

    add_multiple_of_one_equation_to_another:
      valid_for_linear_systems,

    divide_equation_by_nonzero_constant:
      valid,

    nonlinear_warning:
      transformations_involving_squaring_or_variable_division_require_verification
  },

  NORMALISATION: {
    INPUT:
      simultaneous_equation_set S,

    PROCESS: [
      parse_each_equation,
      identify_shared_variables,
      simplify_each_equation,
      move_terms_to_preferred_form,
      classify_linear_or_nonlinear,
      preserve_original_equations_for_verification
    ],

    OUTPUT:
      NormalisedSimultaneousEquationSet
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "{x+y=7, x-y=1}",
      "{2x+3y=12, x-y=1}",
      "{x+y+z=6, x-y+z=2, 2x+z=5}",
      "{x^2+y^2=25, y=x+1}"
    ],

    REDIRECT_SINGLE_EQUATION:
      equation_count=1 -> EquationOntology
  },

  NONLINEAR_SIMULTANEOUS_EQUATIONS: {
    solving_methods: [
      substitution,
      elimination,
      factorisation,
      resultant_methods,
      Groebner_basis_methods,
      numerical_methods,
      graphical_intersection
    ],

    rule:
      candidate_solutions_must_be_checked_against_all_original_equations
  },

  SUBSTITUTION_NONLINEAR_EXAMPLE_PATTERN: {
    equations:
      {
        y=f(x),
        G(x,y)=0
      },

    transform:
      G(x,f(x))=0,

    solve:
      reduced_equation_in_x,

    back_substitute:
      y=f(x),

    verify:
      both_original_equations
  },

  DOMAIN_REASONING: {
    common_domains: [
      RealNumbers,
      ComplexNumbers,
      RationalNumbers,
      Integers
    ],

    default_domain:
      RealNumbers,

    rule:
      valid_solution_must_belong_to_declared_domain
  },

  PARAMETER_REASONING: {
    parameterised_system:
      coefficients_or_constants_may_depend_on_parameters,

    objective:
      classify_parameter_values_producing [
        unique_solution,
        no_solution,
        infinitely_many_solutions
      ],

    requirement:
      avoid_illegal_division_by_parameter_that_may_be_zero
  },

  VERIFICATION: {
    INPUT:
      candidate_assignment C,

    PROCESS:
      substitute_C_into_every_original_equation,

    ACCEPT_IF:
      all_equations_true,

    REJECT_IF:
      any_equation_false
  },

  ERROR_DETECTION: {

    SignError:
      incorrect_addition_or_subtraction_during_elimination
      -> flag,

    ScalingError:
      failure_to_scale_every_term
      -> flag,

    BackSubstitutionError:
      derived_second_variable_inconsistent_with_original_system
      -> flag,

    PartialCheckError:
      checking_only_one_equation
      -> reject_verification,

    DivisionByPotentialZero:
      parameter_or_expression_division_without_case_analysis
      -> flag,

    ExtraneousSolution:
      nonlinear_transformation_generated_invalid_candidate
      -> reject
  },

  NATURAL_LANGUAGE_MAPPING: {
    "solve simultaneously":
      find_values_satisfying_all_equations,

    "simultaneous equations":
      system_of_equations_with_shared_variables,

    "find x and y":
      infer_multi_variable_solution_request_when_context_contains_equations,

    "common solution":
      intersection_of_solution_sets
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [
      identify_unknowns,
      assign_variables,
      extract_independent_relations,
      build_multiple_equations,
      classify_system,
      choose_method,
      solve,
      verify_all_relations,
      interpret_in_context
    ],

    requirement:
      each_word_problem_constraint_must_map_to_equation_or_domain_rule
  },

  GEOMETRIC_SEMANTICS: {
    linear_2D:
      simultaneous_solution = intersection_of_lines,

    linear_3D:
      simultaneous_solution = common_intersection_of_planes,

    nonlinear:
      simultaneous_solution = common_intersection_of_curves_or_surfaces
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "SimultaneousEquations IS_A SystemOfEquations",
      "LinearSimultaneousEquations IS_A SimultaneousEquations",
      "NonlinearSimultaneousEquations IS_A SimultaneousEquations"
    ],

    RELATED_TO: [
      "SimultaneousEquations RELATED_TO LinearAlgebra",
      "SimultaneousEquations RELATED_TO MatrixEquation",
      "SimultaneousEquations RELATED_TO CoordinateGeometry",
      "SimultaneousEquations RELATED_TO ConstraintSatisfaction",
      "SimultaneousEquations RELATED_TO Intersection"
    ],

    DEPENDS_ON: [
      EquationSemantics,
      VariableBinding,
      LogicalConjunction,
      Domain,
      Equality
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    equivalent_systems:
      SolutionSet(S1)=SolutionSet(S2),

    linear_row_equivalence:
      implies_equal_solution_sets,

    caution:
      syntactic_difference_does_not_imply_semantic_difference
  },

  CONFIDENCE: {
    classification_confidence:
      IF all_equations_and_variables_parsed_successfully THEN 1.0,

    solution_confidence:
      IF candidate_verified_against_every_original_equation THEN 1.0,

    method_confidence:
      based_on [
        linearity_detection,
        coefficient_structure,
        domain_consistency,
        transformation_validity
      ]
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_simultaneous_equations,
      extract_equations,
      identify_shared_variables,
      classify_linear_or_nonlinear,
      select_substitution_or_elimination,
      scale_equations,
      eliminate_variables,
      back_substitute,
      build_matrix_representation,
      determine_consistency,
      verify_solutions,
      explain_graphical_intersection,
      detect_reasoning_errors,
      link_system_of_equations_ontology
    ],

    preferred_representation:
      conjunction_constraint_graph,

    reasoning_mode:
      recursive_multi_constraint_reduction
  },

  RECURSIVE_REASONING: {

    FUNCTION SolveSimultaneousEquations(S,Domain):

      parsed := ParseEquationSet(S)

      IF EquationCount(parsed)<2:
        RETURN RedirectToEquationOntology

      variables := ExtractSharedVariables(parsed)
      normalised := NormaliseEquations(parsed)

      IF AllLinear(normalised):
        representation := BuildLinearSystem(normalised,variables)
        classification := AnalyseConsistency(representation)

        IF classification=NoSolution:
          RETURN EmptySet

        IF classification=UniqueSolution:
          candidate := SolveLinearSystem(representation)
          RETURN Verify(candidate,S,Domain)

        IF classification=InfiniteSolutions:
          general_solution := ProduceParametricSolution(representation)
          RETURN VerifyParametricSolution(general_solution,S,Domain)

      ELSE:
        strategy := SelectNonlinearStrategy(normalised)
        candidates := SolveNonlinearSystem(normalised,strategy,Domain)
        verified := VerifyAll(candidates,S,Domain)
        RETURN verified
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      every_emitted_solution_satisfies_every_original_equation=TRUE,

    invariant_2:
      elimination_and_substitution_preserve_common_solution_set=TRUE,

    invariant_3:
      graphical_intersections_match_algebraic_solutions=TRUE,

    invariant_4:
      matrix_representation_matches_original_linear_system=TRUE,

    invariant_5:
      consistency_classification_matches_solution_set_cardinality=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      simultaneous_solution_definition,
      classification_model,
      substitution_rules,
      elimination_rules,
      consistency_rules,
      verification_rules
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      simultaneous_satisfaction,
      shared_solution_set_intersection,
      valid_elimination_semantics,
      valid_substitution_semantics,
      full_original_system_verification
    ],

    revision_triggers: [
      semantic_conflict,
      SystemOfEquationsOntology_update,
      new_solution_method,
      new_representation_model
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      SimultaneousEquations,
      SystemOfEquations,
      Equation,
      SharedVariable,
      Constraint,
      SolutionSet,
      Substitution,
      Elimination,
      MatrixEquation,
      Intersection
    ],

    edges: [
      SimultaneousEquations -> IS_A -> SystemOfEquations,
      SimultaneousEquations -> CONTAINS -> Equation,
      Equation -> SHARES -> SharedVariable,
      SimultaneousEquations -> HAS_SOLUTION_SET -> SolutionSet,
      SolutionSet -> IS_INTERSECTION_OF -> EquationSolutionSets,
      SimultaneousEquations -> SOLVED_BY -> Substitution,
      SimultaneousEquations -> SOLVED_BY -> Elimination,
      LinearSimultaneousEquations -> REPRESENTABLE_AS -> MatrixEquation,
      GraphicalSolution -> REPRESENTS -> Intersection
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    SystemOfEquationsOntology:
      direct_parent,

    EquationOntology:
      component_equations,

    LinearEquationOntology:
      linear_components,

    PolynomialEquationOntology:
      polynomial_nonlinear_components,

    MatrixOntology:
      linear_representation,

    LinearAlgebraOntology:
      elimination_rank_and_matrix_methods,

    CoordinateGeometryOntology:
      intersection_interpretation,

    ConstraintSatisfactionOntology:
      simultaneous_constraint_semantics
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      simultaneous_equation_definition_defined,
      shared_variable_semantics_defined,
      classification_defined,
      substitution_method_defined,
      elimination_method_defined,
      consistency_rules_defined,
      verification_defined,
      graphical_semantics_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Simultaneous_Equations_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyEquationSet
    -> ExtractSharedVariables
    -> ResolveDomain
    -> NormaliseEquations
    -> ClassifyLinearOrNonlinear
    -> AnalyseConstraintStructure
    -> SelectSolutionMethod
    -> SubstituteOrEliminate
    -> SolveReducedSystem
    -> BackSubstitute
    -> VerifyAgainstEveryOriginalEquation
    -> ClassifySolutionSet
    -> DeriveGeometricOrMatrixSemantics
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    equations,
    shared_variables,
    domain,
    solving_method,
    transformations,
    consistency,
    solution_type,
    solution_set,
    matrix_representation,
    graphical_semantics,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Simultaneous_Equations_Ontology_v1.0