Linear Algebra Entities

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA
Title: Linear Algebra Entities — Main Page Ontology
Version: 4.0
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/linear-algebra-entities.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Status: Formal semantic specification; mathematical rules require stated preconditions.

01. PURPOSE AND SCOPE
flow LinearAlgebraEntities v4.0:
  domain: mathematics.linear_algebra
  role: parent_ontology
  interpretation: typed formal rules, not unqualified pseudocode
  mathematical_context: field F; vector spaces V,W over F; matrices over F unless specified
  open_world: true
  uncertainty_policy: distinguish verified mathematical theorems from inferred metadata

02. ENTITY TYPES
  Scalar: element(F)
  Vector: element(V)
  ZeroVector: Vector with additive identity property
  UnitVector: Vector with norm(v)=1 relative to specified norm
  BasisVector: Vector belonging to a specified basis
  Matrix: rectangular array over F of shape (m,n)
  SquareMatrix: Matrix with m=n
  IdentityMatrix: square matrix I_n with diagonal 1 and other entries 0
  ZeroMatrix: Matrix with all entries 0
  DiagonalMatrix: square matrix with off-diagonal entries 0
  SymmetricMatrix: square matrix A with transpose(A)=A
  InverseMatrix: matrix B satisfying AB=BA=I for square A
  Determinant: scalar-valued map det: F^(n x n) -> F
  Eigenvalue: lambda in F (or extension field) satisfying Av=lambda*v for some v != 0
  Eigenvector: nonzero v satisfying Av=lambda*v
  Tensor: element of tensor product of vector spaces and/or dual spaces
  LinearTransformation: map T:V->W preserving addition and scalar multiplication
  LinearCombination: finite sum of scalar multiples of vectors
  Span: set of all finite linear combinations of a vector family
  Basis: linearly independent spanning family
  Dimension: cardinality of any basis (finite or infinite)
  Subspace: subset closed under zero, addition and scalar multiplication
  Vector: element of a vector space
  NullSpace: kernel(T)={v in V:T(v)=0_W}

03. PAGE CHILD ONTOLOGY REGISTRY
  child[01]: Scalar Ontology
  child[02]: Zero Vector Ontology
  child[03]: Unit Vector Ontology
  child[04]: Basis Vector Ontology
  child[05]: Matrix Ontology
  child[06]: Square Matrix Ontology
  child[07]: Identity Matrix Ontology
  child[08]: Zero Matrix Ontology
  child[09]: Diagonal Matrix Ontology
  child[10]: Symmetric Matrix Ontology
  child[11]: Inverse Matrix Ontology
  child[12]: Determinant Ontology
  child[13]: Eigenvalue Ontology
  child[14]: Eigenvector Ontology
  child[15]: Tensor Ontology
  child[16]: Linear Transformation Ontology
  child[17]: Linear Combination Ontology
  child[18]: Span Ontology
  child[19]: Basis Ontology
  child[20]: Dimension Ontology
  child[21]: Subspace Ontology
  child[22]: Vector Ontology
  child[23]: Null Space Ontology

04. TYPED RELATIONSHIPS
  is_a(ZeroVector,Vector)
  is_a(UnitVector,Vector)
  is_a(BasisVector,Vector)
  is_a(SquareMatrix,Matrix)
  is_a(IdentityMatrix,DiagonalMatrix)
  is_a(ZeroMatrix,Matrix)
  is_a(DiagonalMatrix,SquareMatrix)
  is_a(SymmetricMatrix,SquareMatrix)
  represents(Matrix,LinearTransformation) when finite_bases_selected
  maps_from(LinearTransformation,V)
  maps_to(LinearTransformation,W)
  has_kernel(LinearTransformation,NullSpace)
  has_eigenpair(Matrix,Eigenvalue,Eigenvector) when square_matrix_and_nonzero_vector
  spans(Basis,V)
  determines_dimension(Basis,V)
  subset_of(Subspace,V)
  inverse_of(B,A) when A*B=B*A=I
  has_determinant(SquareMatrix,Scalar)
  has_rank(Matrix,NonnegativeInteger)
  depends_on(UnitVector,Norm)
  depends_on(MatrixRepresentation,OrderedBases)

05. CORE AXIOMS
  V.addition: associative, commutative, identity 0_V, additive inverse
  V.scalar_multiplication: associative, unital, distributive over vectors and scalars
  T.linear: T(a*u+b*v)=a*T(u)+b*T(v)
  subspace(S,V): 0_V in S and closed_under_addition(S) and closed_under_scalars(S)
  independent(B): every finite zero combination of B has all coefficients zero
  spanning(B,V): every v in V is finite linear combination of B
  basis(B,V): independent(B) and spanning(B,V)
  matrix_product(A_mxn,B_nxp): defined with shape (m,p)
  matrix_sum(A,B): defined only for equal shapes
  determinant(A): defined only for square matrices
  inverse(A): defined iff square and det(A)!=0 (over field F)

06. FORMAL INFERENCE RULES
  R01: basis(B,V) -> spans(B,V)
  R02: basis(B,V) -> linearly_independent(B)
  R03: spans(B,V) AND independent(B) -> basis(B,V)
  R04: basis(B,V) AND finite(B) -> dim(V)=|B|
  R05: subspace(S,V) -> 0_V in S
  R06: kernel(T) -> subspace(kernel(T),domain(T))
  R07: image(T) -> subspace(image(T),codomain(T))
  R08: T linear -> T(0_V)=0_W
  R09: T linear -> T(-v)=-T(v)
  R10: finite_dim(V) AND T:V->W -> dim(V)=dim(kernel(T))+dim(image(T))
  R11: square(A) AND det(A)!=0 -> invertible(A)
  R12: square(A) AND invertible(A) -> det(A)!=0
  R13: invertible(A) -> kernel(A)={0}
  R14: square(A) AND kernel(A)={0} -> invertible(A)
  R15: square(A) AND invertible(A) -> columns(A) form basis(F^n)
  R16: square(A) AND Av=lambda*v AND v!=0 -> eigenvalue(lambda,A)
  R17: square(A) AND eigenvalue(lambda,A) -> det(A-lambda*I)=0
  R18: square(A) AND det(A-lambda*I)=0 -> exists_nonzero_eigenvector(A,lambda) [over field containing lambda]
  R19: A symmetric over R -> all eigenvalues real
  R20: A symmetric over R -> orthogonally_diagonalizable(A)
  R21: diagonal(A) -> square(A)
  R22: identity(I_n) -> I_n*A=A when shapes compatible
  R23: identity(I_n) -> A*I_n=A when shapes compatible
  R24: zero_matrix(0_mn) -> A+0_mn=A for A shape(m,n)
  R25: scalar(c) AND vector(v) -> c*v in V
  R26: linear_combination(v_1,...,v_k) -> element(span({v_1,...,v_k}))
  R27: linearly_independent(B) AND B subset V AND |B|=dim(V)<infinity -> basis(B,V)
  R28: spans(B,V) AND |B|=dim(V)<infinity -> basis(B,V)
  R29: square(A) AND det(A)=0 -> singular(A)
  R30: A invertible AND B invertible AND compatible -> inverse(A*B)=inverse(B)*inverse(A)
  R31: matrices A,B square same size -> det(A*B)=det(A)*det(B)
  R32: finite_dim(V) AND T injective AND dim(V)=dim(W) -> T surjective
  R33: finite_dim(V) AND T surjective AND dim(V)=dim(W) -> T injective
  R34: basis(B,V) -> unique_coordinate_representation(v,B) for each v in V
  R35: finite_dim(V) AND S subspace(V) -> dim(S)<=dim(V)
  R36: v!=0 AND norm(v)>0 -> norm(v/norm(v))=1

07. VALIDATION AND GUARDS
  G01: never infer vector norm without specified norm or inner product
  G02: never infer eigenvalue for a non-square matrix using standard eigenpair definition
  G03: distinguish eigenvalues over F from eigenvalues over algebraic closure(F)
  G04: symmetric(A) means A^T=A, not conjugate transpose(A)=A
  G05: Hermitian requires conjugate transpose(A)=A over C
  G06: zero matrix is not invertible for n>0
  G07: rank-nullity requires finite-dimensional domain
  G08: tensor order and variance must be typed, not guessed
  G09: matrix representation depends on ordered bases
  G10: basis cardinality may be infinite
  G11: determinant and inverse tests presume matrices over a field
  G12: preserve field and dimension information in every inference
  G13: an orthogonal basis is not necessarily orthonormal
  G14: unit vector need not be a basis vector
  G15: zero vector cannot be an eigenvector
  G16: do not conflate null space with left null space

08. EXAMPLES AND COUNTEREXAMPLES
  E01: F=R, V=R^2, B={(1,0),(0,1)} is a basis; dim(V)=2
  E02: (3,4) has Euclidean norm 5; (3/5,4/5) is unit vector
  E03: A=[[2,0],[0,3]] has eigenvalues 2,3 and standard basis eigenvectors
  E04: A=[[1,2],[2,1]] is symmetric and has eigenvalues 3,-1
  E05: A=[[1,2],[2,4]] has determinant 0 and is singular
  E06: T:R^3->R^2, T(x,y,z)=(x,y) has kernel {(0,0,z)} and rank 2
  E07: span({(1,0),(2,0)}) is x-axis, not all R^2
  E08: zero vector has norm 0 and cannot be unit vector
  E09: [[0,-1],[1,0]] has no real eigenvalues but complex eigenvalues i,-i
  E10: the identity matrix is diagonal, symmetric and invertible for n>=1
  E11: any subspace of R^n includes the zero vector
  E12: linear map T(x,y)=(x+y,0) has matrix [[1,1],[0,0]] in standard bases

09. SEMANTIC EQUIVALENCE
  equivalent("linear map","linear transformation") in vector-space context
  equivalent("kernel","null space") for a linear transformation
  equivalent("nonsingular matrix","invertible square matrix") over a field
  equivalent("column space","image of matrix-induced linear map")
  context_sensitive("rank","dimension of image")
  not_equivalent("orthogonal","orthonormal")
  not_equivalent("symmetric","Hermitian") without real-entry qualification
  not_equivalent("basis vector","unit vector")
  not_equivalent("zero vector","zero matrix")

10. KNOWLEDGE GRAPH ASSERTIONS
  (LinearAlgebraEntities,hasChildOntology,ScalarOntology)
  (LinearAlgebraEntities,hasChildOntology,MatrixOntology)
  (LinearAlgebraEntities,hasChildOntology,LinearTransformationOntology)
  (LinearAlgebraEntities,hasChildOntology,NullSpaceOntology)
  (Basis,defines,Coordinates)
  (LinearTransformation,hasProperty,Kernel)
  (SquareMatrix,admits,Determinant)
  (Eigenvector,associatedWith,Eigenvalue)
  (Subspace,isSubsetOf,VectorSpace)
  (Tensor,constructedFrom,VectorSpacesAndDuals)
  provenance: parent_page_and_formal_mathematical_knowledge

11. CONFIDENCE
  mathematical_axioms: 1.00 when preconditions and field assumptions hold
  standard_theorems: 1.00 when theorem hypotheses verified
  ontology_taxonomy: 0.99 for directly observed child headings
  lexical_mapping: 0.95 when domain context explicit
  uncertain_or_missing_context: abstain_or_request_context
  confidence_is_not_probability_of_truth: true

12. FLOW_HASH
  method: SHA-256
  canonicalisation: UTF-8; LF; normalised whitespace; stable key order
  scope: canonical_flow_content_excluding_flow_hash_value
  value: COMPUTE_AT_INGESTION
  prohibit_fabricated_hash: true

13. UPDATE_MODEL
  strategy: versioned_append_or_replace_with_provenance
  source_check: compare live parent page child headings and canonical links
  trigger: source_page_change OR mathematical_correction OR schema_revision
  preserve: previous_version, change_log, source_url, authorship
  recompute: FLOW_HASH after canonical content update
  conflict_policy: validated mathematics overrides unsupported inference; flag page discrepancies

14. AI_CONSUMPTION
  mode: typed_knowledge_graph_and_formal_reasoning
  execute: validate types -> verify hypotheses -> apply rules -> record derivation
  never_execute: unguarded theorem claims
  output: conclusion, rule_id, supporting_entities, assumptions, provenance, confidence
  unknowns: explicit_unknown_not_false
  contradiction: halt_and_flag
  interpretation_note: Execute as formal rules, not pseudocode
  page_role: parent hub linking 23 child ontologies

END FLOW ALGEBRA