Column Space Ontology

FLOW Column_Space_Ontology_v1.0

PAGE:
  title: "Column Space Ontology"
  canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/column-space-ontology.html"
  language: "en-GB"
  domain: "Mathematics > Algebra > Linear Algebra > Column Space"

DEFINE ColumnSpaceOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: ColumnSpace,
    parent_entities: [VectorSubspace, Image, LinearAlgebraConcept],
    related_entities: [
      Matrix,
      LinearTransformation,
      VectorSpace,
      RowSpace,
      NullSpace,
      Rank,
      Basis,
      PivotColumn,
      LinearCombination,
      Span,
      Image,
      SystemOfEquations
    ]
  },

  DEFINITION: {
    meaning:
      "The column space of a matrix is the vector subspace spanned by its columns. Equivalently, it is the image of the associated linear transformation.",
    matrix_form:
      Col(A)=span{a_1,...,a_n},
    transformation_form:
      Image(T_A)=Col(A)
  },

  SEMANTIC_PRIMITIVES: {
    Column:
      vector_formed_by_entries_in_one_matrix_column,
    Span:
      set_of_all_linear_combinations_of_columns,
    Image:
      set_of_all_outputs_Ax,
    PivotColumn:
      original_matrix_column_corresponding_to_a_pivot_position,
    Rank:
      dimension_of_column_space
  },

  MATRIX_CONTEXT: {
    A:
      m_by_n_matrix,

    columns:
      [a_1,...,a_n],

    ambient_space:
      F^m,

    column_space:
      subspace_of_F^m
  },

  SPAN_DEFINITION: {
    Col(A):
      {
        c_1*a_1 + ... + c_n*a_n
        |
        c_i IN F
      }
  },

  IMAGE_RELATION: {
    Col(A):
      {A*x | x IN F^n},

    equivalence:
      Col(A)=Image(T_A)
  },

  SUBSPACE_PROPERTY: {
    zero_vector_included:
      TRUE,

    closed_under_addition:
      TRUE,

    closed_under_scalar_multiplication:
      TRUE
  },

  RANK_RELATION: {
    rank(A):
      dim(Col(A))
  },

  ROW_RANK_COLUMN_RANK_RELATION: {
    dim(Col(A)):
      dim(RowSpace(A))
  },

  PIVOT_COLUMN_METHOD: {
    INPUT:
      matrix_A,

    PROCESS: [
      row_reduce_A,
      identify_pivot_positions,
      select_corresponding_columns_from_original_matrix
    ],

    OUTPUT:
      basis_for_Col(A)
  },

  ORIGINAL_COLUMN_REQUIREMENT: {
    rule:
      basis_for_column_space_must_use_pivot_columns_from_original_matrix,

    warning:
      pivot_columns_of_RREF(A)_generally_span_different_subspace_in_F^m
  },

  BASIS: {
    basis_for_column_space:
      linearly_independent_subset_of_original_columns_spanning_Col(A)
  },

  DIMENSION: {
    dim(Col(A)):
      rank(A)
  },

  LINEAR_COMBINATION_INTERPRETATION: {
    b IN Col(A)
    IFF:
      EXISTS x:
        A*x=b
  },

  SYSTEM_OF_EQUATIONS_RELATION: {
    A*x=b:

    consistent:
      IFF b IN Col(A)
  },

  CONSISTENCY_TEST: {
    b_in_column_space:
      equivalent_to_rank(A)=rank([A|b])
  },

  SURJECTIVITY_RELATION: {
    T_A:F^n->F^m:

    surjective:
      IFF Col(A)=F^m,

    equivalent:
      rank(A)=m
  },

  FULL_ROW_RANK_RELATION: {
    condition:
      rank(A)=m,

    consequence:
      Col(A)=F^m
  },

  INJECTIVITY_CONTRAST: {
    injectivity:
      determined_by_null_space,

    surjectivity:
      determined_by_column_space
  },

  ZERO_MATRIX: {
    Col(0):
      {0},

    rank:
      0
  },

  IDENTITY_MATRIX: {
    Col(I_n):
      F^n,

    rank:
      n
  },

  SQUARE_INVERTIBLE_MATRIX: {
    A_n_by_n:

    IF det(A)!=0:
      Col(A)=F^n
  },

  SINGULAR_MATRIX_RELATION: {
    square_A_singular:
      Col(A)_proper_subspace_of_F^n
  },

  COLUMN_DEPENDENCE_RELATION: {
    rank(A)<n:
      columns_linearly_dependent
      when_n_exceeds_rank,

    independent_columns:
      basis_for_Col(A)
  },

  COLUMN_SPACE_AND_NULL_SPACE: {
    column_space:
      subset_of_codomain,

    null_space:
      subset_of_domain,

    semantic_rule:
      do_not_confuse_their_ambient_spaces
  },

  FOUR_FUNDAMENTAL_SUBSPACES: {
    for_A_m_by_n: [
      ColumnSpace(A),
      RowSpace(A),
      NullSpace(A),
      LeftNullSpace(A)
    ]
  },

  ORTHOGONAL_COMPLEMENT_RELATION: {
    over_real_or_complex_inner_product_context:

    Col(A)^⊥:
      Null(A^*),

    real_case:
      Col(A)^⊥=Null(A^T)
  },

  LEFT_NULL_SPACE_RELATION: {
    LeftNullSpace(A):
      Null(A^T),

    relation:
      orthogonal_complement_of_Col(A)
  },

  PROJECTION_RELATION: {
    orthogonal_projection_onto_Col(A):
      used_in_least_squares,

    projection_matrix:
      A*(A^T*A)^(-1)*A^T
      when_columns_are_linearly_independent
  },

  LEAST_SQUARES_RELATION: {
    inconsistent_Ax=b:
      project_b_onto_Col(A),

    residual:
      r=b-A*x_hat,

    orthogonality:
      r orthogonal_to Col(A)
  },

  NORMAL_EQUATIONS_RELATION: {
    A^T*A*x=A^T*b,

    semantic_role:
      enforces_residual_orthogonal_to_column_space
  },

  QR_RELATION: {
    A=Q*R,

    columns_of_Q:
      orthonormal_basis_for_Col(A)
      when_A_has_full_column_rank
  },

  SVD_RELATION: {
    A=U*Sigma*V^*,

    column_space:
      span_of_left_singular_vectors_corresponding_to_nonzero_singular_values
  },

  COLUMN_SPACE_BASIS_FROM_SVD: {
    basis:
      first_r_relevant_columns_of_U,

    r:
      rank(A)
  },

  CHANGE_OF_BASIS_RELATION: {
    column_space_as_subspace:
      intrinsic_to_linear_map_image_under_fixed_codomain_coordinates,

    matrix_columns:
      depend_on_domain_basis_and_codomain_basis
  },

  ELEMENTARY_ROW_OPERATION_CAUTION: {
    row_operations:
      preserve_linear_dependence_relations_among_columns
      and_rank,

    but:
      generally_change_actual_column_space_as_subset_of_F^m
  },

  ELEMENTARY_COLUMN_OPERATION_RELATION: {
    invertible_column_operations:
      preserve_column_space,

    matrix_relation:
      A*Q
      with_Q_invertible
      has_same_column_space_as_A
  },

  PRODUCT_RELATION: {
    Col(A*B):
      SUBSET_OR_EQUAL Col(A)
  },

  COMPOSITION_RELATION: {
    Image(S∘T):
      SUBSET_OR_EQUAL Image(S)
      and_is_image_of_T_then_S
  },

  BLOCK_MATRIX_RELATION: {
    horizontal_concatenation:
      Col([A B])=Col(A)+Col(B)
  },

  DIRECT_SUM_CONDITION: {
    IF Col(A)∩Col(B)={0}
    AND combined_columns_independent_across_spaces:
      Col([A B])=Col(A)⊕Col(B)
  },

  LINEAR_TRANSFORMATION_IMAGE: {
    T:V->W,

    Image(T):
      {T(v) | v IN V},

    matrix_representation:
      column_space_of_matrix_of_T
  },

  BASIS_IMAGE_RELATION: {
    if_B=[v_1,...,v_n]_basis_of_domain:

      Image(T):
        span{T(v_1),...,T(v_n)}
  },

  RANK_NULLITY_RELATION: {
    rank(T):
      dim(Image(T)),

    relation:
      dim(V)=rank(T)+nullity(T)
  },

  EIGENSPACE_RELATION: {
    eigenspace:
      not_generally_column_space,

    caution:
      avoid_conflation
  },

  AFFINE_SYSTEM_RELATION: {
    consistent_nonhomogeneous_system:
      b_must_lie_in_Col(A)
  },

  COLUMN_SPACE_GEOMETRY: {
    interpretation:
      all_reachable_outputs_of_linear_map,

    rank:
      number_of_independent_output_directions
  },

  DIMENSION_COLLAPSE: {
    rank_less_than_m:
      transformation_does_not_reach_full_codomain
  },

  PARAMETER_REASONING: {
    matrix_A(t):

    tasks: [
      determine_parameter_values_where_column_space_dimension_changes,
      identify pivot-column changes,
      analyse reachability conditions
    ]
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "Col(A)",
      "column space of A",
      "span of the columns of A",
      "image of matrix transformation A"
    ],

    AMBIGUITY:
      "image" may refer_to_general_function_image_or_visual image in nonmathematical context
  },

  NATURAL_LANGUAGE_MAPPING: {
    "column space":
      span_of_matrix_columns,

    "image of A":
      set_of_all_Ax,

    "range of matrix transformation":
      column_space,

    "pivot columns":
      original_columns_forming_basis
  },

  ERROR_DETECTION: {
    AmbientSpaceError:
      column_space_placed_in_F^n_instead_of_F^m_for_m_by_n_matrix
      -> flag,

    RREFPivotColumnError:
      using_RREF_columns_as_basis_for_original_column_space
      -> flag,

    ConsistencyError:
      Ax=b_called_consistent_when_b_not_in_column_space
      -> flag,

    RankError:
      column_space_dimension_not_equal_rank
      -> flag,

    NullSpaceConfusion:
      column_space_and_null_space_conflated
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "ColumnSpace IS_A VectorSubspace",
      "ColumnSpace IS_A Image"
    ],

    RELATED_TO: [
      "ColumnSpace RELATED_TO Rank",
      "ColumnSpace RELATED_TO RowSpace",
      "ColumnSpace RELATED_TO NullSpace",
      "ColumnSpace RELATED_TO LinearTransformation",
      "ColumnSpace RELATED_TO LeastSquares",
      "ColumnSpace RELATED_TO SingularValueDecomposition"
    ],

    DEPENDS_ON: [
      VectorSpace,
      LinearCombination,
      Span
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    equivalent_descriptions: [
      "Col(A)",
      "span of the columns of A",
      "{Ax | x in F^n}",
      "image of the linear map represented by A"
    ]
  },

  CONFIDENCE: {
    column_space_confidence:
      IF basis_vectors_are_original_columns
      AND span_and_independence_verified
      THEN 1.0,

    rank_confidence:
      IF pivot_count_verified
      THEN 1.0,

    membership_confidence:
      IF Ax=b_solvability_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_column_space_query,
      identify matrix columns,
      compute row echelon form,
      identify pivot positions,
      select original pivot columns,
      construct column-space basis,
      compute rank,
      test membership,
      analyse system consistency,
      test surjectivity,
      connect to left null space,
      derive orthogonal projection relations,
      use QR_or_SVD_basis_when_relevant,
      detect column-space reasoning errors,
      link related ontologies
    ],

    preferred_representation:
      typed_vector_subspace_as_image_of_linear_map,

    reasoning_mode:
      recursive_span_pivot_image_and_membership_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseColumnSpace(AorT,Context):

      object := ParseLinearObject(AorT)

      IF IsMatrix(object):
        A := object
        [m,n] := Dimensions(A)

        R := RowReduce(A)
        pivot_indices := IdentifyPivotColumns(R)

        basis :=
          SelectColumnsFromOriginalMatrix(A,pivot_indices)

        rank_value := Count(basis)

        verified :=
          VerifyLinearIndependence(basis)
          AND VerifySpanEqualsImage(A,basis)
          AND rank_value=Rank(A)

        RETURN {
          entity:ColumnSpace,
          ambient_space:F^m,
          basis,
          rank:rank_value,
          pivot_columns:pivot_indices,
          verified
        }

      ELSE IF IsLinearTransformation(object):
        image := ComputeImage(object)
        basis := Basis(image)

        RETURN {
          entity:ColumnSpace,
          interpretation:ImageOfLinearTransformation,
          ambient_space:Codomain(object),
          basis,
          rank:Dimension(image),
          verified:TRUE
        }

      ELSE:
        RETURN RedirectToAppropriateImageOntology
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      column_space_is_subspace_of_codomain=TRUE,

    invariant_2:
      column_space_equals_image_of_matrix_map=TRUE,

    invariant_3:
      column_space_dimension_equals_rank=TRUE,

    invariant_4:
      original_pivot_columns_form_valid_basis=TRUE,

    invariant_5:
      b_in_column_space_iff_Ax_equals_b_is_consistent=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      column_space_definition,
      image_equivalence,
      pivot_column_basis_rule,
      rank_relation,
      consistency_relation,
      orthogonal_complement_relation
    ],

    purpose:
      "Detect semantic drift between revisions of the ontology."
  },

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      column_space_is_span_of_columns,
      column_space_equals_image,
      ambient_space_is_codomain,
      dimension_equals_rank,
      basis_uses_original_pivot_columns
    ],

    revision_triggers: [
      semantic_conflict,
      RankOntology_update,
      VectorSpaceOntology_update,
      LinearTransformationOntology_update,
      numerical_basis_method_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      ColumnSpace,
      Image,
      Matrix,
      LinearTransformation,
      VectorSpace,
      Column,
      Span,
      Basis,
      PivotColumn,
      Rank,
      LeftNullSpace,
      SystemOfEquations
    ],

    edges: [
      ColumnSpace -> IS_A -> VectorSubspace,
      ColumnSpace -> EQUIVALENT_TO -> Image,
      Matrix -> HAS_COLUMN -> Column,
      Column -> SPANS -> ColumnSpace,
      ColumnSpace -> HAS_BASIS -> Basis,
      Basis -> SELECTED_BY -> PivotColumn,
      ColumnSpace -> HAS_DIMENSION -> Rank,
      ColumnSpace -> ORTHOGONAL_COMPLEMENT_OF -> LeftNullSpace,
      SystemOfEquations -> IS_CONSISTENT_IF -> RHSInColumnSpace,
      LinearTransformation -> HAS_IMAGE -> ColumnSpace
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    VectorSpaceOntology:
      subspace_structure,

    RankOntology:
      dimension_relation,

    MatrixOntology:
      column representation,

    LinearTransformationOntology:
      image semantics,

    NullSpaceOntology:
      domain-side contrast,

    RowSpaceOntology:
      equal_dimension_relation,

    SystemOfEquationsOntology:
      consistency criterion,

    LeastSquaresOntology:
      projection onto column space,

    SingularValueDecompositionOntology:
      orthonormal column-space basis
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      column_space_defined,
      image_equivalence_defined,
      ambient_space_defined,
      subspace_properties_defined,
      pivot_column_basis_method_defined,
      rank_relation_defined,
      consistency_and_surjectivity_relations_defined,
      orthogonal_complement_relation_defined,
      QR_and_SVD_relations_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Column_Space_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyMatrixOrLinearTransformation
    -> ResolveCodomainAndAmbientSpace
    -> ExtractColumnsOrImage
    -> RowReduceWhenMatrixBased
    -> IdentifyPivotPositions
    -> SelectOriginalPivotColumns
    -> ConstructColumnSpaceBasis
    -> ComputeRank
    -> TestMembershipAndSystemConsistency
    -> AnalyseSurjectivity
    -> DeriveOrthogonalComplementAndLeastSquaresRelations
    -> VerifyImageAndSpanSemantics
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    object,
    ambient_space,
    columns,
    pivot_columns,
    basis,
    rank,
    span,
    image,
    membership_tests,
    consistency_relation,
    surjectivity,
    left_null_space_relation,
    orthogonal_projection_relation,
    least_squares_relation,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Column_Space_Ontology_v1.0