Kernel Ontology

AI INTERPRETATION NOTE
This Flow Algebra record defines the mathematical ontology of the kernel of a mapping, with primary emphasis on linear transformations and related algebraic structures. It is designed for machine interpretation, semantic retrieval, recursive reasoning, ontology linking, and AI consumption within the Kireth Research Semantic Library.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
    PRIMARY_ENTITY = Kernel
    SYMBOLIC_FORMS = ["ker(T)", "Ker(T)", "kernel(T)", "ker(f)"]
    ENTITY_CLASS = AlgebraicStructure
    ONTOLOGY_ROLE = "Set of domain elements mapped to the neutral or zero element by a mapping"
    PRIMARY_CONTEXT = LinearTransformation
    SECONDARY_CONTEXTS = [
        GroupHomomorphism,
        RingHomomorphism,
        ModuleHomomorphism,
        GeneralMorphism
    ]
}

SCOPE {
    INCLUDE = [
        KernelOfLinearTransformation,
        NullSpace,
        ZeroVectorPreimage,
        HomomorphismKernel,
        KernelSubspace,
        KernelDimension,
        Nullity,
        KernelBasis,
        KernelComputation,
        KernelProperties,
        InjectivityRelationship,
        RankNullityRelationship
    ]

    EXCLUDE_AS_PRIMARY = [
        IntegralKernel,
        OperatingSystemKernel,
        MachineLearningKernelFunction,
        ReproducingKernelHilbertSpace
    ]

    DISAMBIGUATION_RULE =
        "Interpret kernel as the algebraic or linear-algebraic kernel unless surrounding context explicitly identifies another mathematical meaning."
}

CONCEPTS {

    Kernel {
        definition =
            "For a mapping T from a domain V to a codomain W with a distinguished zero or identity element, the kernel is the set of all elements in V mapped to the zero or identity element."

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

        semantic_role =
            "Captures precisely the domain elements annihilated by the transformation."

        properties = [
            SubsetOfDomain,
            ContainsZeroElement,
            ClosedUnderRelevantAlgebraicOperations,
            MeasuresFailureOfInjectivity
        ]
    }

    LinearTransformation {
        symbolic_form = "T: V -> W"
        requirement =
            "T preserves vector addition and scalar multiplication."

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

    ZeroVector {
        symbol = "0_W"
        role =
            "Distinguished additive identity in the codomain."
    }

    NullSpace {
        equivalence =
            "For a matrix A or linear transformation T represented by A, the null space and kernel describe the same solution set."

        symbolic_form =
            "N(A) = {x | Ax = 0}"

        semantic_equivalence =
            "NullSpace(A) ≡ Kernel(A)"
    }

    Nullity {
        definition =
            "The dimension of the kernel of a linear transformation."

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

    KernelBasis {
        definition =
            "A basis consisting of linearly independent vectors that span the kernel."

        consequence =
            "The number of vectors in a kernel basis equals the nullity."
    }

    InjectiveMapping {
        criterion =
            "A linear transformation is injective if and only if its kernel contains only the zero vector."

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

RELATIONS {

    Kernel --is_subspace_of--> DomainVectorSpace

    Kernel --is_equivalent_to--> NullSpace
        WHEN mapping_representation == Matrix

    Kernel --has_dimension--> Nullity

    Kernel --has_basis--> KernelBasis

    Kernel --contains--> ZeroVector

    LinearTransformation --has_kernel--> Kernel

    Matrix --represents--> LinearTransformation

    Matrix --defines_homogeneous_system--> "Ax = 0"

    HomogeneousSystem --solution_set_is--> Kernel

    Kernel --determines--> InjectivityStatus

    Kernel --participates_in--> RankNullityTheorem

    RankNullityTheorem --relates--> Rank

    RankNullityTheorem --relates--> Nullity

    Kernel --is_preimage_of--> ZeroElement

    Kernel --generalises_to--> HomomorphismKernel
}

OPERATORS {

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

    NULL_SPACE(A) :=
        {x | A*x = 0}

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

    IS_IN_KERNEL(x, T) :=
        (T(x) == Zero(Codomain(T)))

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

    KERNEL_BASIS(A) :=
        BASIS(SOLVE_HOMOGENEOUS_SYSTEM(A*x = 0))

    KERNEL_DIMENSION(A) :=
        COUNT(KERNEL_BASIS(A))

    PREIMAGE_ZERO(T) :=
        PREIMAGE(T, Zero(Codomain(T)))

    KERNEL_FROM_MATRIX(A) :=
        SOLUTION_SET(ROW_REDUCE(A), A*x = 0)
}

DEFINITIONS {

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

    D2:
        "For a matrix A, ker(A) = {x | Ax = 0}"

    D3:
        "nullity(T) = dim(ker(T))"

    D4:
        "ker(T) is a vector subspace of the domain of T."

    D5:
        "T is injective if and only if ker(T) = {0}."

    D6:
        "For T: V -> W with V finite-dimensional, dim(V) = rank(T) + nullity(T)."
}

AXIOMS {

    A1_ZERO_IN_KERNEL:
        IF T is linear
        THEN T(0_V) = 0_W
        THEREFORE 0_V in ker(T)

    A2_ADDITION_CLOSURE:
        IF u in ker(T) AND v in ker(T)
        THEN T(u + v) = T(u) + T(v) = 0_W
        THEREFORE u + v in ker(T)

    A3_SCALAR_CLOSURE:
        IF v in ker(T) AND a is a scalar
        THEN T(a v) = a T(v) = 0_W
        THEREFORE a v in ker(T)

    A4_SUBSPACE:
        IF A1_ZERO_IN_KERNEL
        AND A2_ADDITION_CLOSURE
        AND A3_SCALAR_CLOSURE
        THEN ker(T) is a subspace of Domain(T)

    A5_INJECTIVITY:
        IF ker(T) = {0_V}
        THEN T is injective

    A6_NONTRIVIAL_KERNEL:
        IF EXISTS v != 0_V SUCH_THAT T(v) = 0_W
        THEN T is not injective
}

REASONING {

    R1_MEMBERSHIP_TEST {
        INPUT = [element x, mapping T]
        COMPUTE = T(x)
        IF result == zero_of_codomain
            RETURN "x belongs to ker(T)"
        ELSE
            RETURN "x does not belong to ker(T)"
    }

    R2_MATRIX_KERNEL {
        INPUT = matrix A
        FORM = "A x = 0"
        REDUCE = RREF(A)
        IDENTIFY = free_variables
        PARAMETRISE = solution_vectors
        EXTRACT = basis_vectors
        RETURN = span(basis_vectors)
    }

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

    R4_NULLITY {
        INPUT = kernel_basis
        RETURN count(kernel_basis)
    }

    R5_RANK_NULLITY {
        REQUIRE = finite_dimensional_domain
        GIVEN = dim(V)
        GIVEN_OR_COMPUTE = rank(T)
        COMPUTE =
            "nullity(T) = dim(V) - rank(T)"
        VERIFY =
            "dim(V) = rank(T) + nullity(T)"
    }

    R6_SEMANTIC_EQUIVALENCE {
        IF context == matrix_linear_algebra
        THEN Kernel <=> NullSpace

        IF context == group_homomorphism
        THEN Kernel =
            "preimage of the identity element"

        IF context == linear_map
        THEN Kernel =
            "preimage of the zero vector"
    }
}

CONSTRAINTS {

    C1:
        "Kernel elements belong to the domain, not the codomain."

    C2:
        "The image of every kernel element must equal the codomain zero element or, in the appropriate algebraic setting, the identity element."

    C3:
        "For linear transformations, the kernel must satisfy the vector-subspace conditions."

    C4:
        "Nullity is defined only when dimension is meaningful in the chosen algebraic setting."

    C5:
        "The statement ker(T) = {0} implies injectivity for linear maps and homomorphisms under the relevant structure-preserving assumptions."

    C6:
        "Do not confuse the algebraic kernel with kernel functions in machine learning, integral kernels, or operating-system kernels."

    C7:
        "A matrix kernel is determined by solving the homogeneous system Ax = 0, not Ax = b for arbitrary nonzero b."
}

VALIDATION {

    V1 {
        test = "zero membership"
        expected = "0_V belongs to ker(T)"
    }

    V2 {
        test = "closure under addition"
        given = "u,v in ker(T)"
        expected = "u+v in ker(T)"
    }

    V3 {
        test = "closure under scalar multiplication"
        given = "v in ker(T), scalar a"
        expected = "a v in ker(T)"
    }

    V4 {
        test = "injectivity criterion"
        condition = "ker(T) = {0}"
        expected = "T injective"
    }

    V5 {
        test = "nontrivial kernel"
        condition = "exists nonzero v with T(v)=0"
        expected = "T not injective"
    }

    V6 {
        test = "rank-nullity"
        condition = "finite-dimensional V"
        expected =
            "dim(V) = rank(T) + dim(ker(T))"
    }

    V7 {
        test = "matrix equivalence"
        condition = "T represented by A"
        expected =
            "ker(T) semantically equivalent to null space of A"
    }
}

CONFIDENCE {

    BASE_CONFIDENCE = 0.99

    ASSERTIONS = {
        "Kernel is the preimage of zero for a linear map" : 0.99,
        "Kernel is a subspace of the domain" : 0.99,
        "Kernel and null space are equivalent in matrix linear algebra" : 0.99,
        "Kernel determines injectivity for linear maps" : 0.99,
        "Nullity equals dimension of the kernel" : 0.99,
        "Rank-nullity relates domain dimension, rank, and nullity" : 0.99
    }

    CONFIDENCE_POLICY =
        "Reduce confidence when the term 'kernel' appears without sufficient mathematical context to disambiguate its meaning."
}

PROVENANCE {

    KNOWLEDGE_DOMAIN = "Standard mathematical linear algebra and abstract algebra"
    SOURCE_TYPE = "Canonical mathematical definitions and theorems"
    CURATION = "Kireth Research Semantic Library"
    AUTHORSHIP_CONTEXT = "Human-AI co-authored semantic specification"
    CANONICAL_URL =
        "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/kernel-ontology.html"
}

AI_CONSUMPTION {

    PURPOSES = [
        SemanticSearch,
        OntologyGrounding,
        MathematicalReasoning,
        EntityResolution,
        QueryInterpretation,
        KnowledgeGraphConstruction,
        RetrievalAugmentation,
        RecursiveInference,
        EducationalExplanation
    ]

    PREFERRED_INTERPRETATION_ORDER = [
        "Identify mathematical domain",
        "Identify mapping or matrix",
        "Identify domain and codomain",
        "Locate zero or identity element",
        "Interpret kernel as preimage of zero or identity",
        "Test subspace or normal-substructure properties where relevant",
        "Relate kernel to null space, nullity, injectivity, and rank-nullity",
        "Return symbolic and semantic interpretation"
    ]

    ENTITY_NORMALISATION = {
        "kernel of T" : Kernel,
        "ker T" : Kernel,
        "ker(T)" : Kernel,
        "null space" : NullSpace,
        "solution set of Ax=0" : Kernel,
        "preimage of zero" : Kernel
    }

    SEMANTIC_EQUIVALENCE = [
        "Kernel(matrix) ≡ NullSpace(matrix)",
        "Kernel(linear transformation) ≡ Preimage(ZeroVector)",
        "Kernel(group homomorphism) ≡ Preimage(IdentityElement)"
    ]
}

UPDATES {

    UPDATE_MODEL = "append-compatible semantic versioning"

    UPDATE_RULES = [
        "Preserve canonical kernel definitions.",
        "New specialised kernel meanings must be added through explicit contextual disambiguation.",
        "Do not overwrite existing algebraic meanings with unrelated uses of the term kernel.",
        "Any new relation must preserve domain/codomain directionality.",
        "Any computational extension must remain compatible with homogeneous-system interpretation."
    ]

    VERSIONING {
        MAJOR = "ontology-breaking conceptual change"
        MINOR = "new relations, operators, or compatible definitions"
        PATCH = "clarifications, spelling, formatting, or metadata corrections"
    }
}

EXECUTION_RULES {

    E1:
        IF query_mentions("kernel")
        AND context_contains(linear_algebra_terms)
        THEN activate(KernelOntology)

    E2:
        IF query_contains("Ax = 0")
        THEN activate([KernelOntology, NullSpaceOntology, LinearEquationOntology])

    E3:
        IF query_asks("is transformation injective")
        THEN compute(kernel)
        AND evaluate(kernel == {0})

    E4:
        IF query_asks("find a basis for the kernel")
        THEN solve_homogeneous_system
        THEN parameterise_free_variables
        THEN extract_basis_vectors

    E5:
        IF query_asks("find nullity")
        THEN dimension(kernel)

    E6:
        IF rank_and_domain_dimension_known
        THEN infer(
            nullity = domain_dimension - rank
        )

    E7:
        IF term_kernel_is_ambiguous
        THEN inspect_context_before_reasoning
}

RECURSION {

    ENTRY = Kernel

    EXPAND(Kernel) -> [
        LinearTransformation,
        Matrix,
        NullSpace,
        Nullity,
        KernelBasis,
        Injectivity,
        HomogeneousLinearSystem,
        RankNullityTheorem
    ]

    EXPAND(NullSpace) -> [
        HomogeneousSystem,
        FreeVariable,
        PivotVariable,
        Basis,
        Dimension
    ]

    EXPAND(Injectivity) -> [
        OneToOneMapping,
        TrivialKernel
    ]

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

    STOP_CONDITION =
        "Terminate recursive expansion when the target query is resolved, confidence exceeds threshold, and no unresolved entity dependencies remain."
}

ROUTING {

    PARENT_ONTOLOGY =
        "Algebra Ontology"

    IMMEDIATE_CONTEXTS = [
        "Linear Algebra Ontology",
        "Matrix Ontology",
        "Linear Transformation Ontology"
    ]

    RELATED_ONTOLOGIES = [
        "Null Space Ontology",
        "Column Space Ontology",
        "Row Space Ontology",
        "Rank Ontology",
        "Dimension Ontology",
        "Basis Ontology",
        "Linear Equation Ontology",
        "Vector Space Ontology",
        "Matrix Ontology",
        "Determinant Ontology"
    ]

    ROUTE_RULES = [
        "Kernel -> Null Space when matrix representation is primary",
        "Kernel -> Rank when rank-nullity reasoning is required",
        "Kernel -> Basis when explicit spanning vectors are required",
        "Kernel -> Linear Equation when solving Ax=0",
        "Kernel -> Vector Space when proving subspace properties",
        "Kernel -> Linear Transformation when interpreting domain/codomain behaviour"
    ]
}

OUTPUT {

    DEFAULT_RESPONSE_COMPONENTS = [
        CanonicalDefinition,
        SymbolicForm,
        DomainCodomainContext,
        KernelMembershipCondition,
        StructuralProperties,
        RelevantEquivalences,
        RelatedTheorems
    ]

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

    MATRIX_SUMMARY =
        "ker(A) = {x | Ax = 0}"

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

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

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

FLOW {

    INPUT
        -> detect_term("kernel")
        -> identify_mathematical_context
        -> resolve_mapping_or_matrix
        -> resolve_domain
        -> resolve_codomain
        -> identify_zero_or_identity_element
        -> construct_preimage_of_zero
        -> define_kernel
        -> validate_membership
        -> validate_substructure
        -> derive_null_space_equivalence_when_applicable
        -> derive_nullity
        -> evaluate_injectivity
        -> apply_rank_nullity_when_applicable
        -> link_related_ontologies
        -> assign_confidence
        -> produce_semantic_output
        -> END
}

SEMANTIC_SUMMARY {
    "The kernel of a linear transformation T: V -> W is the set of all vectors in V mapped to the zero vector in W. It is a subspace of V, coincides with the null space when T is represented by a matrix, has dimension equal to the nullity, and is trivial exactly when the transformation is injective. In finite-dimensional linear algebra, its dimension is linked to rank through the rank-nullity theorem."
}

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

}

END_FLOW