Numerical Linear Algebra Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Linear Algebra Ontology 2 within the Kireth Research Semantic Library. Numerical linear algebra studies stable and efficient algorithms for matrix and vector problems under finite precision. This ontology supports linear systems, least-squares problems, matrix factorizations, eigenvalue and singular-value problems, iterative Krylov methods, sparse matrices, preconditioning, conditioning, perturbation analysis, residuals, forward and backward error, floating-point effects, low-rank approximation, randomised methods and scalable linear algebra computation.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalLinearAlgebra
 ENTITY_CLASS = FinitePrecisionMatrixComputationFramework
 PRIMARY_CONTEXT = LinearAlgebraComputation
 DEFINITION = "Numerical linear algebra is the study of computational methods for solving matrix and vector problems accurately and efficiently under finite-precision arithmetic."
 SYMBOLIC_FORMS = [
  "A x=b",
  "P A=L U",
  "A=Q R",
  "A=U Sigma V^T"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for matrix algorithms, linear-system solving, factorizations, eigenproblems, sparse and iterative methods, conditioning, stability, error analysis and scalable finite-precision linear algebra."
}

SCOPE {
 INCLUDE = [
  NumericalLinearAlgebra,
  ComputationalLinearAlgebra,
  MatrixComputation,
  VectorComputation,
  Matrix,
  Vector,
  DenseMatrix,
  SparseMatrix,
  StructuredMatrix,
  SymmetricMatrix,
  HermitianMatrix,
  PositiveDefiniteMatrix,
  PositiveSemidefiniteMatrix,
  OrthogonalMatrix,
  UnitaryMatrix,
  TriangularMatrix,
  DiagonalMatrix,
  BandedMatrix,
  BlockMatrix,
  ToeplitzMatrix,
  LinearSystem,
  SquareSystem,
  RectangularSystem,
  OverdeterminedSystem,
  UnderdeterminedSystem,
  LeastSquaresProblem,
  MinimumNormProblem,
  MatrixEquation,
  DirectMethod,
  IterativeMethod,
  GaussianElimination,
  Pivoting,
  PartialPivoting,
  CompletePivoting,
  RookPivoting,
  ForwardSubstitution,
  BackSubstitution,
  LUDecomposition,
  LDUDecomposition,
  CholeskyDecomposition,
  LDLTDecomposition,
  QRDecomposition,
  HouseholderTransformation,
  GivensRotation,
  GramSchmidtProcess,
  ModifiedGramSchmidt,
  RankRevealingQR,
  RRQR,
  SingularValueDecomposition,
  SVD,
  TruncatedSVD,
  Pseudoinverse,
  MoorePenrosePseudoinverse,
  EigenvalueProblem,
  GeneralisedEigenvalueProblem,
  Eigenvector,
  SchurDecomposition,
  RealSchurForm,
  HessenbergReduction,
  TridiagonalReduction,
  PowerMethod,
  InverseIteration,
  RayleighQuotientIteration,
  QRAlgorithm,
  DivideAndConquerEigenSolver,
  LanczosMethod,
  ArnoldiMethod,
  KrylovSubspace,
  IterativeLinearSolver,
  StationaryIteration,
  JacobiMethod,
  GaussSeidelMethod,
  SuccessiveOverRelaxation,
  SOR,
  ConjugateGradientMethod,
  CG,
  MINRES,
  GMRES,
  BiCG,
  BiCGSTAB,
  QMR,
  TFQMR,
  Preconditioner,
  LeftPreconditioning,
  RightPreconditioning,
  SplitPreconditioning,
  DiagonalPreconditioner,
  JacobiPreconditioner,
  IncompleteLU,
  ILU,
  IncompleteCholesky,
  Multigrid,
  AlgebraicMultigrid,
  AMG,
  ConditionNumber,
  Conditioning,
  MatrixConditionNumber,
  PerturbationAnalysis,
  Sensitivity,
  Residual,
  ResidualNorm,
  ForwardError,
  BackwardError,
  ComponentwiseError,
  NormwiseError,
  NumericalStability,
  BackwardStability,
  GrowthFactor,
  FloatingPointArithmetic,
  MachinePrecision,
  RoundOffError,
  LossOfOrthogonality,
  Reorthogonalisation,
  Convergence,
  ConvergenceRate,
  SpectralRadius,
  FieldOfValues,
  Pseudospectrum,
  SparseStorage,
  CSR,
  CSC,
  COO,
  FillIn,
  Reordering,
  NestedDissection,
  MinimumDegreeOrdering,
  PermutationMatrix,
  Scaling,
  Equilibration,
  LowRankApproximation,
  MatrixApproximation,
  RandomisedLinearAlgebra,
  RandomisedSVD,
  Sketching,
  MatrixFunction,
  MatrixExponential,
  MatrixSquareRoot,
  MatrixLogarithm,
  KroneckerProduct,
  TensorProduct,
  ParallelLinearAlgebra,
  DistributedMatrix,
  BlockCyclicDistribution,
  BLAS,
  LAPACK,
  ScaLAPACK,
  GPUComputing,
  MixedPrecision,
  IterativeRefinement,
  MixedPrecisionIterativeRefinement,
  ComputationalComplexity,
  MemoryComplexity,
  Verification,
  Benchmarking,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  AbstractLinearAlgebraWithoutNumericalAlgorithm,
  ExactSymbolicMatrixAlgebraWithoutFinitePrecision,
  SoftwareImplementationWithoutNumericalLinearAlgebraSemantics,
  StatisticalMatrixUseWithoutMatrixAlgorithmReasoning
 ]
 DISAMBIGUATION_RULE = "When matrix or vector problems are solved numerically with explicit concern for accuracy, stability, conditioning, sparsity or computational cost, interpret the context as numerical linear algebra."
}

CORE_CONCEPTS {
 NumericalLinearAlgebra = "Study of stable and efficient numerical algorithms for matrix and vector problems."
 LinearSystem = "Matrix equation A x=b solved by direct or iterative algorithms."
 MatrixFactorisation = "Decomposition of a matrix into structured factors useful for solving, analysis or compression."
 LeastSquaresProblem = "Problem of minimising the norm of A x-b."
 EigenvalueProblem = "Problem of finding eigenvalues and eigenvectors of a matrix or matrix pair."
 SingularValueDecomposition = "Factorisation exposing singular values, rank and conditioning."
 SparseMatrix = "Matrix represented and processed by exploiting predominantly zero entries."
 Preconditioner = "Transformation designed to improve spectral properties and iterative convergence."
 ConditionNumber = "Measure of sensitivity of a matrix problem to perturbations."
}

RELATIONS {
 NumericalLinearAlgebra --is_child_of--> LinearAlgebraComputation
 NumericalLinearAlgebra --uses--> FloatingPointArithmetic
 LinearSystem --is_solved_by--> DirectMethod
 LinearSystem --is_solved_by--> IterativeMethod
 GaussianElimination --uses--> Pivoting
 Pivoting --controls--> ElementGrowth
 LUDecomposition --supports--> LinearSystemSolution
 CholeskyDecomposition --requires--> SymmetricPositiveDefiniteStructure
 QRDecomposition --supports--> LeastSquaresSolution
 SVD --supports--> RankAndConditionAnalysis
 Pseudoinverse --can_be_constructed_from--> SVD
 KrylovSubspace --supports--> IterativeLinearSolver
 ConjugateGradientMethod --solves--> SymmetricPositiveDefiniteSystem
 MINRES --solves--> SymmetricIndefiniteSystem
 GMRES --solves--> GeneralNonsymmetricSystem
 Preconditioner --improves--> IterativeConvergence
 ConditionNumber --quantifies--> ProblemSensitivity
 Residual --measures--> EquationMismatch
 BackwardError --measures--> NearbyProblemPerturbation
 Scaling --can_reduce--> NumericalImbalance
 Reordering --can_reduce--> SparseFillIn
 RandomisedSVD --approximates--> DominantSingularSubspace
 IterativeRefinement --improves--> SolutionAccuracy
 ParallelLinearAlgebra --accelerates--> LargeScaleMatrixComputation
}

OPERATORS {
 LINEAR_SYSTEM(A,x,b) := A*x=b
 RESIDUAL(A,x,b) := r=b-A*x
 RELATIVE_RESIDUAL(A,x,b) := ||b-A*x||/(||A||*||x||+||b||)
 CONDITION_NUMBER(A) := kappa(A)=||A||*||A^(-1)||
 LU_FACTOR(A) := P*A=L*U
 QR_FACTOR(A) := A=Q*R
 CHOLESKY_FACTOR(A) := A=L*L^T
 SVD_FACTOR(A) := A=U*Sigma*V^T
 PSEUDOINVERSE(A) := A_plus=V*Sigma_plus*U^T
 LEAST_SQUARES(A,b) := x_hat=argmin_x ||A*x-b||_2
 EIGENPAIR(A,v,lambda) := A*v=lambda*v
 KRYLOV_SPACE(A,r,m) := span{r,A*r,...,A^(m-1)*r}
 PRECONDITIONED_SYSTEM(M,A,x,b) := M^(-1)*A*x=M^(-1)*b
 ITERATIVE_REFINEMENT(A,x,b) := x_next=x+correction_from_residual
}

AXIOMS {
 A1 = "Numerical linear algebra must account for finite-precision arithmetic."
 A2 = "Problem conditioning and algorithmic stability are distinct."
 A3 = "Residual size and forward solution error are distinct."
 A4 = "Matrix structure should be exploited when it improves reliability or efficiency."
 A5 = "Orthogonal transformations generally provide favourable stability properties."
 A6 = "Sparse matrix computation should preserve sparsity where feasible."
 A7 = "Iterative convergence depends on spectrum, field of values, conditioning and preconditioning."
 A8 = "Numerical linear-algebra results require residual, error, convergence and reproducibility validation."
}

REASONING {
 R1_CONTEXT = identify(matrix_dimensions,structure,sparsity,problem_type,precision,accuracy_goal)
 R2_STRUCTURE = detect(symmetry,Hermitian_structure,definiteness,bandedness,rank_and_sparsity)
 R3_CLASS = classify(linear_system,least_squares,eigenproblem,SVD,matrix_function_or_other)
 R4_METHOD = select(direct,factorisation,stationary_iteration,Krylov,randomised_or_low_rank_method)
 R5_CONDITIONING = analyse(condition_number,scaling,perturbation_sensitivity)
 R6_STABILITY = analyse(pivoting,growth,orthogonality,roundoff,backward_error)
 R7_ITERATIVE = if_iterative analyse(residual,spectrum,field_of_values,preconditioner,stopping_rule)
 R8_SPARSE = if_sparse choose(storage,reordering,fill_reduction_and_sparse_factorisation)
 R9_PRECISION = if_mixed_precision analyse(iterative_refinement_and_precision_transitions)
 R10_VALIDATION = compare(residual,error_bounds,reference_solution,convergence,memory_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Forming an explicit inverse is often unnecessary and can be less stable than solving a linear system."
 C2 = "Normal equations can square the condition number of a least-squares problem."
 C3 = "Cholesky decomposition requires suitable positive-definite structure."
 C4 = "Standard conjugate gradients require symmetric positive-definite structure."
 C5 = "Sparse direct factorisation can generate substantial fill-in."
 C6 = "Non-normal matrices can exhibit large transient behaviour even when eigenvalues appear benign."
 C7 = "Classical Gram-Schmidt can lose orthogonality in finite precision."
 C8 = "Iterative residual tolerances should be interpreted relative to conditioning and scale."
 C9 = "Low-rank approximation accuracy depends on singular-value decay and target rank."
 C10 = "Parallel performance can be limited by communication, synchronisation and memory bandwidth."
}

SEMANTIC_EQUIVALENCE {
 "NumericalLinearAlgebra" <=> "ComputationalNumericalLinearAlgebra"
 "SingularValueDecomposition" <=> "SVD"
 "ConjugateGradientMethod" <=> "CG"
 "SuccessiveOverRelaxation" <=> "SOR"
 "IncompleteLU" <=> "ILU"
 "AlgebraicMultigrid" <=> "AMG"
 "MoorePenrosePseudoinverse" <=> "Pseudoinverse"
 "RankRevealingQR" <=> "RRQR"
}

VALIDATION {
 V1 = "Matrix dimensions and structure are explicit."
 V2 = "Arithmetic precision is documented."
 V3 = "Conditioning is assessed where relevant."
 V4 = "Residuals are reported with scale-aware interpretation."
 V5 = "Forward and backward error are distinguished."
 V6 = "Factorisation assumptions are verified."
 V7 = "Iterative convergence and stopping rules are documented."
 V8 = "Sparse storage, fill and memory effects are considered."
 V9 = "Reference or benchmark solutions are used where feasible."
 V10 = "Results are reproducible under documented solver and arithmetic settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_LINEAR_ALGEBRA_DEFINITION = 0.99
 DIRECT_SOLVER_REASONING = 0.99
 FACTORISATION_REASONING = 0.99
 LEAST_SQUARES_REASONING = 0.99
 EIGENVALUE_REASONING = 0.99
 SVD_REASONING = 0.99
 KRYLOV_REASONING = 0.99
 PRECONDITIONING_REASONING = 0.98
 SPARSE_REASONING = 0.98
 POLICY = "Reduce confidence when matrix structure, conditioning, sparsity, arithmetic precision, residual scaling, preconditioner or stopping criteria are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, NumericalLinearAlgebraReasoning,
  LinearSystemReasoning, GaussianEliminationReasoning, LUReasoning,
  QRReasoning, CholeskyReasoning, LeastSquaresReasoning, SVDReasoning,
  EigenvalueReasoning, KrylovReasoning, ConjugateGradientReasoning,
  GMRESReasoning, PreconditioningReasoning, SparseMatrixReasoning,
  ConditioningReasoning, ResidualReasoning, BackwardErrorReasoning,
  FloatingPointReasoning, MixedPrecisionReasoning, LowRankReasoning,
  ParallelLinearAlgebraReasoning, KnowledgeGraphConstruction,
  RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "numerical linear algebra" -> NumericalLinearAlgebra
  "computational numerical linear algebra" -> NumericalLinearAlgebra
  "SVD" -> SingularValueDecomposition
  "CG" -> ConjugateGradientMethod
  "SOR" -> SuccessiveOverRelaxation
  "ILU" -> IncompleteLU
  "AMG" -> AlgebraicMultigrid
  "RRQR" -> RankRevealingQR
 }
}

EXECUTION_RULES {
 E1 = "If a matrix or vector problem is solved numerically, activate NumericalLinearAlgebraOntology."
 E2 = "If solving A x=b, detect matrix structure before choosing a solver."
 E3 = "If a least-squares problem is ill-conditioned, prefer QR or SVD reasoning over naive normal equations."
 E4 = "If the matrix is large and sparse, consider Krylov methods and preconditioning."
 E5 = "If the matrix is symmetric positive definite, consider Cholesky or conjugate gradients."
 E6 = "If eigenpairs are sought for large sparse matrices, consider Lanczos or Arnoldi methods."
 E7 = "If low-rank structure exists, consider truncated or randomised SVD."
 E8 = "If low precision is used, consider iterative refinement or mixed-precision correction."
 E9 = "Any numerical linear-algebra result should be validated for residuals, conditioning, stability, convergence and reproducibility."
}

RECURSION {
 ENTRY = NumericalLinearAlgebra
 EXPAND(NumericalLinearAlgebra) -> [
  ComputationalLinearAlgebra, MatrixComputation, VectorComputation,
  Matrix, Vector, DenseMatrix, SparseMatrix, StructuredMatrix,
  SymmetricMatrix, HermitianMatrix, PositiveDefiniteMatrix,
  OrthogonalMatrix, TriangularMatrix, DiagonalMatrix, BandedMatrix,
  BlockMatrix, LinearSystem, OverdeterminedSystem, UnderdeterminedSystem,
  LeastSquaresProblem, MinimumNormProblem, DirectMethod, IterativeMethod,
  GaussianElimination, Pivoting, ForwardSubstitution, BackSubstitution,
  LUDecomposition, LDUDecomposition, CholeskyDecomposition,
  LDLTDecomposition, QRDecomposition, HouseholderTransformation,
  GivensRotation, GramSchmidtProcess, ModifiedGramSchmidt,
  RankRevealingQR, SingularValueDecomposition, TruncatedSVD,
  Pseudoinverse, EigenvalueProblem, GeneralisedEigenvalueProblem,
  SchurDecomposition, HessenbergReduction, TridiagonalReduction,
  PowerMethod, InverseIteration, RayleighQuotientIteration, QRAlgorithm,
  LanczosMethod, ArnoldiMethod, KrylovSubspace, IterativeLinearSolver,
  JacobiMethod, GaussSeidelMethod, SuccessiveOverRelaxation,
  ConjugateGradientMethod, MINRES, GMRES, BiCGSTAB, Preconditioner,
  LeftPreconditioning, RightPreconditioning, DiagonalPreconditioner,
  IncompleteLU, IncompleteCholesky, Multigrid, AlgebraicMultigrid,
  ConditionNumber, Conditioning, PerturbationAnalysis, Residual,
  ForwardError, BackwardError, ComponentwiseError, NormwiseError,
  NumericalStability, GrowthFactor, FloatingPointArithmetic,
  MachinePrecision, RoundOffError, LossOfOrthogonality,
  Reorthogonalisation, Convergence, SpectralRadius, FieldOfValues,
  Pseudospectrum, SparseStorage, CSR, CSC, COO, FillIn, Reordering,
  NestedDissection, MinimumDegreeOrdering, Scaling, Equilibration,
  LowRankApproximation, RandomisedLinearAlgebra, RandomisedSVD,
  Sketching, MatrixFunction, MatrixExponential, MatrixSquareRoot,
  MatrixLogarithm, KroneckerProduct, ParallelLinearAlgebra,
  DistributedMatrix, BLAS, LAPACK, ScaLAPACK, GPUComputing,
  MixedPrecision, IterativeRefinement, ComputationalComplexity,
  MemoryComplexity, Verification, Benchmarking, Reproducibility
 ]
 EXPAND(NLAFamilies) -> [
  DirectLinearSolvers,
  LeastSquaresMethods,
  MatrixFactorisations,
  EigenvalueMethods,
  SingularValueMethods,
  KrylovAndIterativeMethods,
  SparseLinearAlgebra,
  LowRankAndRandomisedLinearAlgebra,
  ParallelAndMixedPrecisionLinearAlgebra
 ]
 STOP_CONDITION = "Stop when matrix structure, problem class, algorithm, conditioning, stability, convergence, sparsity, precision and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Linear Algebra Computation"
 RELATED_ONTOLOGIES = [
  "Linear Algebra Computation",
  "Linear Algebra Ontologies",
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology",
  "Machine Precision Ontology",
  "Scientific Computing Ontology 2",
  "High Performance Computing Ontologies"
 ]
 ROUTE_RULES = [
  "Numerical Linear Algebra -> Linear Algebra Computation for parent semantics",
  "Numerical Linear Algebra -> Linear Algebra Ontologies for mathematical matrix structure",
  "Numerical Linear Algebra -> Numerical Methods for solver algorithms",
  "Numerical Linear Algebra -> Numerical Analysis for conditioning and stability",
  "Numerical Linear Algebra -> Numerical Error for residual and forward/backward error",
  "Numerical Linear Algebra -> Numerical Stability for finite-precision algorithm behaviour",
  "Numerical Linear Algebra -> Numerical Convergence for iterative solver convergence",
  "Numerical Linear Algebra -> Floating Point Arithmetic for rounding effects",
  "Numerical Linear Algebra -> Scientific Computing for applied sparse systems",
  "Numerical Linear Algebra -> HPC for distributed and parallel matrix computation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical linear-algebra algorithms, factorizations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve mathematical-problem-versus-numerical-algorithm distinction.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve residual-versus-forward-error distinction.",
  "Preserve direct-versus-iterative solver distinction.",
  "Preserve dense-versus-sparse matrix distinction.",
  "Preserve exact-factorisation-versus-low-rank approximation distinction.",
  "Preserve serial-versus-parallel computation distinction.",
  "Preserve machine-readable numerical-linear-algebra semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Numerical linear algebra develops stable and efficient finite-precision algorithms for matrix and vector problems."
 SYSTEM_SUMMARY = "Gaussian elimination, LU, Cholesky and iterative methods solve linear systems according to matrix structure."
 LEAST_SQUARES_SUMMARY = "QR, SVD and related methods solve overdetermined and rank-deficient least-squares problems robustly."
 EIGEN_SUMMARY = "QR, power, inverse, Lanczos and Arnoldi methods solve dense and sparse eigenproblems."
 SPARSE_SUMMARY = "Sparse storage, reordering, preconditioning and multigrid reduce memory and computational cost."
 ERROR_SUMMARY = "Residuals, condition numbers, forward and backward errors provide complementary measures of numerical quality."
 LOW_RANK_SUMMARY = "SVD, truncated SVD, randomised methods and sketching expose or approximate low-dimensional structure."
 PRECISION_SUMMARY = "Floating-point, mixed-precision and iterative-refinement methods balance accuracy, cost and memory."
 VALIDATION_SUMMARY = "Numerical linear-algebra results should be checked for residuals, conditioning, stability, convergence, precision and reproducibility."
}

FLOW {
 INPUT
 -> detect_numerical_linear_algebra_context
 -> identify_matrix_dimensions_structure_sparsity_problem_type_precision_and_accuracy_goal
 -> classify_linear_system_least_squares_eigenvalue_SVD_matrix_function_or_other_problem
 -> detect_symmetry_Hermitian_structure_definiteness_rank_and_sparsity
 -> select_direct_factorisation_stationary_Krylov_randomised_or_low_rank_method
 -> analyse_conditioning_scaling_and_perturbation_sensitivity
 -> analyse_pivoting_growth_orthogonality_roundoff_and_backward_error
 -> if_iterative_assess_residual_spectrum_field_of_values_preconditioner_and_stopping_rule
 -> if_sparse_select_storage_reordering_fill_reduction_and_sparse_factorisation
 -> if_mixed_precision_assess_iterative_refinement_and_precision_transitions
 -> validate_with_residuals_error_bounds_reference_solutions_benchmarks_and_reproducibility
 -> route_to_linear_algebra_computation_linear_algebra_numerical_methods_analysis_error_stability_convergence_floating_point_scientific_computing_or_HPC_ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Linear Algebra Ontology 2 defines stable and efficient matrix computation under finite precision. It supports dense, sparse and structured matrices, linear, overdetermined, underdetermined and minimum-norm systems, Gaussian elimination and pivoting, LU, LDU, Cholesky, LDLT and QR factorisations, Householder and Givens transformations, Gram-Schmidt and rank-revealing QR, SVD and pseudoinverses, eigenvalue and generalised eigenvalue problems, Schur and Hessenberg forms, power, inverse, Rayleigh, QR, Lanczos and Arnoldi algorithms, stationary and Krylov iterative solvers, CG, MINRES, GMRES and BiCGSTAB, preconditioning and multigrid, condition numbers and perturbation analysis, residual, forward and backward error, sparse storage and fill reduction, low-rank and randomised linear algebra, matrix functions, parallel and GPU computation, mixed precision, iterative refinement, complexity, verification, benchmarking and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-NUMERICAL-LINEAR-ALGEBRA-ONTOLOGY-2-V1"
}

}

END_FLOW