Image Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the mathematical Image Ontology, principally the image of a linear transformation. It is intended for semantic retrieval, recursive reasoning, ontology linking and AI consumption within the Kireth Research Semantic Library.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = Image
 SYMBOLS = ["im(T)", "Im(T)", "T(V)", "range(T)"]
 PRIMARY_CONTEXT = LinearTransformation
 DEFINITION = "The image of T: V -> W is the set of outputs T(v) attained by elements v of V."
 SYMBOLIC_FORM = "im(T) = {T(v) | v in V}"
 EXISTENTIAL_FORM = "im(T) = {w in W | exists v in V such that T(v)=w}"
}

DISAMBIGUATION {
 MATHEMATICAL_IMAGE = "set of attained outputs of a mapping"
 NOT_PRIMARY = [DigitalImage, Photograph, RasterImage, ComputerVisionImage, MedicalImage]
 RULE = "When image occurs with mapping, function, matrix, vector space, domain, codomain, rank, range or transformation, prefer the mathematical interpretation."
}

CORE_CONCEPTS {
 Image {
   location = Codomain
   role = "attainable outputs"
   linear_property = "subspace of codomain"
 }
 Range {
   equivalence = "Range(T) ≡ Image(T)"
 }
 ColumnSpace {
   condition = "T(x)=Ax"
   equivalence = "Image(T) ≡ Col(A)"
 }
 Rank {
   definition = "dimension of image"
   formula = "rank(T)=dim(im(T))"
 }
 Surjectivity {
   criterion = "T surjective <=> im(T)=Codomain(T)"
 }
 ImageBasis {
   definition = "linearly independent vectors spanning im(T)"
   cardinality = "rank(T)"
 }
}

RELATIONS {
 LinearTransformation --has_image--> Image
 Image --is_subset_of--> Codomain
 Image --is_subspace_of--> Codomain WHEN transformation_is_linear
 Image --is_equivalent_to--> Range
 Image --is_equivalent_to--> ColumnSpace WHEN representation_is_matrix
 Image --has_dimension--> Rank
 Image --has_basis--> ImageBasis
 Image --determines--> Surjectivity
 Matrix --columns_span--> Image
 Image --participates_in--> RankNullityTheorem
 RankNullityTheorem --relates--> Kernel
 RankNullityTheorem --relates--> Image
}

OPERATORS {
 IMAGE(T) := {T(x) | x in Domain(T)}
 RANGE(T) := IMAGE(T)
 IS_IN_IMAGE(y,T) := EXISTS x in Domain(T) SUCH_THAT T(x)=y
 RANK(T) := DIMENSION(IMAGE(T))
 IS_SURJECTIVE(T) := IMAGE(T)==Codomain(T)
 COLUMN_SPACE(A) := SPAN(columns(A))
 IMAGE_FROM_MATRIX(A) := COLUMN_SPACE(A)
 IMAGE_BASIS(A) := BASIS(COLUMN_SPACE(A))
}

AXIOMS {
 A1:
   IF T is linear
   THEN T(0_V)=0_W
   THEREFORE 0_W in im(T)

 A2:
   IF y1 in im(T) AND y2 in im(T)
   THEN y1+y2 in im(T)

 A3:
   IF y in im(T) AND a is scalar
   THEN a*y in im(T)

 A4:
   IF T is linear
   THEN im(T) is a vector subspace of Codomain(T)

 A5:
   IF im(T)=Codomain(T)
   THEN T is surjective

 A6:
   IF T(x)=A*x
   THEN im(T)=span(columns(A))

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

REASONING {
 MEMBERSHIP {
   INPUT = [y,T]
   SOLVE = "T(x)=y"
   IF solution_exists RETURN "y in im(T)"
   ELSE RETURN "y not in im(T)"
 }

 MATRIX_IMAGE {
   INPUT = A
   STEP_1 = RREF(A)
   STEP_2 = identify_pivot_columns
   STEP_3 = select_corresponding_columns_from_original_A
   RETURN = span(selected_columns)
 }

 IMAGE_BASIS {
   INPUT = A
   PIVOTS = pivot_positions(RREF(A))
   BASIS = corresponding_columns(original_A)
   RETURN = BASIS
 }

 RANK {
   INPUT = image_basis
   RETURN = count(image_basis)
 }

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

 RANK_NULLITY {
   REQUIRE = finite_dimensional_domain
   FORMULA = "dim(V)=rank(T)+nullity(T)"
   INFER_RANK = "rank(T)=dim(V)-nullity(T)"
   INFER_NULLITY = "nullity(T)=dim(V)-rank(T)"
 }
}

CONSTRAINTS {
 C1 = "Image elements are elements of the codomain."
 C2 = "Every image element must have at least one preimage in the domain."
 C3 = "Image and codomain need not be equal."
 C4 = "For a linear transformation the image is a subspace."
 C5 = "For T(x)=Ax the image equals the column space of A."
 C6 = "Pivot locations may be found using RREF, but a column-space basis uses corresponding columns of the original matrix."
 C7 = "Rank equals dimension of image."
 C8 = "Do not confuse mathematical image with visual-image meanings."
}

SEMANTIC_EQUIVALENCE {
 "Image(T)" <=> "Range(T)"
 "Image(A)" <=> "ColumnSpace(A)" WHEN A represents a linear transformation
 "rank(T)" <=> "dim(Image(T))"
 "surjective(T)" <=> "Image(T)=Codomain(T)"
}

VALIDATION {
 V1 = "0_W belongs to image of every linear transformation."
 V2 = "Image is closed under addition for linear transformations."
 V3 = "Image is closed under scalar multiplication for linear transformations."
 V4 = "Image is a subspace of the codomain."
 V5 = "For matrix A, image equals column space."
 V6 = "Rank equals image dimension."
 V7 = "Image equals codomain exactly when the mapping is surjective."
 V8 = "For finite-dimensional V, dim(V)=dim(im(T))+dim(ker(T))."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 IMAGE_DEFINITION = 0.99
 RANGE_EQUIVALENCE = 0.99
 COLUMN_SPACE_EQUIVALENCE = 0.99
 RANK_RELATION = 0.99
 SURJECTIVITY_RELATION = 0.99
 RANK_NULLITY_RELATION = 0.99
 POLICY = "Reduce confidence if image appears without mathematical context."
}

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

 NORMALISE {
   "image of T" -> Image
   "im(T)" -> Image
   "range of T" -> Image
   "range(T)" -> Image
   "attainable outputs" -> Image
   "column space of A" -> Image WHEN matrix_context
 }

 INTERPRETATION_ORDER = [
   identify_mathematical_context,
   identify_mapping,
   identify_domain,
   identify_codomain,
   construct_attainable_outputs,
   resolve_range_equivalence,
   resolve_column_space_equivalence,
   derive_image_basis,
   derive_rank,
   evaluate_surjectivity,
   apply_rank_nullity,
   return_semantic_result
 ]
}

EXECUTION_RULES {
 E1:
   IF query_mentions("image") AND mathematical_context
   THEN activate(ImageOntology)

 E2:
   IF query_mentions("range") AND mapping_context
   THEN activate(ImageOntology)

 E3:
   IF query_mentions("column space")
   THEN activate([ImageOntology,ColumnSpaceOntology,MatrixOntology])

 E4:
   IF request=="find image" AND matrix_representation
   THEN compute(COLUMN_SPACE(A))

 E5:
   IF request=="find image basis"
   THEN identify_pivot_columns
   THEN select_original_matrix_columns

 E6:
   IF request=="find rank"
   THEN compute(DIMENSION(IMAGE(T)))

 E7:
   IF request=="test surjectivity"
   THEN compare(IMAGE(T),Codomain(T))

 E8:
   IF rank_nullity_data_available
   THEN apply(RankNullityTheorem)
}

RECURSION {
 ENTRY = Image

 EXPAND(Image) -> [
   LinearTransformation,
   Range,
   ColumnSpace,
   Rank,
   ImageBasis,
   Surjectivity,
   Codomain,
   Matrix,
   RankNullityTheorem
 ]

 EXPAND(ColumnSpace) -> [
   MatrixColumn,
   Span,
   LinearIndependence,
   PivotColumn,
   Basis,
   Dimension
 ]

 EXPAND(Rank) -> [
   Image,
   Dimension,
   ColumnSpace,
   RowSpace,
   RankNullityTheorem
 ]

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

 STOP_CONDITION = "Stop when the query is resolved, confidence is sufficient, and no required dependency remains unresolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Algebra Ontology"

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

 ROUTE_RULES = [
   "Image -> Column Space for matrix representations",
   "Image -> Rank for dimensional reasoning",
   "Image -> Basis for spanning-vector reasoning",
   "Image -> Surjectivity for codomain-coverage reasoning",
   "Image -> Kernel for rank-nullity reasoning",
   "Image -> Linear Transformation for mapping behaviour"
 ]
}

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 canonical mathematical image semantics.",
   "Preserve domain-to-codomain directionality.",
   "Preserve image-range equivalence.",
   "Preserve matrix-image and column-space equivalence.",
   "Preserve rank as dimension of image.",
   "Explicitly disambiguate unrelated meanings of image."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "The image of T: V -> W is the set of all outputs T(v) for v in V."
 SYMBOLIC_SUMMARY = "im(T)={T(v) | v in V}"
 MATRIX_SUMMARY = "im(A)=Col(A)=span(columns(A))"
 RANK_SUMMARY = "rank(T)=dim(im(T))"
 SURJECTIVITY_SUMMARY = "T surjective <=> im(T)=W"
 RANK_NULLITY_SUMMARY = "dim(V)=rank(T)+nullity(T)"
}

FLOW {
 INPUT
 -> detect_term("image")
 -> disambiguate_mathematical_context
 -> identify_mapping_or_matrix
 -> identify_domain
 -> identify_codomain
 -> construct_attainable_output_set
 -> define_image
 -> validate_image_membership
 -> validate_subspace_when_linear
 -> resolve_range_equivalence
 -> resolve_column_space_when_matrix
 -> derive_basis_when_required
 -> derive_rank
 -> evaluate_surjectivity
 -> apply_rank_nullity_when_applicable
 -> link_related_ontologies
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The image of a mapping consists of the codomain elements actually attained by inputs from the domain. For a linear transformation it is a vector subspace of the codomain. It is equivalent to the range, and for a matrix transformation it is the column space. Its dimension is the rank, and the transformation is surjective exactly when its image equals its codomain."
}

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

}

END_FLOW