System of Equations Ontology

FLOW System_Of_Equations_Ontology_v1.0

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

DEFINE SystemOfEquationsOntology := {

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

  DEFINITION: {
    meaning:
      "A collection of two or more equations considered simultaneously, where a solution must satisfy every equation in the collection.",
    generic_form:
      {
        E_1(x_1,...,x_n)=0,
        E_2(x_1,...,x_n)=0,
        ...,
        E_m(x_1,...,x_n)=0
      },
    number_of_equations: m,
    number_of_variables: n
  },

  SEMANTIC_PRIMITIVES: {
    Equation: mathematical_equality_relation,
    Variable: symbolic_unknown_or_parameter,
    Constraint: condition_imposed_by_an_equation,
    CandidateSolution: assignment_of_values_to_all_required_variables,
    Solution:
      candidate_assignment_satisfying_every_equation,
    SolutionSet:
      intersection_of_individual_equation_solution_sets,
    Consistency:
      existence_or_nonexistence_of_common_solution
  },

  CORE_SEMANTICS: {
    SystemSolutionSet:
      SolutionSet(E_1) INTERSECTION
      SolutionSet(E_2) INTERSECTION
      ...
      INTERSECTION SolutionSet(E_m),

    satisfaction_condition:
      FOR_EACH equation E_i:
        E_i(candidate_assignment)=TRUE
  },

  STRUCTURAL_MODEL: {
    equations: [E_1,...,E_m],
    variables: [x_1,...,x_n],
    shared_variable_space: TRUE,
    equation_count: m,
    variable_count: n,
    domain:
      inherited_from_context_or_declared_system_domain
  },

  CLASSIFICATION: {

    LinearSystem: {
      condition:
        every_equation_is_linear_in_all_system_variables = TRUE
    },

    NonlinearSystem: {
      condition:
        at_least_one_equation_is_nonlinear = TRUE
    },

    HomogeneousLinearSystem: {
      matrix_form: A*x = 0
    },

    NonHomogeneousLinearSystem: {
      matrix_form: A*x = b,
      condition: b != 0_vector
    },

    SquareSystem: {
      condition: m=n
    },

    OverdeterminedSystem: {
      condition: m>n
    },

    UnderdeterminedSystem: {
      condition: m<n
    },

    ConsistentSystem: {
      condition: SolutionSet != EmptySet
    },

    InconsistentSystem: {
      condition: SolutionSet = EmptySet
    },

    IndependentLinearSystem: {
      condition:
        unique_solution_exists
    },

    DependentLinearSystem: {
      condition:
        infinitely_many_solutions_due_to_equation_dependency
    }
  },

  LINEAR_CANONICAL_FORM: {
    system:
      A*x = b,

    A:
      coefficient_matrix,

    x:
      variable_vector,

    b:
      constant_vector,

    dimensions:
      A is m_by_n,
      x is n_by_1,
      b is m_by_1
  },

  AUGMENTED_MATRIX_MODEL: {
    representation:
      [A | b],

    purpose:
      encode_linear_system_for_row_operations,

    equivalence:
      elementary_row_operations_preserve_solution_set
  },

  ELEMENTARY_ROW_OPERATIONS: {

    RowSwap:
      R_i <-> R_j,

    RowScaling:
      R_i -> k*R_i
      WHERE k != 0,

    RowReplacement:
      R_i -> R_i + k*R_j,

    invariant:
      linear_system_solution_set_preserved = TRUE
  },

  ROW_ECHELON_FORMS: {

    RowEchelonForm: {
      conditions: [
        all_zero_rows_at_bottom,
        leading_entry_of_lower_row_is_right_of_leading_entry_above,
        entries_below_each_pivot_are_zero
      ]
    },

    ReducedRowEchelonForm: {
      conditions: [
        satisfies_RowEchelonForm,
        every_pivot_equals_1,
        each_pivot_is_only_nonzero_entry_in_its_column
      ]
    }
  },

  SOLUTION_CLASSIFICATION_LINEAR: {

    UniqueSolution: {
      condition:
        rank(A)=rank([A|b])=n
    },

    InfiniteSolutions: {
      condition:
        rank(A)=rank([A|b])<n
    },

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

  RANK_MODEL: {
    coefficient_rank:
      rank(A),

    augmented_rank:
      rank([A|b]),

    Rouché_Capelli_semantics:
      system_is_consistent
      <=> rank(A)=rank([A|b])
  },

  SUBSTITUTION_METHOD: {
    INPUT:
      system_of_equations,

    PROCESS: [
      select_equation,
      isolate_one_variable_or_expression,
      substitute_into_remaining_equations,
      reduce_variable_count,
      recursively_solve_reduced_system,
      back_substitute,
      verify_complete_assignment
    ],

    invariant:
      substitutions_must_preserve_equivalence
  },

  ELIMINATION_METHOD: {
    INPUT:
      system_of_equations,

    PROCESS: [
      select_target_variable,
      scale_equations_if_required,
      add_or_subtract_equations,
      eliminate_target_variable,
      solve_reduced_system,
      back_substitute,
      verify
    ],

    relation_to_matrix_method:
      algebraic_equivalent_of_row_reduction
  },

  GRAPHICAL_METHOD: {
    interpretation:
      solutions_are_common_intersections_of_all_equation_graphs,

    two_equation_2D_linear_cases: {
      one_intersection:
        unique_solution,

      parallel_distinct_lines:
        no_solution,

      coincident_lines:
        infinitely_many_solutions
    }
  },

  TWO_VARIABLE_LINEAR_SYSTEM: {
    canonical_form:
      {
        a_1*x + b_1*y = c_1,
        a_2*x + b_2*y = c_2
      },

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

    IF D != 0:
      unique_solution = TRUE,

    IF D = 0:
      require_dependency_or_inconsistency_analysis
  },

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

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

    limitation:
      not_preferred_for_large_systems
  },

  INVERSE_MATRIX_METHOD: {
    applicability:
      square_system AND A_is_invertible,

    equation:
      A*x=b,

    solution:
      x=A^(-1)*b
  },

  HOMOGENEOUS_SYSTEM: {
    form:
      A*x=0,

    trivial_solution:
      x=0_vector,

    nontrivial_solution_exists_if:
      rank(A)<n,

    square_case:
      det(A)=0
      implies_possible_nontrivial_solutions
  },

  NULL_SPACE_RELATION: {
    homogeneous_solution_set:
      Null(A),

    dimension:
      nullity(A)=n-rank(A),

    semantic_relation:
      homogeneous_system_solution_space_is_vector_space
  },

  AFFINE_SOLUTION_RELATION: {
    nonhomogeneous_consistent_system:
      solution_set = particular_solution + Null(A),

    semantic_type:
      affine_subspace
  },

  PARAMETRIC_SOLUTIONS: {
    free_variables:
      variables_without_pivots,

    basic_variables:
      variables_associated_with_pivots,

    general_solution:
      express_basic_variables_in_terms_of_free_parameters
  },

  OVERDETERMINED_REASONING: {
    condition:
      m>n,

    possibilities: [
      inconsistent_system,
      unique_solution_if_constraints_compatible_and_rank_sufficient,
      redundant_equations
    ],

    rule:
      equation_count_alone_does_not_determine_consistency
  },

  UNDERDETERMINED_REASONING: {
    condition:
      m<n,

    linear_consistent_case:
      generally_has_free_variables,

    unique_solution:
      impossible_for_linear_system_when_rank<n
  },

  NONLINEAR_SYSTEM_SEMANTICS: {
    equations:
      may_include_polynomial_rational_radical_transcendental_relations,

    solution_set:
      common_intersections_in_shared_domain,

    solving_methods: [
      substitution,
      elimination,
      algebraic_factorisation,
      Gröbner_basis_methods,
      resultant_methods,
      numerical_iteration,
      geometric_intersection
    ]
  },

  POLYNOMIAL_SYSTEM_RELATION: {
    condition:
      every_equation_is_polynomial,

    related_ontology:
      PolynomialEquationOntology,

    algebraic_geometry_relation:
      common_zero_set_of_polynomials
  },

  CONSTRAINT_INTERSECTION_MODEL: {
    each_equation:
      defines_constraint_set_S_i,

    system_solution_set:
      INTERSECTION[i=1..m](S_i),

    empty_intersection:
      inconsistent_system,

    nonempty_intersection:
      consistent_system
  },

  VARIABLE_DEPENDENCY_GRAPH: {
    nodes:
      variables_and_equations,

    edges:
      variable_occurs_in_equation,

    purpose: [
      detect_decomposable_subsystems,
      identify_sparse_structure,
      guide_elimination_order,
      improve_recursive_solving
    ]
  },

  DECOMPOSITION: {
    IF dependency_graph_has_disconnected_components:
      split_into_independent_subsystems,

    solve:
      each_subsystem_separately,

    combine:
      cartesian_product_of_compatible_subsystem_solutions
  },

  TRANSFORMATION_GRAPH: {
    nodes: [
      OriginalSystem,
      NormalisedSystem,
      MatrixRepresentation,
      RowReducedSystem,
      ReducedSubsystem,
      ParametricRepresentation,
      CandidateSolutionSet,
      VerifiedSolutionSet
    ],

    edges: [
      normalise,
      substitute,
      eliminate,
      row_swap,
      row_scale,
      row_replace,
      factor,
      decompose,
      back_substitute,
      verify
    ],

    invariant:
      valid_transformations_preserve_system_solution_set
  },

  EQUIVALENCE_RULES: {
    equation_replacement:
      MAY_replace_equation_with_equivalent_equation,

    linear_combination:
      MAY_replace_equation_by_nonzero_equivalent_linear_combination
      WHEN system_equivalence_preserved,

    row_operations:
      preserve_linear_system_solution_set,

    warning:
      nonlinear_transformations_may_introduce_or_remove_solutions
  },

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

    default_for_continuous_algebra:
      RealNumbers,

    rule:
      system_solution_set_depends_on_declared_domain
  },

  VERIFICATION: {
    INPUT:
      candidate_assignment C,

    PROCESS:
      substitute_C_into_every_original_equation,

    ACCEPT_IF:
      every_equation_evaluates_true,

    REJECT_IF:
      any_equation_evaluates_false
  },

  ERROR_DETECTION: {

    PartialVerificationError:
      candidate_checked_against_only_some_equations
      -> reject,

    LostSolutionError:
      invalid_division_by_expression_that_may_be_zero
      -> flag,

    ExtraneousSolutionError:
      nonlinear_transformation_generated_invalid_candidate
      -> remove_after_verification,

    RowOperationError:
      invalid_or_incomplete_row_operation
      -> flag,

    VariableMismatch:
      omitted_or_unbound_system_variable
      -> flag,

    InconsistentDomain:
      candidate_outside_declared_domain
      -> reject
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT_LINEAR: [
      "{x+y=5, x-y=1}",
      "{2x+3y=7, x-y=4}",
      "{x+y+z=6, 2x-y+z=3, x+2z=5}"
    ],

    ACCEPT_NONLINEAR: [
      "{x^2+y^2=25, y=x+1}",
      "{xy=6, x+y=5}"
    ],

    REDIRECT_SINGLE_EQUATION:
      equation_count=1 -> EquationOntology
  },

  NATURAL_LANGUAGE_MAPPING: {
    "simultaneously satisfy":
      require_all_equations_true,

    "solve the system":
      compute_common_solution_set,

    "intersection of equations":
      common_graph_points_or_constraint_assignments,

    "simultaneous equations":
      SystemOfEquations
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [
      identify_unknown_quantities,
      assign_variables,
      extract_multiple_constraints,
      construct_equations,
      form_system,
      classify_system,
      choose_solution_method,
      solve,
      verify_all_constraints,
      interpret_solution
    ],

    rule:
      every_context_constraint_must_be_respected
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "LinearSystem IS_A SystemOfEquations",
      "NonlinearSystem IS_A SystemOfEquations",
      "HomogeneousLinearSystem IS_A LinearSystem"
    ],

    RELATED_TO: [
      "SystemOfEquations RELATED_TO MatrixEquation",
      "SystemOfEquations RELATED_TO LinearAlgebra",
      "SystemOfEquations RELATED_TO ConstraintSatisfaction",
      "SystemOfEquations RELATED_TO CoordinateGeometry",
      "SystemOfEquations RELATED_TO AlgebraicGeometry",
      "SystemOfEquations RELATED_TO Optimisation"
    ],

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

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

    solution:
      assignment_satisfying_conjunction,

    inconsistency:
      conjunction_is_unsatisfiable
  },

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

    row_equivalent_linear_systems:
      semantically_equivalent = TRUE,

    caution:
      same_equation_count_or_same_rank_does_not_necessarily_imply_equivalence
  },

  CONFIDENCE: {
    classification_confidence:
      based_on [
        equation_type_detection,
        variable_detection,
        domain_resolution,
        matrix_structure_validation
      ],

    solution_confidence:
      IF all_candidates_verified_against_all_original_equations
      THEN 1.0,

    consistency_confidence_linear:
      IF rank_analysis_valid
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_system_of_equations,
      extract_equations,
      extract_variables,
      classify_linear_or_nonlinear,
      build_coefficient_matrix,
      build_augmented_matrix,
      compute_rank,
      determine_consistency,
      select_solving_method,
      perform_substitution,
      perform_elimination,
      row_reduce,
      produce_parametric_solution,
      verify_candidates,
      detect_dependency,
      decompose_sparse_system,
      explain_geometric_meaning,
      detect_reasoning_errors,
      link_related_ontologies
    ],

    representation:
      constraint_graph_plus_symbolic_matrix_model,

    reasoning_mode:
      recursive_constraint_intersection_and_reduction
  },

  RECURSIVE_REASONING: {

    FUNCTION SolveSystem(S,Domain):

      parsed := ParseSystem(S)

      IF EquationCount(parsed)=1:
        RETURN RedirectToEquationOntology

      variables := ExtractVariables(parsed)
      normalised := NormaliseAllEquations(parsed)

      IF AllEquationsLinear(normalised):
        A,b := BuildLinearRepresentation(normalised,variables)
        rankA := Rank(A)
        rankAug := Rank([A|b])

        IF rankA != rankAug:
          RETURN EmptySet

        IF rankA = NumberOfVariables:
          candidate := SolveUniqueLinearSystem(A,b)
          RETURN Verify(candidate,S,Domain)

        ELSE:
          parametric := BuildParametricSolution(A,b)
          RETURN VerifyParametricSolution(parametric,S,Domain)

      ELSE:
        decomposed := DecomposeIfPossible(normalised)

        IF decomposed:
          partial_solutions := RecursiveSolveEach(decomposed,Domain)
          candidates := CombineCompatibleSolutions(partial_solutions)
        ELSE:
          candidates := SolveNonlinearSystem(normalised,Domain)

        verified := VerifyAllCandidatesAgainstAllEquations(candidates,S,Domain)

        RETURN verified
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      every_solution_satisfies_every_original_equation = TRUE,

    invariant_2:
      valid_linear_row_operations_preserve_solution_set = TRUE,

    invariant_3:
      rank_based_classification_matches_row_reduced_form = TRUE,

    invariant_4:
      matrix_and_equation_representations_are_semantically_equivalent = TRUE,

    invariant_5:
      decomposition_and_recombination_preserve_global_solution_set = TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      system_definition,
      classification_model,
      matrix_semantics,
      solving_rules,
      consistency_rules,
      verification_rules
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      simultaneous_satisfaction_requirement,
      solution_set_intersection_semantics,
      rank_consistency_rule_for_linear_systems,
      row_operation_equivalence,
      full_solution_verification
    ],

    revision_triggers: [
      semantic_conflict,
      parent_ontology_update,
      new_system_classification,
      new_solver_representation,
      matrix_semantics_revision
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      SystemOfEquations,
      Equation,
      Variable,
      Constraint,
      SolutionSet,
      LinearSystem,
      NonlinearSystem,
      MatrixEquation,
      CoefficientMatrix,
      AugmentedMatrix,
      Rank,
      NullSpace,
      Intersection
    ],

    edges: [
      SystemOfEquations -> CONTAINS -> Equation,
      Equation -> CONSTRAINS -> Variable,
      SystemOfEquations -> HAS_SOLUTION_SET -> SolutionSet,
      SolutionSet -> IS_INTERSECTION_OF -> EquationSolutionSets,
      LinearSystem -> REPRESENTABLE_AS -> MatrixEquation,
      MatrixEquation -> HAS_COEFFICIENT_MATRIX -> CoefficientMatrix,
      LinearSystem -> HAS_AUGMENTED_MATRIX -> AugmentedMatrix,
      Consistency -> DEPENDS_ON -> Rank,
      HomogeneousLinearSystem -> HAS_SOLUTION_SPACE -> NullSpace
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    EquationOntology:
      parent,

    LinearEquationOntology:
      linear_component_equations,

    PolynomialEquationOntology:
      polynomial_system_components,

    MatrixOntology:
      linear_system_representation,

    VectorOntology:
      variable_and_constant_vectors,

    LinearAlgebraOntology:
      rank_null_space_row_reduction,

    CoordinateGeometryOntology:
      intersection_semantics,

    ConstraintSatisfactionOntology:
      conjunction_of_constraints,

    AlgebraicGeometryOntology:
      polynomial_system_zero_sets
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      system_defined,
      simultaneous_solution_semantics_defined,
      linear_and_nonlinear_classification_defined,
      matrix_model_defined,
      solving_methods_defined,
      consistency_rules_defined,
      verification_defined,
      graph_and_constraint_relations_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE System_Of_Equations_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifySystem
    -> ExtractEquations
    -> ExtractVariables
    -> ResolveDomain
    -> NormaliseEquations
    -> ClassifyLinearOrNonlinear
    -> BuildConstraintModel
    -> SelectSolvingStrategy
    -> ReduceOrDecompose
    -> Solve
    -> VerifyAgainstAllOriginalEquations
    -> ClassifyConsistency
    -> DeriveMatrixOrGeometricSemantics
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    system_type,
    equation_count,
    variable_count,
    equations,
    variables,
    domain,
    matrix_representation,
    consistency,
    rank_information,
    solution_type,
    solution_set,
    parametric_form,
    transformations,
    verification,
    geometric_semantics,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW System_Of_Equations_Ontology_v1.0