Matrix Decomposition Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Matrix Decomposition Ontology 2 within the Kireth Research Semantic Library. Matrix decomposition studies factorisations that express a matrix as products or structured combinations of simpler matrices. This ontology supports LU, LDU, QR, Cholesky, LDLT, Schur, Hessenberg, tridiagonal, eigenvalue, singular-value, polar and rank-revealing decompositions, together with conditioning, stability, sparse and dense factorisation, low-rank structure, iterative use, numerical verification and scalable computation.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Matrix Decomposition Ontology 2"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Linear Algebra Computation / Matrix Decomposition"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/linear-algebra-computation/matrix-decomposition-ontology-2.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = MatrixDecomposition
 ENTITY_CLASS = StructuredMatrixFactorisationFramework
 PRIMARY_CONTEXT = LinearAlgebraComputation
 DEFINITION = "Matrix decomposition is the representation of a matrix as a product, sum or structured combination of simpler matrices that expose algebraic or numerical properties useful for computation."
 SYMBOLIC_FORMS = [
  "P*A=L*U",
  "A=Q*R",
  "A=L*L^T",
  "A=U*Sigma*V^T"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for matrix factorisation, structural reduction, stable solution methods, spectral analysis, rank revelation, low-rank approximation and computational reuse."
}

SCOPE {
 INCLUDE = [
  MatrixDecomposition,
  MatrixFactorisation,
  FactorMatrix,
  PermutationMatrix,
  TriangularFactor,
  OrthogonalFactor,
  UnitaryFactor,
  DiagonalFactor,
  BlockFactorisation,
  LUDecomposition,
  LUPDecomposition,
  LDUDecomposition,
  SparseLU,
  QRDecomposition,
  ThinQR,
  FullQR,
  EconomyQR,
  PivotedQR,
  RankRevealingQR,
  RRQR,
  CholeskyDecomposition,
  PivotedCholesky,
  IncompleteCholesky,
  LDLTDecomposition,
  BunchKaufmanFactorisation,
  SchurDecomposition,
  RealSchurDecomposition,
  ComplexSchurDecomposition,
  GeneralisedSchurDecomposition,
  QZDecomposition,
  HessenbergReduction,
  TridiagonalReduction,
  Bidiagonalisation,
  SingularValueDecomposition,
  SVD,
  CompactSVD,
  TruncatedSVD,
  GeneralisedSVD,
  GSVD,
  EigenDecomposition,
  SpectralDecomposition,
  JordanDecomposition,
  PolarDecomposition,
  MatrixSquareRootDecomposition,
  TakagiFactorisation,
  SylvesterDecomposition,
  CURDecomposition,
  InterpolativeDecomposition,
  ID,
  LowRankFactorisation,
  NonnegativeMatrixFactorisation,
  NMF,
  IncompleteLU,
  ILU,
  ILU0,
  ILUT,
  IncompleteFactorisation,
  HouseholderTransformation,
  GivensRotation,
  GramSchmidtProcess,
  ModifiedGramSchmidt,
  GaussianElimination,
  Pivoting,
  PartialPivoting,
  CompletePivoting,
  RookPivoting,
  ColumnPivoting,
  RowPivoting,
  MatrixRank,
  NumericalRank,
  EffectiveRank,
  RankDeficiency,
  NullSpace,
  ColumnSpace,
  RowSpace,
  Range,
  Kernel,
  SingularValue,
  Eigenvalue,
  ConditionNumber,
  Conditioning,
  PerturbationAnalysis,
  Residual,
  ReconstructionError,
  FactorisationError,
  OrthogonalityError,
  BackwardError,
  ForwardError,
  NumericalStability,
  BackwardStability,
  RoundOffError,
  FloatingPointArithmetic,
  MachinePrecision,
  Scaling,
  Equilibration,
  DenseFactorisation,
  SparseFactorisation,
  FillIn,
  Reordering,
  SymbolicFactorisation,
  NumericFactorisation,
  BlockedFactorisation,
  TiledFactorisation,
  ParallelFactorisation,
  DistributedFactorisation,
  GPUFactorisation,
  MixedPrecisionFactorisation,
  IterativeRefinement,
  ComputationalComplexity,
  MemoryComplexity,
  CommunicationCost,
  Verification,
  Benchmarking,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  MatrixMultiplicationWithoutFactorisation,
  AbstractFactorisationWithoutMatrixSemantics,
  TensorDecompositionWithoutMatrixContext,
  PureSymbolicAlgebraWithoutComputationalMatrixFactorisation
 ]
 DISAMBIGUATION_RULE = "When a matrix is expressed as structured factors or reductions to expose solvable, spectral, rank or computational structure, interpret the context as matrix decomposition."
}

CORE_CONCEPTS {
 MatrixDecomposition = "Representation of a matrix using structured component matrices."
 LUDecomposition = "Factorisation into lower and upper triangular factors, often with permutations."
 QRDecomposition = "Factorisation into an orthogonal or unitary factor and an upper triangular factor."
 CholeskyDecomposition = "Factorisation of a suitable positive-definite matrix into triangular factors."
 LDLTDecomposition = "Factorisation of a symmetric or Hermitian matrix into unit triangular and block-diagonal factors."
 SchurDecomposition = "Unitary or orthogonal similarity reduction to triangular or quasi-triangular form."
 SingularValueDecomposition = "Factorisation into left singular vectors, singular values and right singular vectors."
 RankRevealingFactorisation = "Factorisation designed to expose numerical rank and rank deficiency."
 LowRankFactorisation = "Approximate factorisation using factors of reduced dimension."
}

RELATIONS {
 MatrixDecomposition --is_child_of--> LinearAlgebraComputation
 MatrixDecomposition --decomposes--> Matrix
 LUDecomposition --produces--> LowerAndUpperTriangularFactors
 QRDecomposition --produces--> OrthogonalAndTriangularFactors
 CholeskyDecomposition --requires--> PositiveDefiniteMatrix
 LDLTDecomposition --supports--> SymmetricIndefiniteSystems
 SchurDecomposition --supports--> EigenvalueComputation
 HessenbergReduction --precedes--> QRAlgorithm
 TridiagonalReduction --precedes--> SymmetricEigenvalueSolution
 Bidiagonalisation --precedes--> SingularValueComputation
 SVD --reveals--> SingularValues
 RankRevealingQR --reveals--> NumericalRank
 Pivoting --improves--> FactorisationRobustness
 Reordering --can_reduce--> SparseFillIn
 SymbolicFactorisation --precedes--> NumericFactorisation
 IncompleteFactorisation --supports--> Preconditioning
 TruncatedSVD --produces--> LowRankApproximation
 PolarDecomposition --separates--> UnitaryAndPositiveSemidefiniteFactors
 ReconstructionError --measures--> FactorisationAccuracy
 OrthogonalityError --measures--> OrthogonalFactorQuality
}

OPERATORS {
 LU_FACTOR(A) := P*A=L*U
 LDU_FACTOR(A) := P*A=L*D*U
 QR_FACTOR(A) := A=Q*R
 CHOLESKY_FACTOR(A) := A=L*L^T
 LDLT_FACTOR(A) := P^T*A*P=L*D*L^T
 SCHUR_FACTOR(A) := A=Q*T*Q^*
 SVD_FACTOR(A) := A=U*Sigma*V^T
 TRUNCATED_SVD(A,k) := A_k=U_k*Sigma_k*V_k^T
 POLAR_FACTOR(A) := A=U*H
 RECONSTRUCTION_ERROR(A,factors) := ||A-reconstruct(factors)||/||A||
 ORTHOGONALITY_ERROR(Q) := ||Q^T*Q-I||
}

AXIOMS {
 A1 = "A matrix decomposition must specify both the factor structure and the assumptions under which it exists or is unique."
 A2 = "Different decompositions expose different mathematical and computational properties."
 A3 = "Pivoting or permutation may be essential for stable factorisation."
 A4 = "Orthogonal or unitary transformations generally provide strong finite-precision stability."
 A5 = "Rank-revealing decompositions concern numerical rank as well as exact algebraic rank."
 A6 = "Sparse factorisation can create fill-in that changes storage and computational cost."
 A7 = "Incomplete decompositions intentionally trade exact reconstruction for lower cost."
 A8 = "Factorisation results require reconstruction, structural, stability and reproducibility validation."
}

REASONING {
 R1_CONTEXT = identify(matrix_shape,structure,sparsity,rank,precision,target_use)
 R2_STRUCTURE = detect(symmetry,Hermitian_structure,definiteness,triangularity,rank_deficiency)
 R3_PURPOSE = classify(solve,least_squares,eigenvalue,SVD,rank_revelation,preconditioning_or_low_rank_approximation)
 R4_METHOD = select(LU,QR,Cholesky,LDLT,Schur,SVD,polar,RRQR_or_incomplete_factorisation)
 R5_PIVOTING = if_required choose(row,column,complete,rook_or_block_pivoting)
 R6_STABILITY = analyse(orthogonality,growth_factor,conditioning,roundoff_and_backward_error)
 R7_SPARSE = if_sparse choose(ordering,symbolic_analysis_and_fill_reduction)
 R8_SCALE = if_large use(blocked,tiled,parallel,GPU_or_distributed_factorisation)
 R9_APPROXIMATION = if_low_rank_or_incomplete quantify_reconstruction_or_preconditioning_error)
 R10_VALIDATION = check(reconstruction,orthogonality,residuals,rank,reference_results,reproducibility)
}

CONSTRAINTS {
 C1 = "Cholesky factorisation requires appropriate positive-definite structure."
 C2 = "LU without pivoting can be unstable for some nonsingular matrices."
 C3 = "QR factorisation is generally more stable than normal-equation approaches for least squares."
 C4 = "Jordan decomposition can be numerically ill-conditioned and unsuitable for general finite-precision computation."
 C5 = "Sparse factorisation cost can be dominated by fill-in."
 C6 = "Numerical rank depends on tolerance, scaling and arithmetic precision."
 C7 = "Truncated factorisations approximate rather than exactly reconstruct the matrix."
 C8 = "Incomplete factorisations can break down or become ineffective without suitable dropping or pivoting."
 C9 = "Mixed-precision factorisation requires explicit correction and residual evaluation semantics."
 C10 = "Distributed factorisations can become communication-bound."
}

SEMANTIC_EQUIVALENCE {
 "MatrixDecomposition" <=> "MatrixFactorisation"
 "SingularValueDecomposition" <=> "SVD"
 "RankRevealingQR" <=> "RRQR"
 "GeneralisedSVD" <=> "GSVD"
 "GeneralisedSchurDecomposition" <=> "QZDecomposition"
 "InterpolativeDecomposition" <=> "ID"
 "NonnegativeMatrixFactorisation" <=> "NMF"
 "IncompleteLU" <=> "ILU"
}

VALIDATION {
 V1 = "Matrix dimensions and structural assumptions are explicit."
 V2 = "Factorisation existence conditions are checked."
 V3 = "Pivoting and permutations are documented."
 V4 = "Reconstruction error is evaluated."
 V5 = "Orthogonality or unitarity is checked where applicable."
 V6 = "Rank and singular-value tolerances are documented."
 V7 = "Conditioning and backward stability are assessed."
 V8 = "Sparse fill and ordering are measured where relevant."
 V9 = "Approximate or incomplete factorisations report approximation quality."
 V10 = "Factorisation results are reproducible under documented arithmetic and execution settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 MATRIX_DECOMPOSITION_DEFINITION = 0.99
 LU_REASONING = 0.99
 QR_REASONING = 0.99
 CHOLESKY_REASONING = 0.99
 LDLT_REASONING = 0.99
 SCHUR_REASONING = 0.99
 SVD_REASONING = 0.99
 RANK_REVEALING_REASONING = 0.98
 INCOMPLETE_FACTORISATION_REASONING = 0.98
 POLICY = "Reduce confidence when matrix structure, pivoting, numerical-rank tolerance, sparsity ordering, precision or approximation target are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, MatrixDecompositionReasoning,
  MatrixFactorisationReasoning, LUReasoning, LDUReasoning,
  QRReasoning, CholeskyReasoning, LDLTReasoning, SchurReasoning,
  HessenbergReasoning, TridiagonalReasoning, BidiagonalisationReasoning,
  SVDReasoning, EigenDecompositionReasoning, PolarReasoning,
  RankRevealingReasoning, LowRankFactorisationReasoning,
  IncompleteFactorisationReasoning, SparseFactorisationReasoning,
  StabilityReasoning, ReconstructionErrorReasoning,
  KnowledgeGraphConstruction, RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "matrix decomposition" -> MatrixDecomposition
  "matrix factorisation" -> MatrixDecomposition
  "matrix factorization" -> MatrixDecomposition
  "SVD" -> SingularValueDecomposition
  "RRQR" -> RankRevealingQR
  "GSVD" -> GeneralisedSVD
  "QZ decomposition" -> GeneralisedSchurDecomposition
  "NMF" -> NonnegativeMatrixFactorisation
  "ILU" -> IncompleteLU
 }
}

EXECUTION_RULES {
 E1 = "If a matrix is represented through structured factors, activate MatrixDecompositionOntology."
 E2 = "If solving a general square system, consider pivoted LU."
 E3 = "If solving least squares or requiring orthogonalisation, consider QR."
 E4 = "If the matrix is symmetric positive definite, consider Cholesky."
 E5 = "If the matrix is symmetric indefinite, consider pivoted LDLT."
 E6 = "If spectral structure is required, use Schur, Hessenberg, tridiagonal or eigendecomposition reasoning."
 E7 = "If rank, conditioning or low-rank approximation is central, use SVD or rank-revealing factorisation."
 E8 = "If sparse, apply ordering and symbolic factorisation before numeric factorisation where appropriate."
 E9 = "Any decomposition should be validated by reconstruction, structural properties, stability and reproducibility."
}

RECURSION {
 ENTRY = MatrixDecomposition
 EXPAND(MatrixDecomposition) -> [
  MatrixFactorisation, FactorMatrix, PermutationMatrix, TriangularFactor,
  OrthogonalFactor, UnitaryFactor, DiagonalFactor, BlockFactorisation,
  LUDecomposition, LUPDecomposition, LDUDecomposition, SparseLU,
  QRDecomposition, ThinQR, FullQR, EconomyQR, PivotedQR,
  RankRevealingQR, CholeskyDecomposition, PivotedCholesky,
  IncompleteCholesky, LDLTDecomposition, BunchKaufmanFactorisation,
  SchurDecomposition, RealSchurDecomposition, ComplexSchurDecomposition,
  GeneralisedSchurDecomposition, HessenbergReduction,
  TridiagonalReduction, Bidiagonalisation, SingularValueDecomposition,
  CompactSVD, TruncatedSVD, GeneralisedSVD, EigenDecomposition,
  SpectralDecomposition, JordanDecomposition, PolarDecomposition,
  TakagiFactorisation, CURDecomposition, InterpolativeDecomposition,
  LowRankFactorisation, NonnegativeMatrixFactorisation, IncompleteLU,
  ILU0, ILUT, HouseholderTransformation, GivensRotation,
  GramSchmidtProcess, ModifiedGramSchmidt, GaussianElimination,
  Pivoting, MatrixRank, NumericalRank, RankDeficiency, NullSpace,
  ColumnSpace, RowSpace, SingularValue, Eigenvalue, ConditionNumber,
  Conditioning, PerturbationAnalysis, Residual, ReconstructionError,
  FactorisationError, OrthogonalityError, BackwardError, ForwardError,
  NumericalStability, RoundOffError, FloatingPointArithmetic,
  MachinePrecision, Scaling, Equilibration, DenseFactorisation,
  SparseFactorisation, FillIn, Reordering, SymbolicFactorisation,
  NumericFactorisation, BlockedFactorisation, TiledFactorisation,
  ParallelFactorisation, DistributedFactorisation, GPUFactorisation,
  MixedPrecisionFactorisation, IterativeRefinement,
  ComputationalComplexity, MemoryComplexity, CommunicationCost,
  Verification, Benchmarking, Reproducibility
 ]
 EXPAND(DecompositionFamilies) -> [
  TriangularFactorisations,
  OrthogonalFactorisations,
  SymmetricAndHermitianFactorisations,
  SpectralAndSchurFactorisations,
  SingularValueFactorisations,
  RankRevealingAndLowRankFactorisations,
  SparseAndIncompleteFactorisations,
  ParallelAndMixedPrecisionFactorisations
 ]
 STOP_CONDITION = "Stop when matrix structure, factorisation choice, assumptions, pivoting, stability, approximation quality, cost and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Linear Algebra Computation"
 RELATED_ONTOLOGIES = [
  "Linear Algebra Computation",
  "Numerical Linear Algebra Ontology 2",
  "Matrix Computation Ontology",
  "Sparse Matrix Ontology 2",
  "Dense Matrix Ontology",
  "Numerical Analysis Ontology 2",
  "Numerical Stability Ontology 2",
  "Floating Point Arithmetic Ontology",
  "Machine Precision Ontology",
  "High Performance Computing Ontologies"
 ]
 ROUTE_RULES = [
  "Matrix Decomposition -> Linear Algebra Computation for parent semantics",
  "Matrix Decomposition -> Numerical Linear Algebra for finite-precision factorisation theory",
  "Matrix Decomposition -> Matrix Computation for matrix operations",
  "Matrix Decomposition -> Sparse Matrix for fill, ordering and sparse factorisation",
  "Matrix Decomposition -> Dense Matrix for blocked dense factorisation",
  "Matrix Decomposition -> Numerical Analysis for conditioning and error",
  "Matrix Decomposition -> Numerical Stability for backward stability and orthogonality",
  "Matrix Decomposition -> Floating Point Arithmetic for round-off effects",
  "Matrix Decomposition -> HPC for parallel, distributed and accelerator factorisation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible decompositions, factorisation variants or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve decomposition-versus-general-matrix-operation distinction.",
  "Preserve exact-versus-approximate factorisation distinction.",
  "Preserve orthogonal-versus-triangular factor structure.",
  "Preserve algebraic-rank-versus-numerical-rank distinction.",
  "Preserve dense-versus-sparse factorisation distinction.",
  "Preserve complete-versus-incomplete factorisation distinction.",
  "Preserve reconstruction-error-versus-solution-error distinction.",
  "Preserve machine-readable matrix-decomposition semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Matrix decomposition expresses a matrix through structured factors that expose properties useful for solving, analysis, approximation and computation."
 TRIANGULAR_SUMMARY = "LU, LDU, Cholesky and LDLT decompositions reduce matrix problems to triangular or block-diagonal structure."
 ORTHOGONAL_SUMMARY = "QR, Householder and Givens methods provide stable orthogonal or unitary factorisations."
 SPECTRAL_SUMMARY = "Schur, Hessenberg, tridiagonal and eigen decompositions expose spectral structure."
 SVD_SUMMARY = "SVD reveals singular values, rank, conditioning and optimal low-rank approximations under standard norms."
 SPARSE_SUMMARY = "Sparse decompositions require ordering, symbolic analysis and fill management."
 APPROXIMATION_SUMMARY = "Truncated, interpolative, CUR, NMF and incomplete factorisations trade exact reconstruction for reduced cost or interpretable structure."
 VALIDATION_SUMMARY = "Decompositions should be checked for reconstruction, structural properties, conditioning, stability, rank, cost and reproducibility."
}

FLOW {
 INPUT
 -> detect_matrix_decomposition_context
 -> identify_matrix_dimensions_structure_sparsity_rank_precision_and_target_use
 -> classify_solve_least_squares_spectral_rank_revelation_preconditioning_or_low_rank_goal
 -> select_LU_QR_Cholesky_LDLT_Schur_SVD_polar_rank_revealing_or_incomplete_factorisation
 -> choose_pivoting_permutation_and_ordering_if_required
 -> analyse_conditioning_growth_orthogonality_roundoff_and_backward_error
 -> if_sparse_perform_symbolic_analysis_and_fill_reducing_ordering
 -> if_large_scale_use_blocked_tiled_parallel_GPU_or_distributed_factorisation
 -> if_approximate_measure_reconstruction_rank_or_preconditioning_quality
 -> validate_reconstruction_orthogonality_residuals_rank_reference_results_and_reproducibility
 -> route_to_linear_algebra_computation_numerical_linear_algebra_matrix_computation_sparse_dense_analysis_stability_floating_point_or_HPC_ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Matrix Decomposition Ontology 2 defines structured matrix factorisations. It supports LU, LUP, LDU, QR, thin, economy, pivoted and rank-revealing QR, Cholesky, pivoted and incomplete Cholesky, LDLT and Bunch-Kaufman factorisations, real, complex and generalised Schur forms, Hessenberg and tridiagonal reductions, bidiagonalisation, SVD, compact, truncated and generalised SVD, eigen and spectral decompositions, polar and Takagi factorisations, CUR, interpolative and nonnegative matrix factorisation, incomplete LU, Householder and Givens transformations, pivoting, numerical rank, singular values, conditioning, reconstruction and orthogonality error, dense and sparse factorisation, fill-in and reordering, symbolic and numeric phases, blocked, tiled, parallel, GPU, distributed and mixed-precision factorisation, iterative refinement, complexity, verification, benchmarking and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-MATRIX-DECOMPOSITION-ONTOLOGY-2-V1"
}

}

END_FLOW