Numerical Linear Algebra Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Linear Algebra Ontology within the Kireth Research Semantic Library. Numerical linear algebra studies computational methods for matrix and vector problems, including linear systems, least-squares problems, eigenvalue problems, singular value decomposition, matrix factorisation, iterative solvers, Krylov subspace methods, sparse matrices, conditioning, stability, preconditioning, low-rank approximation and large-scale computation. This ontology supports direct and iterative algorithms, dense and sparse matrix structure, floating-point effects, backward and forward error, residuals, convergence and relationships with computational mathematics, scientific computing, high-performance computing, optimisation and differential equations.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalLinearAlgebra
 SYMBOLIC_FORMS = [
  "A x = b",
  "A = L U",
  "A = Q R",
  "A v = lambda v",
  "A = U Sigma V^T"
 ]
 ENTITY_CLASS = ComputationalMatrixAnalysisFramework
 PRIMARY_CONTEXT = ComputationalMathematics
 DEFINITION = "Numerical linear algebra is the study of computational algorithms for matrix and vector problems, including linear systems, eigenproblems, least-squares problems and matrix decompositions."
 SEMANTIC_ROLE = "Provides machine-readable semantics for dense and sparse matrix computation, direct factorisation, iterative methods, Krylov subspaces, conditioning, stability, residuals, error and large-scale numerical linear algebra."
}

SCOPE {
 INCLUDE = [
  NumericalLinearAlgebra,
  Matrix,
  Vector,
  LinearSystem,
  DenseMatrix,
  SparseMatrix,
  StructuredMatrix,
  SymmetricMatrix,
  HermitianMatrix,
  PositiveDefiniteMatrix,
  BandedMatrix,
  TriangularMatrix,
  OrthogonalMatrix,
  UnitaryMatrix,
  Rank,
  NullSpace,
  ColumnSpace,
  RowSpace,
  MatrixNorm,
  VectorNorm,
  ConditionNumber,
  Residual,
  ForwardError,
  BackwardError,
  RoundoffError,
  FloatingPointArithmetic,
  DirectMethod,
  IterativeMethod,
  GaussianElimination,
  Pivoting,
  PartialPivoting,
  CompletePivoting,
  LUFactorisation,
  CholeskyFactorisation,
  QRFactorisation,
  HouseholderTransformation,
  GivensRotation,
  LeastSquares,
  NormalEquations,
  SingularValueDecomposition,
  SVD,
  Pseudoinverse,
  LowRankApproximation,
  EigenvalueProblem,
  Eigenvector,
  PowerIteration,
  InverseIteration,
  RayleighQuotientIteration,
  QRAlgorithm,
  LanczosMethod,
  ArnoldiMethod,
  KrylovSubspace,
  ConjugateGradient,
  MINRES,
  GMRES,
  BiCGSTAB,
  Preconditioning,
  JacobiPreconditioner,
  ILUPreconditioner,
  MultigridPreconditioner,
  MatrixFreeMethod,
  SparseDirectSolver,
  SparseIterativeSolver,
  Reordering,
  FillIn,
  ParallelLinearAlgebra
 ]

 EXCLUDE_AS_PRIMARY = [
  PureAbstractLinearAlgebraWithoutComputationalConcern,
  GeneralNumericalAnalysisWithoutMatrixStructure,
  SymbolicMatrixManipulationWithoutNumericalApproximation
 ]

 DISAMBIGUATION_RULE =
  "When matrix or vector problems are solved or analysed computationally with attention to numerical error, conditioning, factorisation, iteration or sparsity, interpret the context as numerical linear algebra."
}

CORE_CONCEPTS {

 NumericalLinearAlgebra {
  definition = "The computational study of matrix and vector problems."
 }

 LinearSystem {
  definition = "A system represented in matrix form as A x = b."
 }

 MatrixFactorisation {
  definition = "A decomposition of a matrix into factors with useful numerical structure."
 }

 ConditionNumber {
  definition = "A measure of the sensitivity of a matrix problem to perturbations."
 }

 Residual {
  definition = "The defect b-Ax associated with an approximate linear-system solution."
 }

 BackwardError {
  definition = "The smallest perturbation to the input data for which the computed result is exact."
 }

 KrylovSubspace {
  definition = "A subspace generated by repeated action of a matrix on a vector."
 }

 Preconditioning {
  definition = "Transformation of a problem to improve convergence or conditioning for iterative solution."
 }

 SingularValueDecomposition {
  definition = "A factorisation A=U Sigma V^T revealing singular values, rank and low-rank structure."
 }

 EigenvalueProblem {
  definition = "The computational problem of finding lambda and v satisfying Av=lambda v."
 }
}

RELATIONS {
 NumericalLinearAlgebra --is_child_of--> ComputationalMathematics
 LinearSystem --uses--> Matrix
 LinearSystem --uses--> Vector
 ConditionNumber --measures--> ProblemSensitivity
 Residual --measures--> EquationDefect
 ForwardError --measures--> SolutionDifference
 BackwardError --measures--> InputPerturbation
 GaussianElimination --produces--> LUFactorisation
 CholeskyFactorisation --applies_to--> PositiveDefiniteMatrix
 QRFactorisation --supports--> LeastSquares
 SingularValueDecomposition --reveals--> Rank
 SingularValueDecomposition --supports--> LowRankApproximation
 Pseudoinverse --derives_from--> SingularValueDecomposition
 PowerIteration --approximates--> DominantEigenpair
 LanczosMethod --uses--> KrylovSubspace
 ArnoldiMethod --uses--> KrylovSubspace
 ConjugateGradient --applies_to--> SymmetricPositiveDefiniteSystem
 GMRES --applies_to--> GeneralNonsymmetricSystem
 Preconditioning --improves--> IterativeConvergence
 Reordering --reduces--> FillIn
 ParallelLinearAlgebra --accelerates--> LargeMatrixComputation
}

OPERATORS {
 LINEAR_SYSTEM(A,x,b) :=
  A*x=b

 RESIDUAL(A,x,b) :=
  r=b-A*x

 RELATIVE_RESIDUAL(r,b) :=
  r_rel=||r||/||b||

 CONDITION_NUMBER(A) :=
  kappa(A)=||A||*||A^(-1)||

 FORWARD_ERROR(x_true,x_hat) :=
  e_f=||x_true-x_hat||/||x_true||

 BACKWARD_ERROR(A,x_hat,b) :=
  smallest_perturbation such_that (A+DeltaA)*x_hat=b+Delta_b

 LU_FACTORIZATION(A) :=
  P*A=L*U

 CHOLESKY_FACTORIZATION(A) :=
  A=L*L^T
  for symmetric_positive_definite A

 QR_FACTORIZATION(A) :=
  A=Q*R

 SVD(A) :=
  A=U*Sigma*V^T

 LEAST_SQUARES(A,x,b) :=
  minimise ||A*x-b||_2

 NORMAL_EQUATIONS(A,b) :=
  A^T*A*x=A^T*b

 EIGENVALUE_PROBLEM(A,v,lambda) :=
  A*v=lambda*v

 KRYLOV_SUBSPACE(A,r0,m) :=
  K_m=span(r0,A*r0,A^2*r0,...,A^(m-1)*r0)

 CG_UPDATE(A,b,x_k) :=
  next_iterate_from_conjugate_gradient_recurrence

 GMRES_OBJECTIVE(A,b,x0,Km) :=
  minimise ||b-A*x||_2 over x in x0+K_m
}

DEFINITIONS {
 D1 = "Numerical linear algebra studies finite-precision computation with matrices and vectors."
 D2 = "Direct methods use factorisations to obtain a solution in a finite number of algebraic stages."
 D3 = "Iterative methods generate a sequence of approximate solutions."
 D4 = "Conditioning is a property of the problem, not the algorithm alone."
 D5 = "Backward stability means the computed result is exact for a nearby problem."
 D6 = "Sparse methods exploit zero structure to reduce storage and arithmetic cost."
 D7 = "QR methods are generally preferable to normal equations for stable least-squares computation."
 D8 = "The SVD provides a robust description of rank and near-rank deficiency."
 D9 = "Krylov methods are central to large sparse linear systems and eigenproblems."
 D10 = "Preconditioning changes the computational representation to improve iterative performance."
}

AXIOMS {
 A1_MATRIX_STRUCTURE:
  Numerical methods should exploit relevant matrix structure when doing so preserves correctness

 A2_FINITE_PRECISION:
  NumericalLinearAlgebra operates under finite-precision arithmetic unless exact arithmetic is explicitly declared

 A3_CONDITIONING:
  Perturbation sensitivity must be distinguished from algorithmic instability

 A4_RESIDUAL_ERROR_DISTINCTION:
  Small residual does not imply small forward error for all ill-conditioned systems

 A5_FACTORISATION_STABILITY:
  Matrix factorisations require numerically stable transformations and pivoting where appropriate

 A6_ITERATIVE_CONVERGENCE:
  Iterative methods require convergence criteria and stopping tolerances

 A7_SPARSE_STRUCTURE:
  Sparse algorithms should manage fill-in and memory growth

 A8_VALIDATION:
  Computed matrix solutions require residual, conditioning and convergence checks
}

REASONING {

 R1_MATRIX_PROBLEM_CONTEXT {
  INPUT = matrix_problem
  IDENTIFY = dimensions
  IDENTIFY = dense_or_sparse structure
  IDENTIFY = symmetry_positivity_rank_and_conditioning
  IDENTIFY = accuracy requirements
  RETURN = numerical_linear_algebra_context
 }

 R2_DIRECT_METHOD_SELECTION {
  INPUT = numerical_linear_algebra_context
  IF general_dense_system
   CONSIDER = LU_with_pivoting
  IF symmetric_positive_definite
   CONSIDER = Cholesky
  IF least_squares
   CONSIDER = QR_or_SVD
  RETURN = direct_solver_strategy
 }

 R3_ITERATIVE_METHOD_SELECTION {
  INPUT = large_sparse_system
  IF symmetric_positive_definite
   SELECT = ConjugateGradient
  ELSE IF symmetric_indefinite
   CONSIDER = MINRES
  ELSE
   CONSIDER = GMRES_or_BiCGSTAB
  RETURN = iterative_solver_strategy
 }

 R4_CONDITIONING_REASONING {
  INPUT = matrix_or_operator
  ESTIMATE = condition_number_or_spectral properties
  RETURN = conditioning_profile
 }

 R5_PRECONDITIONING_REASONING {
  INPUT = iterative_problem
  SELECT = Jacobi_ILU_multigrid_domain_specific_or_other preconditioner
  ANALYSE = setup_cost_apply_cost_and_convergence effect
  RETURN = preconditioned_system
 }

 R6_LEAST_SQUARES_REASONING {
  INPUT = overdetermined_or_rank_deficient system
  CHECK = rank_and_conditioning
  SELECT = QR_or_SVD
  RETURN = least_squares_solution
 }

 R7_EIGENVALUE_REASONING {
  INPUT = matrix_eigenproblem
  CLASSIFY = dense_sparse_symmetric_general_and_target spectrum
  SELECT = QR_power_inverse_Lanczos_Arnoldi_or_shiftInvert method
  RETURN = eigen_solution
 }

 R8_LOW_RANK_REASONING {
  INPUT = matrix_and_approximation tolerance
  COMPUTE = SVD_or_truncated factorisation
  RETURN = low_rank_approximation
 }

 R9_SPARSE_REASONING {
  INPUT = sparse_matrix
  ANALYSE = ordering_fill_pattern_memory_and_parallel structure
  RETURN = sparse_solver_profile
 }

 R10_VALIDATION {
  INPUT = computed_result
  CHECK = residual_forward_or_backward error_conditioning_convergence_and_structure preservation
  RETURN = validated_linear_algebra_status
 }
}

CONSTRAINTS {
 C1 = "Normal equations square the condition number and can reduce least-squares numerical stability."
 C2 = "Cholesky requires an appropriate positive-definite matrix."
 C3 = "Conjugate gradient requires symmetric positive-definite structure in its standard form."
 C4 = "GMRES memory cost grows with unrestarted Krylov dimension."
 C5 = "Pivoting may be necessary for stable Gaussian elimination."
 C6 = "Rank decisions depend on numerical tolerance."
 C7 = "Sparse factorisation can create substantial fill-in."
 C8 = "Preconditioners can improve iteration count while adding setup and application cost."
 C9 = "Eigenvalue sensitivity can be severe for nonnormal matrices."
 C10 = "Finite-precision orthogonality can degrade in long Krylov iterations."
}

SEMANTIC_EQUIVALENCE {
 "NumericalLinearAlgebra" <=> "ComputationalLinearAlgebra"
 "LUFactorisation" <=> "LUDecomposition"
 "QRFactorisation" <=> "QRDecomposition"
 "SingularValueDecomposition" <=> "SVD"
 "ConjugateGradient" <=> "CG"
 "GeneralizedMinimalResidual" <=> "GMRES"
}

VALIDATION {
 V1 = "Matrix dimensions and structure are explicit."
 V2 = "Residual is computed."
 V3 = "Conditioning is assessed where relevant."
 V4 = "Pivoting or stability strategy is documented."
 V5 = "Least-squares rank handling is explicit."
 V6 = "Iterative convergence history is checked."
 V7 = "Preconditioner assumptions are documented."
 V8 = "Sparse fill and memory requirements are assessed."
 V9 = "Eigenpair residuals are checked."
 V10 = "Low-rank approximation error is measured."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_LINEAR_ALGEBRA_DEFINITION = 0.99
 DIRECT_METHOD_REASONING = 0.99
 ITERATIVE_METHOD_REASONING = 0.99
 CONDITIONING_REASONING = 0.99
 PRECONDITIONING_REASONING = 0.98
 LEAST_SQUARES_REASONING = 0.99
 EIGENVALUE_REASONING = 0.98
 LOW_RANK_REASONING = 0.98
 SPARSE_REASONING = 0.98

 POLICY =
  "Reduce confidence when matrix structure, rank, conditioning, sparsity, stopping tolerances, preconditioner details, precision or convergence evidence are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalLinearAlgebraReasoning,
  LinearSystemReasoning,
  MatrixFactorisationReasoning,
  LUReasoning,
  CholeskyReasoning,
  QRReasoning,
  SVDReasoning,
  LeastSquaresReasoning,
  EigenvalueReasoning,
  KrylovReasoning,
  ConjugateGradientReasoning,
  GMRESReasoning,
  PreconditioningReasoning,
  SparseMatrixReasoning,
  ConditioningReasoning,
  StabilityReasoning,
  ErrorAnalysisReasoning,
  ParallelLinearAlgebraReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "numerical linear algebra" -> NumericalLinearAlgebra
  "computational linear algebra" -> NumericalLinearAlgebra
  "LU decomposition" -> LUFactorisation
  "QR decomposition" -> QRFactorisation
  "singular value decomposition" -> SingularValueDecomposition
  "SVD" -> SingularValueDecomposition
  "conjugate gradient" -> ConjugateGradient
  "CG" -> ConjugateGradient
  "GMRES" -> GMRES
  "preconditioner" -> Preconditioning
 }

 INTERPRETATION_ORDER = [
  detect_numerical_linear_algebra_context,
  identify matrix_dimensions_structure_sparsity_rank_symmetry_positivity_and_accuracy requirements,
  assess conditioning,
  select direct_iterative_leastSquares_eigen_or_lowRank pathway,
  choose factorisation_or_Krylov method,
  apply pivoting_preconditioning_or_reordering as needed,
  compute solution,
  evaluate residual_forward_backward error_and_convergence,
  assess sparse_memory_and_parallel considerations,
  validate numerical result,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("numerical linear algebra")
  OR computational_matrix_problem_is_present
  THEN activate(NumericalLinearAlgebraOntology)

 E2:
  IF general_dense_linear_system
  THEN consider LU_with_pivoting

 E3:
  IF symmetric_positive_definite_system
  THEN consider Cholesky_or_ConjugateGradient

 E4:
  IF least_squares_problem
  THEN prefer QR_or_SVD_over_normal_equations_when_stability matters

 E5:
  IF large_sparse_system
  THEN consider Krylov_and_preconditioning

 E6:
  IF rank_deficiency_or_near_rank_deficiency
  THEN use SVD_or_rank_revealing factorisation

 E7:
  IF eigenproblem_is_large_and_sparse
  THEN consider Lanczos_or_Arnoldi

 E8:
  IF sparse_direct_method
  THEN analyse reordering_and_fill in

 E9:
  IF numerical_solution
  THEN require residual_conditioning_and_error checks
}

RECURSION {
 ENTRY = NumericalLinearAlgebra

 EXPAND(NumericalLinearAlgebra) -> [
  Matrix,
  Vector,
  LinearSystem,
  DenseMatrix,
  SparseMatrix,
  StructuredMatrix,
  SymmetricMatrix,
  HermitianMatrix,
  PositiveDefiniteMatrix,
  BandedMatrix,
  TriangularMatrix,
  OrthogonalMatrix,
  UnitaryMatrix,
  Rank,
  NullSpace,
  ColumnSpace,
  RowSpace,
  MatrixNorm,
  VectorNorm,
  ConditionNumber,
  Residual,
  ForwardError,
  BackwardError,
  RoundoffError,
  FloatingPointArithmetic,
  DirectMethod,
  IterativeMethod,
  GaussianElimination,
  Pivoting,
  PartialPivoting,
  CompletePivoting,
  LUFactorisation,
  CholeskyFactorisation,
  QRFactorisation,
  HouseholderTransformation,
  GivensRotation,
  LeastSquares,
  NormalEquations,
  SingularValueDecomposition,
  Pseudoinverse,
  LowRankApproximation,
  EigenvalueProblem,
  Eigenvector,
  PowerIteration,
  InverseIteration,
  RayleighQuotientIteration,
  QRAlgorithm,
  LanczosMethod,
  ArnoldiMethod,
  KrylovSubspace,
  ConjugateGradient,
  MINRES,
  GMRES,
  BiCGSTAB,
  Preconditioning,
  JacobiPreconditioner,
  ILUPreconditioner,
  MultigridPreconditioner,
  MatrixFreeMethod,
  SparseDirectSolver,
  SparseIterativeSolver,
  Reordering,
  FillIn,
  ParallelLinearAlgebra
 ]

 EXPAND(DirectMethods) -> [
  GaussianElimination,
  LUFactorisation,
  CholeskyFactorisation,
  QRFactorisation,
  SingularValueDecomposition
 ]

 EXPAND(IterativeMethods) -> [
  PowerIteration,
  InverseIteration,
  RayleighQuotientIteration,
  LanczosMethod,
  ArnoldiMethod,
  ConjugateGradient,
  MINRES,
  GMRES,
  BiCGSTAB
 ]

 STOP_CONDITION =
  "Stop when matrix structure, conditioning, selected algorithm, preconditioning or factorisation, residual, error, convergence, sparsity and computational cost are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics"

 IMMEDIATE_CONTEXTS = [
  "Computational Mathematics Ontology",
  "Scientific Computing Ontology",
  "High Performance Computing Ontology",
  "Parallel Algorithms Ontology"
 ]

 RELATED_ONTOLOGIES = [
  "Computational Mathematics",
  "Computational Mathematics Ontology",
  "Scientific Computing Ontology",
  "High Performance Computing Ontology",
  "Parallel Algorithms Ontology",
  "Linear Algebra Ontologies",
  "Matrix Ontologies",
  "Eigenvalue Ontologies",
  "Optimisation Ontologies",
  "Finite Element Ontology",
  "Finite Difference Ontology",
  "Finite Volume Ontologies",
  "Spectral Method Ontology",
  "Algorithmic Complexity Ontologies"
 ]

 ROUTE_RULES = [
  "Numerical Linear Algebra -> Computational Mathematics for parent semantics",
  "Numerical Linear Algebra -> Scientific Computing for solver workflows",
  "Numerical Linear Algebra -> High Performance Computing for scalable matrix computation",
  "Numerical Linear Algebra -> Parallel Algorithms for distributed factorisation and Krylov methods",
  "Numerical Linear Algebra -> Linear Algebra for abstract matrix structure",
  "Numerical Linear Algebra -> Eigenvalue Ontologies for spectral problems",
  "Numerical Linear Algebra -> Optimisation for least-squares and iterative minimisation interpretations",
  "Numerical Linear Algebra -> Finite Element, Finite Difference, Finite Volume and Spectral Methods for assembled systems"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible matrix algorithms, factorisations or iterative pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve computational-matrix semantics.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve direct-versus-iterative method distinction.",
  "Preserve dense-versus-sparse structure.",
  "Preserve residual-versus-forward-error distinction.",
  "Preserve rank and SVD semantics.",
  "Preserve Krylov and preconditioning semantics.",
  "Preserve machine-readable numerical-linear-algebra semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Numerical linear algebra studies stable and efficient computational methods for matrix and vector problems."

 DIRECT_SUMMARY =
  "LU, Cholesky, QR and SVD factorisations provide core direct methods for linear systems, least squares and matrix analysis."

 ITERATIVE_SUMMARY =
  "Krylov subspace methods such as conjugate gradient, MINRES and GMRES solve large sparse systems iteratively."

 CONDITIONING_SUMMARY =
  "Condition numbers describe problem sensitivity, while backward and forward errors describe numerical solution quality."

 LEAST_SQUARES_SUMMARY =
  "QR and SVD methods provide numerically robust least-squares solutions, particularly near rank deficiency."

 EIGEN_SUMMARY =
  "Power, Lanczos, Arnoldi and QR methods compute eigenvalues and eigenvectors under different matrix structures and scales."

 SPARSE_SUMMARY =
  "Sparse numerical linear algebra manages storage, fill-in, ordering, preconditioning and scalable computation."

 VALIDATION_SUMMARY =
  "Numerical linear algebra results should be checked using residuals, conditioning, error estimates, convergence and structure-aware validation."
}

FLOW {
 INPUT
 -> detect_numerical_linear_algebra_context
 -> identify matrix_vector_problem_dimensions_structure_sparsity_rank_symmetry_positivity_precision_and_accuracy requirements
 -> estimate conditioning
 -> classify linear_system_leastSquares_eigenvalue_lowRank_or_matrix factorisation problem
 -> choose direct_or_iterative method
 -> if_direct apply pivoting_factorisation_and_reordering as needed
 -> if_iterative choose Krylov_method_preconditioner_and_stopping criterion
 -> compute numerical solution
 -> evaluate residual_forward_error_backward_error_rank_and_convergence
 -> assess sparse_memory_fill_parallelism_and_complexity
 -> validate matrix_structure_and_numerical quality
 -> route to computational_mathematics scientific_computing high_performance_computing parallel_algorithms linear_algebra eigenvalue optimisation finite_element finite_difference finite_volume spectral_or_algorithmic_complexity ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Linear Algebra Ontology defines computational methods for matrix and vector problems. It supports dense, sparse and structured matrices, linear systems, norms, rank and subspaces, conditioning, residuals, forward and backward error, floating-point effects, Gaussian elimination and pivoting, LU, Cholesky and QR factorisations, Householder and Givens transformations, least squares and normal equations, singular value decomposition, pseudoinverses and low-rank approximation, eigenvalue algorithms, Krylov subspaces, Lanczos and Arnoldi methods, conjugate gradient, MINRES, GMRES and BiCGSTAB, preconditioning, sparse direct and iterative solvers, reordering, fill-in, matrix-free methods and parallel linear algebra."
}

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

}

END_FLOW