Transformation Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the mathematical ontology of transformation, principally within algebra and linear algebra. A transformation is a mapping from one mathematical structure to another, with linear transformations preserving 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 = "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/transformation-ontology.html"
    LANGUAGE = "en-GB"
    VERSION = "1.0"
    STATUS = "active"
}

IDENTITY {
    PRIMARY_ENTITY = Transformation
    SYMBOLIC_FORMS = ["T: V -> W", "f: X -> Y", "T(x)"]
    ENTITY_CLASS = MappingStructure
    PRIMARY_CONTEXT = Algebra
    SECONDARY_CONTEXT = LinearAlgebra
    DEFINITION = "A transformation is a mapping that assigns each element of a domain to an element of a codomain."
    LINEAR_DEFINITION = "A linear transformation T: V -> W preserves vector addition and scalar multiplication."
}

SCOPE {
    INCLUDE = [
        Transformation,
        Mapping,
        Function,
        LinearTransformation,
        Domain,
        Codomain,
        Image,
        Kernel,
        Injectivity,
        Surjectivity,
        Bijectivity,
        Composition,
        IdentityTransformation,
        InverseTransformation,
        MatrixRepresentation,
        ChangeOfBasis
    ]

    EXCLUDE_AS_PRIMARY = [
        PhysicalTransformation,
        ChemicalTransformation,
        DigitalImageTransformation,
        DataTransformation,
        OrganisationalTransformation
    ]

    DISAMBIGUATION_RULE =
        "When transformation occurs with mappings, functions, vectors, matrices, domains, codomains, kernels, images, rank, nullity, basis or vector spaces, interpret it mathematically."
}

CORE_CONCEPTS {

    Transformation {
        definition =
            "A rule assigning each element of a domain to exactly one element of a codomain."

        symbolic_form =
            "T: V -> W"

        evaluation =
            "x maps to T(x)"
    }

    LinearTransformation {
        definition =
            "A transformation between vector spaces preserving addition and scalar multiplication."

        laws = [
            "T(u+v)=T(u)+T(v)",
            "T(a v)=a T(v)"
        ]

        equivalent_combined_form =
            "T(a u + b v)=a T(u)+b T(v)"
    }

    Domain {
        definition =
            "The set or structure on which the transformation acts."
    }

    Codomain {
        definition =
            "The declared target set or structure of the transformation."
    }

    Image {
        definition =
            "The set of outputs attained by the transformation."

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

    Kernel {
        definition =
            "For a linear transformation, the set of vectors mapped to zero."

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

    InjectiveTransformation {
        criterion =
            "Distinct inputs have distinct outputs."

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

    SurjectiveTransformation {
        criterion =
            "Every codomain element is attained."

        symbolic_form =
            "T surjective <=> im(T)=Codomain(T)"
    }

    BijectiveTransformation {
        definition =
            "A transformation that is both injective and surjective."
    }

    IdentityTransformation {
        symbolic_form =
            "I_V(v)=v"

        role =
            "Leaves every element unchanged."
    }

    InverseTransformation {
        definition =
            "A transformation T^-1 reversing a bijective transformation T."

        laws = [
            "T^-1(T(v))=v",
            "T(T^-1(w))=w"
        ]
    }
}

RELATIONS {
    Transformation --has_domain--> Domain
    Transformation --has_codomain--> Codomain
    Transformation --produces--> Image
    LinearTransformation --has_kernel--> Kernel
    LinearTransformation --has_image--> Image
    Transformation --can_be--> InjectiveTransformation
    Transformation --can_be--> SurjectiveTransformation
    Transformation --can_be--> BijectiveTransformation
    Transformation --can_be_composed_with--> Transformation
    BijectiveTransformation --has_inverse--> InverseTransformation
    VectorSpace --is_source_of--> LinearTransformation
    VectorSpace --is_target_of--> LinearTransformation
    Matrix --can_represent--> LinearTransformation
    Basis --determines--> MatrixRepresentation
    Transformation --participates_in--> RankNullityTheorem
}

OPERATORS {
    APPLY(T,x) :=
        T(x)

    COMPOSE(S,T) :=
        S o T

    IDENTITY(V) :=
        I_V

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

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

    IS_INJECTIVE(T) :=
        FOR_ALL x1,x2:
        T(x1)=T(x2) => x1=x2

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

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

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

    MATRIX_REPRESENTATION(T,B,C) :=
        matrix of T relative to ordered bases B and C
}

DEFINITIONS {
    D1: "A transformation T: X -> Y assigns each x in X exactly one output T(x) in Y."
    D2: "A linear transformation preserves vector addition and scalar multiplication."
    D3: "ker(T)={v | T(v)=0}."
    D4: "im(T)={T(v) | v in Domain(T)}."
    D5: "T is injective iff equal outputs imply equal inputs."
    D6: "For linear T, injectivity is equivalent to ker(T)={0}."
    D7: "T is surjective iff im(T)=Codomain(T)."
    D8: "T is bijective iff it is both injective and surjective."
    D9: "A bijective transformation has an inverse."
    D10: "Composition of linear transformations is linear."
    D11: "The identity transformation is linear."
    D12: "A linear transformation is determined uniquely by its values on a basis."
}

AXIOMS {
    A1_FUNCTIONALITY:
        IF T: X -> Y
        THEN each x in X has exactly one T(x) in Y

    A2_LINEAR_ADDITION:
        IF T is linear
        THEN T(u+v)=T(u)+T(v)

    A3_LINEAR_SCALAR:
        IF T is linear
        THEN T(a v)=a T(v)

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

    A5_COMPOSITION:
        IF S and T are linear
        AND codomain(T)=domain(S)
        THEN S o T is linear

    A6_IDENTITY:
        IF I_V is identity on V
        THEN I_V is linear

    A7_BASIS_DETERMINATION:
        IF B is a basis of V
        AND values T(b) are known for all b in B
        THEN T is uniquely determined on V
}

REASONING {

    R1_LINEARITY_TEST {
        INPUT = transformation T
        TEST_1 = "T(u+v)=T(u)+T(v)"
        TEST_2 = "T(a v)=a T(v)"
        IF TEST_1 AND TEST_2
            RETURN LinearTransformation
        ELSE
            RETURN NonlinearTransformation
    }

    R2_KERNEL_ANALYSIS {
        INPUT = linear transformation T
        SOLVE = "T(v)=0"
        RETURN = kernel(T)
    }

    R3_IMAGE_ANALYSIS {
        INPUT = transformation T
        COMPUTE = attainable_outputs
        RETURN = image(T)
    }

    R4_INJECTIVITY_TEST {
        INPUT = linear transformation T
        COMPUTE = ker(T)
        IF ker(T)=={0}
            RETURN Injective
        ELSE
            RETURN NotInjective
    }

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

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

    R7_INVERSE_TEST {
        IF T is bijective
            RETURN inverse_exists
        ELSE
            RETURN inverse_does_not_exist_as_global_function
    }

    R8_MATRIX_REPRESENTATION {
        INPUT = [linear transformation T, ordered basis B of V, ordered basis C of W]
        FOR each basis vector b_i in B
            compute coordinates of T(b_i) relative to C
        PLACE coordinate vectors as columns
        RETURN matrix_representation
    }

    R9_COMPOSITION {
        INPUT = [T: U -> V, S: V -> W]
        RETURN = "S o T: U -> W"
    }

    R10_RANK_NULLITY {
        REQUIRE = finite_dimensional_domain
        COMPUTE = rank(T)
        COMPUTE = nullity(T)
        VERIFY = "dim(V)=rank(T)+nullity(T)"
    }
}

CONSTRAINTS {
    C1: "Every transformation must have a defined domain and codomain."
    C2: "Each input has exactly one output."
    C3: "The image is a subset of the codomain but need not equal it."
    C4: "A linear transformation must preserve both addition and scalar multiplication."
    C5: "The kernel of a linear transformation is a subspace of the domain."
    C6: "The image of a linear transformation is a subspace of the codomain."
    C7: "A transformation has a global inverse iff it is bijective."
    C8: "Composition S o T requires codomain(T) compatible with domain(S)."
    C9: "A matrix representation depends on chosen ordered bases."
    C10: "Do not confuse mathematical transformation with unrelated physical, visual or organisational meanings."
}

SEMANTIC_EQUIVALENCE {
    "Transformation" <=> "Mapping" WHEN mathematical_context
    "LinearTransformation" <=> "LinearMap"
    "Image(T)" <=> "Range(T)"
    "InjectiveTransformation" <=> "OneToOneMap"
    "SurjectiveTransformation" <=> "OntoMap"
    "BijectiveTransformation" <=> "OneToOneCorrespondence"
}

VALIDATION {
    V1 = "A linear transformation maps zero to zero."
    V2 = "The kernel of a linear transformation is a subspace."
    V3 = "The image of a linear transformation is a subspace."
    V4 = "Composition of linear transformations is linear."
    V5 = "Identity transformation is linear."
    V6 = "For linear T, ker(T)={0} iff T is injective."
    V7 = "T is surjective iff im(T)=codomain."
    V8 = "Bijective transformations possess inverses."
    V9 = "A linear transformation is uniquely determined by its values on a basis."
}

CONFIDENCE {
    BASE_CONFIDENCE = 0.99
    TRANSFORMATION_DEFINITION = 0.99
    LINEARITY_LAWS = 0.99
    KERNEL_RELATION = 0.99
    IMAGE_RELATION = 0.99
    INJECTIVITY_RELATION = 0.99
    SURJECTIVITY_RELATION = 0.99
    INVERSE_RELATION = 0.99
    BASIS_DETERMINATION = 0.99

    POLICY =
        "Reduce confidence when transformation occurs without mathematical context or when domain/codomain information is insufficient."
}

AI_CONSUMPTION {
    PURPOSES = [
        SemanticSearch,
        OntologyGrounding,
        MathematicalReasoning,
        EntityResolution,
        MappingReasoning,
        MatrixReasoning,
        KnowledgeGraphConstruction,
        RetrievalAugmentation,
        RecursiveInference
    ]

    NORMALISE {
        "transformation" -> Transformation
        "mapping" -> Transformation
        "map" -> Transformation
        "linear transformation" -> LinearTransformation
        "linear map" -> LinearTransformation
        "one-to-one" -> InjectiveTransformation
        "onto" -> SurjectiveTransformation
        "invertible transformation" -> BijectiveTransformation
    }

    INTERPRETATION_ORDER = [
        identify_mapping_context,
        identify_domain,
        identify_codomain,
        determine_linearity,
        derive_kernel_when_linear,
        derive_image,
        evaluate_injectivity,
        evaluate_surjectivity,
        evaluate_bijectivity,
        determine_inverse_status,
        derive_matrix_representation_if_bases_known,
        apply_rank_nullity_when_applicable,
        return_semantic_result
    ]
}

EXECUTION_RULES {
    E1:
        IF query_mentions("transformation")
        AND mathematical_context
        THEN activate(TransformationOntology)

    E2:
        IF query_mentions("linear transformation")
        THEN activate([TransformationOntology, LinearAlgebraOntology])

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

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

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

    E6:
        IF request=="test injective"
        THEN compute(kernel)
        AND compare(kernel,{0})

    E7:
        IF request=="test surjective"
        THEN compute(image)
        AND compare(image,codomain)

    E8:
        IF request=="find inverse"
        THEN verify_bijectivity
        THEN construct_inverse

    E9:
        IF request=="find matrix of transformation"
        THEN require_ordered_bases
        THEN map_basis_vectors
        THEN construct_coordinate_columns

    E10:
        IF finite_dimensional_domain
        THEN permit_rank_nullity_reasoning
}

RECURSION {
    ENTRY = Transformation

    EXPAND(Transformation) -> [
        Domain,
        Codomain,
        Mapping,
        Function,
        LinearTransformation,
        Image,
        Kernel,
        Injectivity,
        Surjectivity,
        Bijectivity,
        Composition,
        IdentityTransformation,
        InverseTransformation,
        MatrixRepresentation
    ]

    EXPAND(LinearTransformation) -> [
        VectorSpace,
        Basis,
        Kernel,
        Image,
        Rank,
        Nullity,
        Matrix
    ]

    EXPAND(Injectivity) -> [
        Kernel,
        OneToOneMapping
    ]

    EXPAND(Surjectivity) -> [
        Image,
        Codomain,
        OntoMapping
    ]

    EXPAND(Bijectivity) -> [
        Injectivity,
        Surjectivity,
        InverseTransformation
    ]

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

    STOP_CONDITION =
        "Stop when the requested transformation property or derived structure is resolved with sufficient confidence and no required dependencies remain unresolved."
}

ROUTING {
    PARENT_ONTOLOGY = "Algebra Ontology"

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

    RELATED_ONTOLOGIES = [
        "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 = [
        "Transformation -> Kernel for zero-preimage reasoning",
        "Transformation -> Image for attainable-output reasoning",
        "Transformation -> Basis for matrix representation",
        "Transformation -> Dimension for rank-nullity reasoning",
        "Transformation -> Matrix for coordinate representation",
        "Transformation -> Vector Space for source/target structure",
        "Transformation -> Inverse for bijectivity 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 domain-to-codomain mapping semantics.",
        "Preserve the two defining laws of linearity.",
        "Preserve kernel and image relations.",
        "Preserve injective, surjective and bijective distinctions.",
        "Preserve inverse existence criterion.",
        "Preserve dependence of matrix representation on ordered bases.",
        "Explicitly disambiguate unrelated uses of transformation."
    ]
}

OUTPUT {
    CANONICAL_DEFINITION =
        "A transformation is a mapping from a domain to a codomain; a linear transformation additionally preserves vector addition and scalar multiplication."

    SYMBOLIC_SUMMARY =
        "T: V -> W"

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

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

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

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

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

    BIJECTIVITY_SUMMARY =
        "T bijective <=> T injective and surjective"
}

FLOW {
    INPUT
    -> detect_term("transformation")
    -> disambiguate_mathematical_context
    -> identify_domain
    -> identify_codomain
    -> identify_mapping_rule
    -> test_linearity_when_required
    -> derive_kernel
    -> derive_image
    -> evaluate_injectivity
    -> evaluate_surjectivity
    -> evaluate_bijectivity
    -> determine_inverse_status
    -> derive_matrix_representation_when_bases_known
    -> apply_rank_nullity_when_applicable
    -> link_related_ontologies
    -> assign_confidence
    -> produce_semantic_output
    -> END
}

SEMANTIC_SUMMARY {
    "A transformation is a mapping from a domain to a codomain. In linear algebra, linear transformations preserve addition and scalar multiplication, possess kernels and images, and can be classified by injectivity, surjectivity and bijectivity. Relative to chosen bases, they can be represented by matrices, while their rank and nullity describe fundamental structural properties."
}

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

}

END_FLOW