Linear Transformation Entity Ontology

FLOW ALGEBRA
TITLE: Linear Transformation Entity Ontology
VERSION: 1.0
SOURCE: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/transformation-entities/linear-transformation-entity-ontology.html
AUTHORS: Mark Higgins — Sky (Recursive AI)
PROJECT: Kireth Semantic Library

1. PURPOSE
Represent linear transformations as typed mathematical entities, including their domains, codomains, matrices, kernels, images, invariants, compositions and inference rules. A linear transformation T: V -> W preserves vector addition and scalar multiplication over a common field F.

2. ENTITY TYPES
ENTITY LinearTransformation {id, name, domain:VectorSpace, codomain:VectorSpace, field:Field, mapping:Function, matrix:Matrix?, basis_domain:Basis?, basis_codomain:Basis?, properties:Set}
ENTITY VectorSpace {id, field:Field, dimension:NonNegativeInteger?}
ENTITY Vector {id, space:VectorSpace, coordinates:ScalarSequence?}
ENTITY Matrix {id, rows:NonNegativeInteger, columns:NonNegativeInteger, entries:ScalarArray, field:Field}
ENTITY Basis {id, space:VectorSpace, vectors:VectorSequence}
ENTITY Kernel {transformation:LinearTransformation, vectors:Subspace}
ENTITY Image {transformation:LinearTransformation, vectors:Subspace}
ENTITY Eigenpair {transformation:Endomorphism, eigenvalue:Scalar, eigenvector:NonzeroVector}
ENTITY LinearFunctional SUBTYPE LinearTransformation WHERE codomain=FieldAsVectorSpace
ENTITY LinearOperator SUBTYPE LinearTransformation WHERE domain=codomain

3. TYPED RELATIONSHIPS
LinearTransformation --HAS_DOMAIN--> VectorSpace
LinearTransformation --HAS_CODOMAIN--> VectorSpace
LinearTransformation --OVER_FIELD--> Field
LinearTransformation --REPRESENTED_BY--> Matrix [relative_to: ordered bases]
LinearTransformation --HAS_KERNEL--> Kernel
LinearTransformation --HAS_IMAGE--> Image
LinearTransformation --COMPOSES_WITH--> LinearTransformation [when intermediate spaces agree]
LinearTransformation --IS_INVERTIBLE_IF_AND_ONLY_IF--> BijectiveMapping
Kernel --IS_SUBSPACE_OF--> Domain
Image --IS_SUBSPACE_OF--> Codomain

4. CORE AXIOMS
For all u,v in V and a,b in F:
  T(a*u + b*v) = a*T(u) + b*T(v).
Equivalent tests:
  T(u+v) = T(u)+T(v)
  T(a*u) = a*T(u)
Consequences:
  T(0_V) = 0_W
  T(-v) = -T(v)
  T(sum_i a_i*v_i) = sum_i a_i*T(v_i) for finite sums.

5. MATRIX SEMANTICS
For finite-dimensional V and W with ordered bases B and C:
  [T(v)]_C = A * [v]_B
  A has shape dim(W) x dim(V).
  Column j of A equals [T(b_j)]_C.
Under basis changes [v]_(B') = P^(-1)[v]_B and [w]_(C') = Q^(-1)[w]_C:
  A' = Q^(-1) * A * P.
For an endomorphism with the same basis change in domain and codomain:
  A' = P^(-1) * A * P.

6. COMPOSITION AND INVERSE
For T: U -> V and S: V -> W:
  (S o T)(u) = S(T(u)); [S o T] = [S]*[T] in compatible bases.
  Composition is associative; identity is neutral.
  If T is bijective, T^(-1) is linear.
  In finite equal dimensions, invertibility iff det(A) != 0 iff rank(A)=dim(V).
  A non-square matrix can represent an injective or surjective linear map, but not an isomorphism between unequal finite dimensions.

7. KERNEL, IMAGE, RANK AND NULLITY
  ker(T) = {v in V : T(v)=0_W}
  im(T) = {T(v) : v in V}
  T injective iff ker(T)={0_V}.
  T surjective iff im(T)=W.
For finite-dimensional V:
  dim(V) = dim(ker(T)) + dim(im(T)).
  nullity(T) = dim(ker(T)); rank(T) = dim(im(T)).

8. SPECIAL CASES AND DISTINCTIONS
  Identity: I(v)=v.
  Zero map: Z(v)=0.
  Projection: P^2=P (idempotent).
  Reflection through a linear subspace: linear when origin is fixed.
  Rotation about the origin: linear in Euclidean coordinates.
  Scaling: T(v)=c*v is linear for scalar c.
  Shear: linear when expressed without translation.
  Translation T(v)=v+b is NOT linear unless b=0; it is affine.
  General affine mapping v -> A*v+b is linear iff b=0.
  Nonlinear coordinate changes (e.g. Cartesian to polar) are not generally linear maps.

9. INFERENCE RULES
RULE LINEARITY_CHECK:
  IF addition_preserved(T) AND scalar_multiplication_preserved(T)
  THEN classify(T,LinearTransformation).
RULE ZERO_TEST:
  IF T(0_V) != 0_W THEN reject_linear(T).
  NOTE: T(0_V)=0_W alone does not prove linearity.
RULE MATRIX_REPRESENTATION:
  IF finite_dimensional(V,W) AND ordered_bases(B,C)
  THEN construct_matrix(T,B,C).
RULE INJECTIVITY:
  IF kernel(T)={0_V} THEN infer(injective(T)).
RULE SURJECTIVITY:
  IF image(T)=W THEN infer(surjective(T)).
RULE ISOMORPHISM:
  IF injective(T) AND surjective(T) THEN infer(invertible_linear_map(T)).
RULE COMPOSITION:
  IF linear(T) AND linear(S) AND codomain(T)=domain(S)
  THEN infer(linear(S o T)).
RULE RANK_NULLITY:
  IF finite_dimensional(domain(T))
  THEN assert(rank(T)+nullity(T)=dim(domain(T))).

10. VALIDATION CONSTRAINTS
  VALIDATE common_field(domain,codomain).
  VALIDATE matrix_dimensions=(dim(codomain),dim(domain)) when finite bases supplied.
  VALIDATE ordered_basis_vectors are independent and span their spaces.
  VALIDATE composition type compatibility.
  VALIDATE inverse only if bijective.
  VALIDATE eigenpairs only for endomorphisms and nonzero eigenvectors.
  VALIDATE eigenvalue equation T(v)=lambda*v.
  VALIDATE rank <= min(dim(domain),dim(codomain)) in finite dimensions.
  VALIDATE transformation_is_linear using both defining axioms.

11. WORKED EXAMPLES
EXAMPLE A: T:R^2 -> R^2, T(x,y)=(2*x,3*y).
  A=[[2,0],[0,3]], rank=2, nullity=0, invertible=true.
EXAMPLE B: T:R^3 -> R^2, T(x,y,z)=(x+y,z).
  A=[[1,1,0],[0,0,1]], rank=2, nullity=1,
  ker(T)=span{(-1,1,0)}, surjective=true, injective=false.
EXAMPLE C: F:R^2 -> R^2, F(x,y)=(x+4,y).
  F(0,0)=(4,0), so F is affine but not linear.
EXAMPLE D: P:R^2 -> R^2, P(x,y)=(x,0).
  A=[[1,0],[0,0]], P^2=P, rank=1, nullity=1.

12. SEMANTIC EQUIVALENCE
  'linear map' ~= 'linear transformation' ~= 'vector-space homomorphism' (same field).
  'linear operator' denotes a linear endomorphism in standard usage.
  'matrix transformation' denotes a representation-dependent linear mapping when no translation is included.
  DO_NOT_EQUIVALATE linear transformation with affine transformation in general.

13. CONFIDENCE AND PROVENANCE
  CONFIDENCE: 1.0 for standard definitions and proved algebraic consequences.
  PROVENANCE: Standard linear algebra; linked ontology page supplies topic and classification.
  ASSUMPTIONS: Vector spaces over the same field; finite-dimensional qualifications explicit.
  UPDATE_MODEL: Revise examples, nomenclature and dependencies with versioned provenance.

14. FLOW HASH AND AI CONSUMPTION
  FLOW_HASH_INPUT: canonical(title,version,entity_types,relationships,axioms,rules,constraints).
  FLOW_HASH: COMPUTE_SHA256_AT_INGESTION (not precomputed).
  AI_CONSUMPTION:
    parsing: UTF-8 plain text
    semantic_index: transformation, vector space, matrix, linearity, kernel, image, rank, nullity
    reasoning: type-check -> verify axioms -> apply rules -> validate result
    outputs: structured entity graph, symbolic relations, verified examples
    uncertainty: do not assert linearity from finite test points alone.

END FLOW ALGEBRA