System of Equations Ontology

FLOW ALGEBRA
SYSTEM OF EQUATIONS ONTOLOGY
Kireth Semantic Library | Mathematical Entities | Equation and Statement Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/equation-and-statement-entities/system-of-equations-ontology-2.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-13 | Locale: en-GB
Status: Domain-grounded draft; source webpage content not independently verified.

01. PURPOSE
flow "SystemOfEquationsOntology" v1.0
  intent: represent, classify, validate, transform and solve simultaneous mathematical equations
  scope: exact and approximate systems; linear and nonlinear systems; symbolic and numerical reasoning
  distinction: a system requires all constituent equations to hold under one shared assignment

02. CORE TYPES
  type ScalarDomain = Real | Complex | Rational | Integer | FiniteField | SymbolicDomain
  type Variable = {id: Identifier, domain: ScalarDomain, assumptions: Set[Predicate]}
  type Expression = Literal | VariableRef | OperatorApplication | FunctionApplication
  type Equation = {lhs: -Expression, rhs: -Expression, domain: DomainConstraints}
  type System = {equations: List[Equation], variables: List[Variable], assumptions: Set[Predicate]}
  type Assignment = Map[Variable, Value]
  type SolutionSet = Set[Assignment] | ParametricSet | ImplicitSet | EmptySet
  type Result = {solution: SolutionSet, status: Status, evidence: Evidence}
  enum Status = Verified | Conditional | Approximate | Inconsistent | Underdetermined | Unknown

03. FORMAL SEMANTICS
  satisfies(a, e) := defined(eval(e.lhs,a)) AND defined(eval(e.rhs,a)) AND eval(e.lhs,a) = eval(e.rhs,a)
  satisfies(a, S) := satisfies_assumptions(a,S) AND forall e in S.equations: satisfies(a,e)
  solutions(S) := {a in admissible_assignments(S.variables) | satisfies(a,S)}
  equivalent(S1,S2) := same_variable_universe(S1,S2) AND solutions(S1) = solutions(S2)
  consequence(S,e) := forall a in solutions(S): satisfies(a,e)
  note: equivalence requires identical domains, assumptions and definedness conditions

04. SYSTEM CLASSIFICATION
  linear_system(S) := every equation is affine in the designated unknowns
  nonlinear_system(S) := exists equation not affine in designated unknowns
  homogeneous_linear(S) := linear_system(S) AND all constant terms = 0
  square_system(S) := number_of_equations(S) = number_of_variables(S)
  overdetermined(S) := number_of_equations(S) > number_of_variables(S)
  underdetermined_by_count(S) := number_of_equations(S) < number_of_variables(S)
  note: equation count alone does not determine consistency or uniqueness
  consistent(S) := solutions(S) != EmptySet
  inconsistent(S) := solutions(S) = EmptySet
  unique(S) := cardinality(solutions(S)) = 1
  multiple(S) := cardinality(solutions(S)) > 1

05. LINEAR NORMAL FORM
  linear_form(S) := A*x = b over a specified field F
  A: Matrix[F,m,n]
  x: Vector[F,n]
  b: Vector[F,m]
  row_equivalence: invertible elementary row operations preserve solution set
  consistency_test: rank(A) = rank([A|b])
  unique_solution_test: consistent AND rank(A) = n
  free_variable_count: n - rank(A) for consistent systems over F
  homogeneous_solution_space: nullspace(A)
  general_consistent_solution: x = x_particular + nullspace(A)
  square_invertible_case: det(A) != 0 implies x = inverse(A)*b

06. LINEAR SOLUTION METHODS
  GaussianElimination: row-reduce augmented matrix and back-substitute
  GaussJordan: reduce augmented matrix to reduced row echelon form
  MatrixFactorisation: LU, QR or other suitable factorisation under stated conditions
  CramersRule: applicable to square systems with nonzero determinant over a field
  IterativeMethod: convergence must be established or checked under appropriate assumptions
  NumericalLeastSquares: minimises residual; not necessarily an exact solution

07. NONLINEAR SYSTEMS
  forms: polynomial, transcendental, differential-algebraic, mixed symbolic systems
  methods: substitution, elimination, resultants, Groebner bases, interval methods, root finding
  numerical_methods: Newton-type, trust-region, continuation, certified interval algorithms
  cautions: local convergence, multiple roots, singular Jacobians, extraneous candidates
  exact_candidate_validation: substitute candidate into every original equation
  domain_validation: check denominators, radicals, logarithms and branch choices

08. TRANSFORMATION RULES
  rule SwapEquations: reorder equations -> preserves solutions
  rule AddRedundantConsequence: add a logically entailed equation -> preserves solutions
  rule ReplaceByReversibleCombination: replace equations via invertible combination -> preserves solutions
  rule SubstituteEquivalentExpression: rewrite under proven identity and preserved domain -> preserves solutions
  rule MultiplyEquationByNonzero: multiply both sides by known nonzero expression -> preserves solutions
  rule DivideEquation: allowed only with proven nonzero divisor on admissible domain
  rule SquareBothSides: candidate-generating unless reverse implication established
  rule CancelFactor: may discard solutions where factor is zero; branch on factor-zero case
  rule EliminateVariable: preserve projected solution semantics and reconstruction constraints

09. SOLUTION REPRESENTATIONS
  exact: rational numbers, algebraic numbers, symbolic radicals and certified expressions
  parametric: free parameters with domains and mapping to unknown variables
  implicit: constraints defining solution manifold or algebraic variety
  approximate: numerical coordinates with tolerances, residuals and method metadata
  interval_enclosure: certified bounds where proof conditions are met
  no_solution: explicit inconsistency certificate when available
  undecided: do not infer unsatisfiability from a solver timeout

10. KNOWLEDGE GRAPH ENTITIES
  nodes: SystemOfEquations, Equation, Variable, Expression, CoefficientMatrix
  nodes: AugmentedMatrix, Constraint, Domain, Assignment, SolutionSet, Solver
  nodes: Transformation, Proof, Residual, Assumption, VerificationRecord
  relations:
    SystemOfEquations --containsEquation--> Equation
    SystemOfEquations --hasUnknown--> Variable
    Equation --hasLeftExpression--> Expression
    Equation --hasRightExpression--> Expression
    SystemOfEquations --hasDomainConstraint--> Constraint
    SystemOfEquations --hasSolutionSet--> SolutionSet
    Solver --solves--> SystemOfEquations
    Transformation --preservesSolutionsOf--> SystemOfEquations
    VerificationRecord --validates--> Assignment

11. SEMANTIC EQUIVALENCE
  alpha_rename: consistent renaming of bound or designated variables with correspondence
  equation_order: permutation does not change conjunction semantics
  row_operations: invertible row operations preserve linear-system solutions
  symbolic_rewrite: require valid identities and domain preservation
  normalisation: canonical variable order, expression trees and constraint sets
  structural_similarity != mathematical_equivalence

12. INFERENCE RULES
  IF rank(A) < rank([A|b]) THEN linear_system_inconsistent
  IF rank(A) = rank([A|b]) = n THEN unique_linear_solution
  IF rank(A) = rank([A|b]) < n THEN infinitely_many_linear_solutions_over_infinite_field
  IF det(A) != 0 for square A THEN unique_solution_for_each_b
  IF verified_assignment(a,S) THEN a belongs_to solutions(S)
  IF equations_imply(0 = nonzero_constant) THEN inconsistent(S)
  IF nonlinear_solver_returns_candidate THEN require_original_equation_validation

13. EXAMPLE: UNIQUE SOLUTION
  system:
    x + y = 5
    x - y = 1
  eliminate: 2*x = 6
  derive: x = 3; y = 2
  verify: 3 + 2 = 5 AND 3 - 2 = 1
  result: Verified({x:3,y:2})

14. EXAMPLE: INCONSISTENT SYSTEM
  system:
    x + y = 2
    x + y = 3
  subtract: 0 = 1
  result: Inconsistent(EmptySet)

15. EXAMPLE: PARAMETRIC SYSTEM
  system:
    x + y = 4
    2*x + 2*y = 8
  parameter: t in Real
  solution: {x:4-t, y:t}
  result: consistent, infinitely many solutions over Real

16. VALIDATION
  validate_system:
    - all variable references resolve
    - domains and assumptions are explicit
    - operations are defined on candidate values
    - equations have compatible types and dimensions
    - transformations preserve or document changes in solution set
    - every claimed solution satisfies all original equations
    - exact and approximate statuses are distinguished
    - numerical tolerances and precision are recorded
    - contradictions and unresolved cases are not silently discarded

17. CONFIDENCE
  confidence.kind: proof_status | numerical_estimate | source_reliability
  proof_status: formal_proof | checked_derivation | numerical_evidence | unverified
  exact_claim: requires symbolic proof or exhaustive certified verification
  numerical_claim: include residual_norm, error_bound_if_known, conditioning, tolerance
  warning: small residual alone does not prove closeness to a true solution

18. FLOW_HASH
  canonicalise:
    - normalise identifiers with namespace and domain
    - serialise equations and assumptions in deterministic order
    - preserve distinctions between exact and approximate values
    - record variable ordering and algebraic domain
  FLOW_HASH := SHA256(canonical_serialisation(system, ruleset_version))
  note: hash identifies canonical representation; it does not itself prove equivalence

19. UPDATE_MODEL
  on_change(equation | variable | assumption | domain):
    invalidate dependent solutions, certificates and derived graph edges
    rerun parsing, typing, satisfiability and verification
    recompute canonical representation and FLOW_HASH
    preserve previous versions and provenance
  version_policy: immutable source snapshot plus traceable revisions

20. AI_CONSUMPTION
  inputs: natural_language_problem | symbolic_system | structured_graph
  pipeline:
    parse -> identify_unknowns -> type_check -> normalise -> classify
    -> select_method -> derive_candidates -> validate -> explain -> emit_graph
  outputs: typed solution set, proof/verification status, assumptions, provenance
  safeguards:
    - distinguish solving from approximate optimisation
    - never invent exact solutions from floating-point evidence
    - preserve domain restrictions through simplification
    - report ambiguity and underdetermination explicitly

21. CROSS-ONTOLOGY LINKS
  parent: Equation and Statement Entities
  related: Equation Ontology, Equality Ontology, Constraint Ontology
  related: Variable Ontology, Matrix Ontology, Linear Algebra Ontology
  related: Polynomial Ontology, Mathematical Statement Ontology
  related: Numerical Analysis Ontology, Mathematical Proof Ontology

22. PROVENANCE AND AUTHORSHIP
  source_page: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/equation-and-statement-entities/system-of-equations-ontology-2.html
  scientific_basis: standard algebra, linear algebra, logic and numerical analysis
  source_verification: webpage content not independently checked
  authors: Mark Higgins — Sky (Recursive AI)
  project: Kireth Research Semantic Library
  site: https://kirethresearch.org

END FLOW ALGEBRA