Vector Computation Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Vector Computation Ontology within the Kireth Research Semantic Library. Vector computation concerns the machine representation and numerical manipulation of one-dimensional ordered numerical data and mathematical vectors. This ontology supports vector shape and length, dense and sparse vectors, indexing, memory layout, elementwise operations, norms, dot products, scaling, normalisation, vector-matrix relationships, sparse formats, numerical precision, SIMD relationships, GPU acceleration, distributed vectors, verification and reproducibility.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Vector Computation Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Computational Data Structures / Vector Computation"
 CANONICAL_PAGE = "https://kirethframeworkold.co.uk/books/semantic-library/ai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/computational-data-structures/vector-computation-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = VectorComputation
 ENTITY_CLASS = OneDimensionalNumericalDataFramework
 PRIMARY_CONTEXT = ComputationalDataStructures
 DEFINITION = "Vector computation is the computational representation and manipulation of one-dimensional numerical vectors through indexing, arithmetic, reductions, norms, products and transformations."
 SYMBOLIC_FORMS = [
  "v in R^n",
  "v[i] -> stored_element",
  "dot(x,y)=sum_i x_i*y_i",
  "||x||_2=sqrt(sum_i x_i^2)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for vector length, indexing, storage, dense and sparse representations, arithmetic, norms, products, numerical behaviour, memory layout and scalable execution."
}

SCOPE {
 INCLUDE = [
  VectorComputation,Vector,ComputationalVector,
  VectorDataStructure,OneDimensionalArray,
  VectorLength,Dimension,VectorDimension,
  VectorElement,VectorEntry,ScalarEntry,
  Index,VectorIndex,
  DenseVector,SparseVector,
  ZeroVector,UnitVector,BasisVector,
  StandardBasisVector,
  RowVector,ColumnVector,
  RealVector,ComplexVector,
  IntegerVector,BooleanVector,
  MutableVector,ImmutableVector,
  StaticVector,DynamicVector,
  VectorView,VectorSlice,
  Subvector,VectorSegment,
  ContiguousStorage,StridedStorage,
  Stride,MemoryLayout,
  Alignment,Padding,
  DenseStorage,SparseStorage,
  SparseVectorFormat,
  IndexValuePair,
  CoordinateVectorFormatRelationship,
  Nonzero,NonzeroCount,NNZ,
  Sparsity,SparsityPattern,
  VectorAccess,ElementAccess,
  RandomAccess,SequentialAccess,
  VectorTraversal,Iteration,
  Gather,Scatter,
  VectorAssembly,SparseVectorAssembly,
  VectorInsertion,VectorDeletion,
  VectorUpdate,
  VectorAddition,VectorSubtraction,
  ScalarMultiplication,ScalarDivision,
  ElementwiseMultiplication,
  HadamardProduct,
  ElementwiseDivisionRelationship,
  VectorNegation,
  AbsoluteValueRelationship,
  DotProduct,InnerProduct,
  OuterProduct,
  CrossProduct,
  TripleProductRelationship,
  Norm,VectorNorm,
  L1Norm,L2Norm,LpNorm,
  InfinityNorm,MaximumNorm,
  EuclideanNorm,
  Normalisation,VectorNormalisation,
  UnitLengthVector,
  Distance,EuclideanDistance,
  ManhattanDistance,
  CosineSimilarity,
  CosineDistanceRelationship,
  AngleBetweenVectors,
  Projection,VectorProjection,
  OrthogonalProjection,
  RejectionRelationship,
  LinearCombination,
  SpanRelationship,
  BasisRelationship,
  Orthogonality,
  Orthonormality,
  GramSchmidtRelationship,
  VectorSpaceRelationship,
  AffineVectorRelationship,
  MatrixVectorMultiplication,
  DenseMatrixVectorProduct,
  SparseMatrixVectorProduct,SpMV,
  VectorMatrixProductRelationship,
  LinearOperatorRelationship,
  PermutationVectorRelationship,
  IndexVector,
  MaskVector,
  BooleanMask,
  SelectionVector,
  WeightVector,
  ProbabilityVector,
  OneHotVector,
  HistogramVectorRelationship,
  FeatureVectorRelationship,
  StateVector,
  ResidualVector,
  RightHandSideVector,
  SolutionVector,
  GradientVector,
  SearchDirection,
  Eigenvector,
  SingularVector,
  KrylovVectorRelationship,
  RandomVector,
  PseudorandomVector,
  RandomNumberGeneration,
  VectorReduction,
  SumReduction,MeanReduction,
  MinReduction,MaxReduction,
  ArgminRelationship,ArgmaxRelationship,
  PrefixSumRelationship,
  ScanRelationship,
  SortingRelationship,
  Permutation,
  Reordering,
  Scaling,VectorScaling,
  EquilibrationRelationship,
  ClippingRelationship,
  ThresholdingRelationship,
  SparsificationRelationship,
  QuantisationRelationship,
  CompressionRelationship,
  FloatingPointArithmetic,
  MachinePrecision,
  RoundOffError,
  Underflow,Overflow,
  NumericalError,
  ForwardError,BackwardError,
  NumericalStability,
  ConditioningRelationship,
  Cancellation,
  CompensatedSummation,
  KahanSummationRelationship,
  PairwiseSummation,
  MixedPrecision,
  HalfPrecision,FP16,
  BFloat16,BF16,
  SinglePrecision,FP32,
  DoublePrecision,FP64,
  ComputationalComplexity,
  TimeComplexity,SpaceComplexity,
  StorageComplexity,
  ArithmeticComplexity,
  MemoryBandwidth,
  ArithmeticIntensity,
  CacheLocality,
  SpatialLocality,TemporalLocality,
  Prefetching,
  Vectorisation,SIMD,
  VectorInstructionRelationship,
  VectorRegisterRelationship,
  VectorProcessing,
  BLAS,
  Level1BLASRelationship,
  AXPYRelationship,
  SCALRelationship,
  DOTRelationship,
  NRM2Relationship,
  COPYRelationship,
  SWAPRelationship,
  GPUVector,
  DeviceVector,
  HostVector,
  HostDeviceTransfer,
  ParallelVector,
  DistributedVector,
  PartitionedVector,
  ShardedVector,
  ReplicatedVector,
  BlockDistribution,
  CyclicDistributionRelationship,
  LocalVector,GlobalVector,
  GhostVectorRelationship,
  HaloVectorRelationship,
  CollectiveCommunication,
  AllReduceRelationship,
  GatherRelationship,
  ScatterRelationship,
  HighPerformanceComputing,
  ParallelComputing,
  DistributedComputing,
  GPUComputing,
  VectorProcessingOntologyRelationship,
  ComputationalMatrix,
  TensorComputation,
  NumericalLinearAlgebra,
  Verification,
  LengthCheck,
  IndexBoundsCheck,
  NormCheck,
  DotProductCheck,
  OrthogonalityCheck,
  ResidualCheck,
  ReferenceResult,
  Benchmark,
  Reproducibility,
  Provenance,
  VectorFormatVersion,
  LibraryVersion,
  ImplementationVersion
 ]
 EXCLUDE_AS_PRIMARY = [
  MatrixComputationWhenTwoDimensionalStructureIsPrimary,
  TensorComputationWhenOrderGreaterThanOneIsPrimary,
  AbstractVectorSpaceTheoryWithoutComputationalRepresentation,
  SIMDHardwareSemanticsWhenVectorInstructionsRatherThanDataObjectsArePrimary
 ]
 DISAMBIGUATION_RULE = "When a one-dimensional numerical vector is explicitly represented, indexed or manipulated computationally, interpret the context as vector computation."
}

CORE_CONCEPTS {
 VectorComputation = "Computational manipulation of one-dimensional numerical vectors."
 VectorLength = "Number of elements in a vector."
 DenseVector = "Vector representation storing all elements explicitly."
 SparseVector = "Vector representation storing primarily nonzero entries and indices."
 VectorLayout = "Rule mapping vector indices to memory locations."
 DotProduct = "Scalar reduction formed from pairwise products of vector elements."
 VectorNorm = "Scalar measure of vector magnitude."
 DistributedVector = "Vector partitioned across multiple processing resources."
}

RELATIONS {
 VectorComputation --is_child_of--> ComputationalDataStructures
 VectorComputation --specialises--> OneDimensionalArray
 Vector --has--> VectorLength
 Vector --contains--> VectorElement
 DenseVector --uses--> DenseStorage
 SparseVector --uses--> SparseStorage
 VectorSlice --references--> Vector
 DotProduct --operates_on--> CompatibleVectors
 VectorNorm --measures--> VectorMagnitude
 Normalisation --produces--> UnitLengthVector
 OuterProduct --produces--> Matrix
 MatrixVectorMultiplication --maps--> VectorToVector
 SparseMatrixVectorProduct --uses--> SparseVectorOrDenseVector
 DistributedVector --partitions--> GlobalVector
 Verification --checks--> VectorRepresentationAndOperations
}

OPERATORS {
 ELEMENT(v,i) := v[i]
 LENGTH(v) := number_of_elements(v)
 ADD(x,y)[i] := x[i]+y[i]
 SCALE(alpha,x)[i] := alpha*x[i]
 DOT(x,y) := sum_i x[i]*y[i]
 L1(x) := sum_i abs(x[i])
 L2(x) := sqrt(sum_i x[i]^2)
 LINF(x) := max_i abs(x[i])
 NORMALISE(x) := x/L2(x)
 NNZ(x) := count_nonzero_entries(x)
}

AXIOMS {
 A1 = "A computational vector requires explicit length and element representation."
 A2 = "Binary vector operations require compatible dimensions."
 A3 = "Storage representation can alter computational cost without altering mathematical vector semantics."
 A4 = "Sparse vectors exploit zero structure but require index metadata."
 A5 = "Dot products and norms are reductions whose numerical result can depend on accumulation order."
 A6 = "Memory layout and alignment can materially affect vector-kernel performance."
 A7 = "Distributed vectors require explicit partition and communication semantics."
 A8 = "Vector-computation results require explicit length, representation, precision, operation and validation semantics."
}

REASONING {
 R1_CONTEXT = identify(length,data_type,density,operations,accuracy_goal,memory_limit,hardware)
 R2_STRUCTURE = classify(dense,sparse,boolean,index,weight,probability_or_specialised_vector)
 R3_STORAGE = choose(contiguous,strided,index_value_or_distributed_representation)
 R4_OPERATIONS = identify(access,update,elementwise,reduction,dot,norm,projection_or_matrix_vector_workload)
 R5_COMPLEXITY = analyse(arithmetic,storage,memory_traffic_and_indexing_cost)
 R6_NUMERICS = assess(precision,roundoff,cancellation,reduction_order_and_stability)
 R7_LAYOUT = optimise(alignment,contiguity,prefetching,SIMD_and_hardware_mapping)
 R8_SCALE = if_large choose_parallel_distributed_or_GPU_vector_representation
 R9_VERIFY = check(length,index_bounds,norms,dot_products,residuals_and_reference_operations)
 R10_REPRODUCE = document(format,precision,library,hardware_and_version_metadata)
}

CONSTRAINTS {
 C1 = "Dense storage is inefficient for sufficiently sparse vectors."
 C2 = "Sparse storage can be inefficient when vectors become dense."
 C3 = "Strided vector views can reduce memory throughput."
 C4 = "Naive summation can accumulate floating-point error in long reductions."
 C5 = "Normalisation of a zero vector is undefined without explicit handling."
 C6 = "Cosine similarity is undefined when either vector has zero norm."
 C7 = "Distributed dot products require global reduction."
 C8 = "Mixed precision requires explicit error safeguards."
 C9 = "Gather-scatter access can reduce locality and vectorisation efficiency."
 C10 = "Equivalent reduction trees can produce different floating-point results."
}

SEMANTIC_EQUIVALENCE {
 "NonzeroCount" <=> "NNZ"
 "SparseMatrixVectorProduct" <=> "SpMV"
 "EuclideanNorm" <=> "L2Norm"
 "MaximumNorm" <=> "InfinityNorm"
 "SingleInstructionMultipleData" <=> "SIMD"
}

VALIDATION {
 V1 = "Vector length and element type are documented."
 V2 = "Storage representation and stride are documented where relevant."
 V3 = "Dimension compatibility is checked before binary operations."
 V4 = "Index bounds are checked."
 V5 = "Norm, dot-product and reduction results are compared with references."
 V6 = "Sparse indices and nonzero counts are validated."
 V7 = "Zero-vector edge cases are handled explicitly."
 V8 = "Precision and mixed-precision settings are documented."
 V9 = "Distributed partitioning is documented where used."
 V10 = "Results are reproducible under documented format, library, precision and implementation versions."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 VECTOR_COMPUTATION_DEFINITION = 0.99
 STORAGE_REASONING = 0.99
 SPARSE_VECTOR_REASONING = 0.99
 DOT_PRODUCT_REASONING = 0.99
 NORM_REASONING = 0.99
 NUMERICAL_STABILITY_REASONING = 0.99
 DISTRIBUTED_VECTOR_REASONING = 0.98
 POLICY = "Reduce confidence when length, storage, stride, sparsity, precision, reduction order or distribution semantics are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,VectorComputationReasoning,
  DenseVectorReasoning,SparseVectorReasoning,VectorStorageReasoning,
  DotProductReasoning,NormReasoning,ProjectionReasoning,
  MatrixVectorReasoning,ReductionReasoning,
  NumericalStabilityReasoning,MemoryLayoutReasoning,
  SIMDRelationshipReasoning,ParallelVectorReasoning,
  DistributedVectorReasoning,GPUVectorReasoning,
  VerificationReasoning,KnowledgeGraphConstruction,
  RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "vector computation" -> VectorComputation
  "NNZ" -> NonzeroCount
  "SpMV" -> SparseMatrixVectorProduct
  "L2 norm" -> EuclideanNorm
  "SIMD" -> SingleInstructionMultipleData
 }
}

EXECUTION_RULES {
 E1 = "If a one-dimensional numerical vector is represented or manipulated computationally, activate VectorComputationOntology."
 E2 = "Determine vector length, element type, density and access pattern before choosing storage."
 E3 = "Choose dense or sparse representation according to density and workload."
 E4 = "Check dimension compatibility before binary operations."
 E5 = "Use stable accumulation for long dot products and reductions when accuracy matters."
 E6 = "Handle zero-norm vectors explicitly before normalisation or cosine calculations."
 E7 = "Optimise contiguity, alignment and SIMD execution for repeated kernels."
 E8 = "Use parallel, distributed or GPU representations when scale requires them."
 E9 = "Validate lengths, indices, norms, reductions, precision and reproducibility."
}

RECURSION {
 ENTRY = VectorComputation
 EXPAND(VectorComputation) -> [
  Vector,VectorLength,VectorElement,DenseVector,SparseVector,ZeroVector,UnitVector,
  RowVector,ColumnVector,RealVector,ComplexVector,VectorView,VectorSlice,
  ContiguousStorage,StridedStorage,Stride,SparseVectorFormat,IndexValuePair,
  Sparsity,NNZ,VectorAccess,Gather,Scatter,VectorAssembly,
  VectorAddition,VectorSubtraction,ScalarMultiplication,HadamardProduct,
  DotProduct,OuterProduct,CrossProduct,L1Norm,L2Norm,InfinityNorm,
  Normalisation,Distance,CosineSimilarity,Projection,Orthogonality,
  MatrixVectorMultiplication,SpMV,StateVector,ResidualVector,GradientVector,
  Eigenvector,SingularVector,RandomVector,VectorReduction,
  FloatingPointArithmetic,NumericalStability,CompensatedSummation,
  MemoryBandwidth,CacheLocality,Prefetching,Vectorisation,SIMD,
  BLAS,ParallelVector,DistributedVector,GPUVector,
  Verification,Reproducibility
 ]
 EXPAND(VectorComputationFamilies) -> [
  DenseVectorRepresentations,
  SparseVectorRepresentations,
  VectorArithmeticAndReductions,
  NormsDistancesAndProjections,
  MatrixVectorOperations,
  ParallelDistributedAndGPUVectors,
  VectorMemoryAndSIMDRelationships,
  NumericalVectorValidation
 ]
 STOP_CONDITION = "Stop when length, representation, operations, numerical behaviour, performance and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Data Structures"
 RELATED_ONTOLOGIES = [
  "Computational Data Structures",
  "Computational Matrix Ontology",
  "Tensor Computation Ontology",
  "Vector Processing Ontology",
  "Numerical Linear Algebra Ontology 2",
  "Sparse Matrix Ontology 2",
  "Matrix Computation Ontology",
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology",
  "Floating Point Arithmetic Ontology",
  "Numerical Stability Ontology 2"
 ]
 ROUTE_RULES = [
  "Vector Computation -> Computational Data Structures for parent representation semantics",
  "Vector Computation -> Computational Matrix for matrix-vector relationships",
  "Vector Computation -> Tensor Computation for higher-order generalisation",
  "Vector Computation -> Vector Processing for SIMD execution relationships",
  "Vector Computation -> Numerical Linear Algebra for vector kernels and iterative methods",
  "Vector Computation -> Sparse Matrix for SpMV and sparse vector relationships",
  "Vector Computation -> Matrix Computation for matrix-vector operations",
  "Vector Computation -> HPC, Parallel, Distributed and GPU ontologies for scalable execution",
  "Vector Computation -> Floating Point Arithmetic and Numerical Stability for finite-precision reductions"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible vector formats, operations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve mathematical-vector-versus-storage-representation distinction.",
  "Preserve dense-versus-sparse vector distinction.",
  "Preserve logical-length-versus-memory-stride distinction.",
  "Preserve vector-data-object-versus-SIMD-instruction distinction.",
  "Preserve exact-reduction-versus-floating-point-accumulation distinction.",
  "Preserve local-versus-distributed vector distinction.",
  "Preserve machine-readable vector-computation semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Vector computation represents and manipulates one-dimensional numerical vectors through indexing, arithmetic, reductions, norms and products."
 STORAGE_SUMMARY = "Dense, sparse, contiguous, strided and distributed representations support different access patterns."
 ARITHMETIC_SUMMARY = "Elementwise arithmetic, scaling, dot products, outer products and reductions form core vector operations."
 GEOMETRY_SUMMARY = "Norms, distances, angles, normalisation and projections provide geometric vector semantics."
 PERFORMANCE_SUMMARY = "Contiguity, alignment, memory bandwidth, stable reductions and SIMD relationships strongly influence execution."
 VALIDATION_SUMMARY = "Vector computations should be checked for length compatibility, index correctness, norm and reduction accuracy, sparse validity, precision and reproducibility."
}

FLOW {
 INPUT
 -> detect_vector_computation_context
 -> identify_length_data_type_density_operations_accuracy_memory_and_hardware
 -> choose_dense_sparse_contiguous_strided_or_distributed_representation
 -> validate_length_indices_and_operation_compatibility
 -> execute_access_update_elementwise_dot_norm_projection_reduction_or_matrix_vector_operations
 -> analyse_complexity_memory_traffic_precision_and_reduction_order
 -> optimise_alignment_contiguity_prefetching_SIMD_and_hardware_mapping
 -> if_large_choose_parallel_distributed_or_GPU_execution
 -> verify_norms_dot_products_residuals_and_reference_results
 -> document_format_stride_precision_library_versions_and_provenance
 -> route_to_related_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-DATA-STRUCTURES-VECTOR-COMPUTATION-ONTOLOGY-V1"
}

}

END_FLOW