Linear Transformation Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the mathematical ontology of linear transformations within linear algebra. A linear transformation is a mapping between vector spaces that preserves vector addition and scalar multiplication. This record is intended for semantic retrieval, recursive mathematical reasoning, ontology linking, and AI consumption within the Kireth Research Semantic Library.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
    PRIMARY_ENTITY = LinearTransformation
    SYMBOLIC_FORMS = ["T: V -> W", "L: V -> W", "T(v)"]
    ENTITY_CLASS = StructurePreservingMap
    PRIMARY_CONTEXT = LinearAlgebra
    DEFINITION = "A linear transformation T: V -> W is a mapping between vector spaces that preserves vector addition and scalar multiplication."
    COMBINED_FORM = "T(a u + b v)=aT(u)+bT(v)"
}

SCOPE {
    INCLUDE = [
        LinearTransformation,
        LinearMap,
        VectorSpaceDomain,
        VectorSpaceCodomain,
        Additivity,
        Homogeneity,
        Kernel,
        Image,
        Rank,
        Nullity,
        Injectivity,
        Surjectivity,
        Bijectivity,
        MatrixRepresentation,
        Composition,
        IdentityMap,
        InverseLinearTransformation,
        RankNullityTheorem
    ]

    EXCLUDE_AS_PRIMARY = [
        NonlinearTransformation,
        AffineTransformationWithoutLinearQualification,
        PhysicalTransformation,
        DigitalImageTransformation,
        OrganisationalTransformation
    ]

    DISAMBIGUATION_RULE =
        "When linear transformation occurs with vector spaces, matrices, kernels, images, bases, rank, nullity, coordinates or mappings, interpret it as the standard linear-algebraic concept."
}

CORE_CONCEPTS {

    LinearTransformation {
        definition =
            "A mapping T: V -> W satisfying additivity and scalar homogeneity."

        additivity =
            "T(u+v)=T(u)+T(v)"

        homogeneity =
            "T(a v)=aT(v)"

        combined_linearity =
            "T(a u+b v)=aT(u)+bT(v)"
    }

    DomainVectorSpace {
        definition =
            "The source vector space V on which the linear transformation acts."
    }

    CodomainVectorSpace {
        definition =
            "The target vector space W into which the linear transformation maps."
    }

    Kernel {
        definition =
            "The set of domain vectors mapped to the zero vector."

        symbolic_form =
            "ker(T)={v in V | T(v)=0_W}"

        structural_property =
            "ker(T) is a subspace of V."
    }

    Image {
        definition =
            "The set of all vectors attained as outputs of the transformation."

        symbolic_form =
            "im(T)={T(v) | v in V}"

        structural_property =
            "im(T) is a subspace of W."
    }

    Rank {
        definition =
            "The dimension of the image."

        symbolic_form =
            "rank(T)=dim(im(T))"
    }

    Nullity {
        definition =
            "The dimension of the kernel."

        symbolic_form =
            "nullity(T)=dim(ker(T))"
    }

    Injectivity {
        criterion =
            "T is injective if and only if ker(T)={0_V}."
    }

    Surjectivity {
        criterion =
            "T is surjective if and only if im(T)=W."
    }

    Bijectivity {
        criterion =
            "T is bijective if and only if it is both injective and surjective."
    }

    MatrixRepresentation {
        definition =
            "Relative to ordered bases B of V and C of W, a linear transformation is represented by a matrix whose columns are the C-coordinate vectors of T applied to the B-basis vectors."
    }
}

RELATIONS {
    LinearTransformation --has_domain--> VectorSpace
    LinearTransformation --has_codomain--> VectorSpace
    LinearTransformation --preserves--> VectorAddition
    LinearTransformation --preserves--> ScalarMultiplication
    LinearTransformation --has_kernel--> Kernel
    LinearTransformation --has_image--> Image
    Kernel --has_dimension--> Nullity
    Image --has_dimension--> Rank
    LinearTransformation --can_be--> Injective
    LinearTransformation --can_be--> Surjective
    LinearTransformation --can_be--> Bijective
    LinearTransformation --can_be_represented_by--> Matrix
    Basis --determines--> MatrixRepresentation
    LinearTransformation --can_be_composed_with--> LinearTransformation
    BijectiveLinearTransformation --has_inverse--> InverseLinearTransformation
    LinearTransformation --participates_in--> RankNullityTheorem
}

OPERATORS {
    IS_LINEAR(T) :=
        FOR_ALL u,v,a,b:
        T(a*u+b*v)=a*T(u)+b*T(v)

    KERNEL(T) :=
        {v in Domain(T) | T(v)=Zero(Codomain(T))}

    IMAGE(T) :=
        {T(v) | v in Domain(T)}

    RANK(T) :=
        DIMENSION(IMAGE(T))

    NULLITY(T) :=
        DIMENSION(KERNEL(T))

    IS_INJECTIVE(T) :=
        KERNEL(T)=={Zero(Domain(T))}

    IS_SURJECTIVE(T) :=
        IMAGE(T)==Codomain(T)

    IS_BIJECTIVE(T) :=
        IS_INJECTIVE(T) AND IS_SURJECTIVE(T)

    COMPOSE(S,T) :=
        S o T

    MATRIX_OF(T,B,C) :=
        matrix whose ith column is COORDINATES(T(b_i),C)

    INVERSE(T) :=
        T^-1 IF IS_BIJECTIVE(T)
}

DEFINITIONS {
    D1: "T is linear iff T(u+v)=T(u)+T(v) and T(a v)=aT(v)."
    D2: "Equivalently, T(a u+b v)=aT(u)+bT(v)."
    D3: "T(0_V)=0_W for every linear transformation."
    D4: "ker(T)={v in V | T(v)=0_W}."
    D5: "im(T)={T(v) | v in V}."
    D6: "ker(T) is a subspace of V."
    D7: "im(T) is a subspace of W."
    D8: "rank(T)=dim(im(T))."
    D9: "nullity(T)=dim(ker(T))."
    D10: "T injective iff ker(T)={0_V}."
    D11: "T surjective iff im(T)=W."
    D12: "For finite-dimensional V, dim(V)=rank(T)+nullity(T)."
    D13: "A linear transformation is uniquely determined by its action on a basis."
    D14: "Composition of linear transformations is linear."
    D15: "The inverse of a bijective linear transformation is linear."
}

AXIOMS {
    A1_ADDITIVITY:
        IF T is linear
        THEN T(u+v)=T(u)+T(v)

    A2_HOMOGENEITY:
        IF T is linear
        THEN T(a v)=aT(v)

    A3_ZERO_PRESERVATION:
        IF T is linear
        THEN T(0_V)=0_W

    A4_KERNEL_SUBSPACE:
        IF T is linear
        THEN ker(T) is a subspace of V

    A5_IMAGE_SUBSPACE:
        IF T is linear
        THEN im(T) is a subspace of W

    A6_COMPOSITION:
        IF T: U -> V is linear
        AND S: V -> W is linear
        THEN S o T: U -> W is linear

    A7_IDENTITY:
        IF I_V(v)=v
        THEN I_V is linear

    A8_BASIS_DETERMINATION:
        IF B is a basis of V
        AND T(b) is specified for every b in B
        THEN T is uniquely determined on all of V

    A9_RANK_NULLITY:
        IF V is finite-dimensional
        THEN dim(V)=rank(T)+nullity(T)
}

REASONING {

    R1_LINEARITY_TEST {
        INPUT = transformation T
        TEST_1 = verify "T(u+v)=T(u)+T(v)"
        TEST_2 = verify "T(a v)=aT(v)"
        IF TEST_1 AND TEST_2
            RETURN Linear
        ELSE
            RETURN NotLinear
    }

    R2_ZERO_TEST {
        INPUT = T
        COMPUTE = T(0_V)
        IF T(0_V) != 0_W
            RETURN "T is not linear"
        ELSE
            RETURN "zero condition satisfied but further tests may be required"
    }

    R3_KERNEL {
        INPUT = T
        SOLVE = "T(v)=0_W"
        RETURN = ker(T)
    }

    R4_IMAGE {
        INPUT = T
        COMPUTE = attainable_outputs
        RETURN = im(T)
    }

    R5_INJECTIVITY {
        COMPUTE = ker(T)
        IF ker(T)=={0_V}
            RETURN Injective
        ELSE
            RETURN NotInjective
    }

    R6_SURJECTIVITY {
        COMPUTE = im(T)
        IF im(T)==Codomain(T)
            RETURN Surjective
        ELSE
            RETURN NotSurjective
    }

    R7_BIJECTIVITY {
        IF IS_INJECTIVE(T) AND IS_SURJECTIVE(T)
            RETURN Bijective
        ELSE
            RETURN NotBijective
    }

    R8_MATRIX_REPRESENTATION {
        INPUT = [T, ordered_basis B=(b1,...,bn), ordered_basis C]
        FOR each b_i in B
            compute T(b_i)
            express T(b_i) in basis C
            place coordinate vector as column i
        RETURN = [T]_C<-B
    }

    R9_MATRIX_ACTION {
        REQUIRE = matrix A represents T relative to standard or specified bases
        INPUT = coordinate vector [v]_B
        COMPUTE = A*[v]_B
        RETURN = [T(v)]_C
    }

    R10_RANK_NULLITY {
        REQUIRE = finite-dimensional V
        COMPUTE_OR_GIVEN = rank(T)
        COMPUTE_OR_GIVEN = nullity(T)
        VERIFY = "dim(V)=rank(T)+nullity(T)"
    }

    R11_BASIS_EXTENSION {
        INPUT = basis B of V
        KNOWN = T(b_i) for all basis vectors
        FOR arbitrary v=sum(c_i*b_i)
            RETURN T(v)=sum(c_i*T(b_i))
    }
}

CONSTRAINTS {
    C1: "The domain and codomain of a linear transformation must be vector spaces over compatible scalar fields."
    C2: "Linearity requires both additivity and scalar homogeneity."
    C3: "Preserving zero alone is necessary but not sufficient for linearity."
    C4: "The kernel is contained in the domain."
    C5: "The image is contained in the codomain."
    C6: "Kernel and image are vector subspaces for linear transformations."
    C7: "A matrix representation depends on the chosen ordered bases."
    C8: "Injectivity of a linear map is equivalent to a trivial kernel."
    C9: "Surjectivity is equivalent to image equalling codomain."
    C10: "Rank-nullity requires a finite-dimensional domain in its standard finite-dimensional form."
}

SEMANTIC_EQUIVALENCE {
    "LinearTransformation" <=> "LinearMap"
    "Image(T)" <=> "Range(T)"
    "Kernel(T)" <=> "NullSpace(T)" WHEN matrix_context
    "rank(T)" <=> "dim(im(T))"
    "nullity(T)" <=> "dim(ker(T))"
    "T injective" <=> "ker(T)={0}"
    "T surjective" <=> "im(T)=Codomain(T)"
}

VALIDATION {
    V1 = "Linear maps preserve zero."
    V2 = "Linear maps preserve finite linear combinations."
    V3 = "Kernel is a subspace of the domain."
    V4 = "Image is a subspace of the codomain."
    V5 = "Composition of linear maps is linear."
    V6 = "Identity map is linear."
    V7 = "T is injective iff kernel is trivial."
    V8 = "T is surjective iff image equals codomain."
    V9 = "rank(T)=dim(im(T))."
    V10 = "nullity(T)=dim(ker(T))."
    V11 = "dim(V)=rank(T)+nullity(T) for finite-dimensional V."
    V12 = "A linear transformation is determined by its values on a basis."
}

CONFIDENCE {
    BASE_CONFIDENCE = 0.99
    LINEAR_TRANSFORMATION_DEFINITION = 0.99
    ADDITIVITY = 0.99
    HOMOGENEITY = 0.99
    KERNEL_RELATION = 0.99
    IMAGE_RELATION = 0.99
    RANK_RELATION = 0.99
    NULLITY_RELATION = 0.99
    INJECTIVITY_RELATION = 0.99
    SURJECTIVITY_RELATION = 0.99
    RANK_NULLITY = 0.99

    POLICY =
        "Reduce confidence when domain, codomain, scalar field, or mapping rule is underspecified."
}

AI_CONSUMPTION {
    PURPOSES = [
        SemanticSearch,
        OntologyGrounding,
        MathematicalReasoning,
        EntityResolution,
        TransformationReasoning,
        MatrixReasoning,
        KernelReasoning,
        ImageReasoning,
        KnowledgeGraphConstruction,
        RetrievalAugmentation,
        RecursiveInference
    ]

    NORMALISE {
        "linear transformation" -> LinearTransformation
        "linear map" -> LinearTransformation
        "linear operator" -> LinearTransformation WHEN domain_equals_codomain
        "kernel of T" -> Kernel
        "null space of T" -> Kernel
        "image of T" -> Image
        "range of T" -> Image
        "rank of T" -> Rank
        "nullity of T" -> Nullity
    }

    INTERPRETATION_ORDER = [
        identify_vector_space_domain,
        identify_vector_space_codomain,
        identify_scalar_field,
        identify_mapping_rule,
        test_additivity,
        test_homogeneity,
        establish_linearity,
        derive_kernel,
        derive_image,
        derive_rank_and_nullity,
        evaluate_injectivity,
        evaluate_surjectivity,
        evaluate_bijectivity,
        derive_matrix_representation_if_bases_known,
        apply_rank_nullity_when_applicable,
        return_semantic_result
    ]
}

EXECUTION_RULES {
    E1:
        IF query_mentions("linear transformation")
        OR query_mentions("linear map")
        THEN activate(LinearTransformationOntology)

    E2:
        IF request=="test linearity"
        THEN verify_additivity
        AND verify_homogeneity

    E3:
        IF T(0_V)!=0_W
        THEN conclude(NotLinear)

    E4:
        IF request=="find kernel"
        THEN solve(T(v)=0_W)

    E5:
        IF request=="find image"
        THEN compute(attainable_outputs)

    E6:
        IF request=="find rank"
        THEN compute(dim(image(T)))

    E7:
        IF request=="find nullity"
        THEN compute(dim(kernel(T)))

    E8:
        IF request=="test injectivity"
        THEN evaluate(kernel(T)=={0_V})

    E9:
        IF request=="test surjectivity"
        THEN evaluate(image(T)==codomain(T))

    E10:
        IF request=="find matrix representation"
        THEN require_ordered_bases
        THEN map_basis_vectors
        THEN build_coordinate_columns

    E11:
        IF finite_dimensional_domain
        THEN permit_rank_nullity_inference
}

RECURSION {
    ENTRY = LinearTransformation

    EXPAND(LinearTransformation) -> [
        Transformation,
        VectorSpace,
        Domain,
        Codomain,
        Kernel,
        Image,
        Rank,
        Nullity,
        Injectivity,
        Surjectivity,
        Bijectivity,
        Basis,
        MatrixRepresentation,
        RankNullityTheorem
    ]

    EXPAND(Kernel) -> [
        NullSpace,
        Basis,
        Nullity,
        Injectivity
    ]

    EXPAND(Image) -> [
        Range,
        ColumnSpace,
        Basis,
        Rank,
        Surjectivity
    ]

    EXPAND(MatrixRepresentation) -> [
        OrderedBasis,
        CoordinateVector,
        Matrix,
        ChangeOfBasis
    ]

    EXPAND(RankNullityTheorem) -> [
        Dimension,
        Rank,
        Nullity,
        Kernel,
        Image
    ]

    STOP_CONDITION =
        "Stop when the requested property or derived structure is resolved with sufficient confidence and all necessary dependencies have been evaluated."
}

ROUTING {
    PARENT_ONTOLOGY = "Transformation Ontology"

    IMMEDIATE_CONTEXTS = [
        "Algebra Ontology",
        "Linear Algebra Ontology",
        "Vector Space Ontology"
    ]

    RELATED_ONTOLOGIES = [
        "Transformation Ontology",
        "Vector Space Ontology",
        "Matrix Ontology",
        "Kernel Ontology",
        "Image Ontology",
        "Basis Ontology",
        "Dimension Ontology",
        "Rank Ontology",
        "Null Space Ontology",
        "Column Space Ontology",
        "Row Space Ontology"
    ]

    ROUTE_RULES = [
        "Linear Transformation -> Kernel for zero-preimage reasoning",
        "Linear Transformation -> Image for range reasoning",
        "Linear Transformation -> Rank for image-dimension reasoning",
        "Linear Transformation -> Nullity for kernel-dimension reasoning",
        "Linear Transformation -> Basis for map determination and coordinates",
        "Linear Transformation -> Matrix for concrete representation",
        "Linear Transformation -> Dimension for rank-nullity reasoning"
    ]
}

UPDATE_MODEL {
    MODE = "append-compatible semantic versioning"

    MAJOR = "ontology-breaking conceptual change"
    MINOR = "new compatible concepts, operators or relations"
    PATCH = "clarification, metadata or formatting correction"

    RULES = [
        "Preserve additivity and scalar-homogeneity as defining laws.",
        "Preserve domain and codomain as vector spaces over compatible fields.",
        "Preserve kernel and image subspace relationships.",
        "Preserve rank and nullity definitions.",
        "Preserve injectivity and surjectivity criteria.",
        "Preserve basis-dependent matrix representation.",
        "Preserve rank-nullity for finite-dimensional domains."
    ]
}

OUTPUT {
    CANONICAL_DEFINITION =
        "A linear transformation T: V -> W is a mapping satisfying T(u+v)=T(u)+T(v) and T(a v)=aT(v)."

    COMBINED_LINEARITY_SUMMARY =
        "T(a u+b v)=aT(u)+bT(v)"

    KERNEL_SUMMARY =
        "ker(T)={v in V | T(v)=0_W}"

    IMAGE_SUMMARY =
        "im(T)={T(v) | v in V}"

    RANK_SUMMARY =
        "rank(T)=dim(im(T))"

    NULLITY_SUMMARY =
        "nullity(T)=dim(ker(T))"

    INJECTIVITY_SUMMARY =
        "T injective <=> ker(T)={0_V}"

    SURJECTIVITY_SUMMARY =
        "T surjective <=> im(T)=W"

    RANK_NULLITY_SUMMARY =
        "dim(V)=rank(T)+nullity(T)"
}

FLOW {
    INPUT
    -> detect_linear_transformation_context
    -> identify_domain_vector_space
    -> identify_codomain_vector_space
    -> identify_scalar_field
    -> identify_mapping_rule
    -> test_additivity
    -> test_scalar_homogeneity
    -> establish_linearity
    -> derive_kernel
    -> derive_image
    -> derive_rank
    -> derive_nullity
    -> evaluate_injectivity
    -> evaluate_surjectivity
    -> evaluate_bijectivity
    -> derive_matrix_representation_when_bases_known
    -> apply_rank_nullity_when_applicable
    -> link_related_ontologies
    -> assign_confidence
    -> produce_semantic_output
    -> END
}

SEMANTIC_SUMMARY {
    "A linear transformation is a structure-preserving map between vector spaces. It preserves addition and scalar multiplication, maps zero to zero, and has a kernel and image that are subspaces of its domain and codomain respectively. Its image dimension is its rank, its kernel dimension is its nullity, and these are connected to the dimension of the domain by the rank-nullity theorem."
}

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

}

END_FLOW