Rank Ontology

FLOW Rank_Ontology_v1.0

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

DEFINE RankOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: Rank,
    parent_entities: [LinearAlgebraConcept, DimensionInvariant],
    related_entities: [
      Matrix,
      LinearTransformation,
      VectorSpace,
      RowSpace,
      ColumnSpace,
      NullSpace,
      Kernel,
      Image,
      Dimension,
      Pivot,
      ReducedRowEchelonForm,
      Determinant,
      RankNullityTheorem,
      SystemOfEquations
    ]
  },

  DEFINITION: {
    meaning:
      "The rank of a matrix or linear transformation is the dimension of its image, equivalently the dimension of its column space and row space in finite-dimensional matrix form.",
    matrix_form:
      rank(A)=dim(ColumnSpace(A))=dim(RowSpace(A)),
    transformation_form:
      rank(T)=dim(Image(T))
  },

  SEMANTIC_PRIMITIVES: {
    Rank:
      dimension_of_image,
    ColumnSpace:
      span_of_matrix_columns,
    RowSpace:
      span_of_matrix_rows,
    Pivot:
      leading_position_in_echelon_form,
    Nullity:
      dimension_of_kernel,
    FullRank:
      maximum_possible_rank_for_given_dimensions
  },

  MATRIX_DIMENSION_BOUNDS: {
    for_A_m_by_n:
      0 <= rank(A) <= min(m,n)
  },

  ZERO_MATRIX: {
    rank:
      0
  },

  IDENTITY_MATRIX: {
    I_n:
      rank=n
  },

  FULL_ROW_RANK: {
    condition:
      rank(A)=m
      for_m_by_n_matrix_with_m<=n
  },

  FULL_COLUMN_RANK: {
    condition:
      rank(A)=n
      for_m_by_n_matrix_with_n<=m
  },

  FULL_RANK: {
    condition:
      rank(A)=min(m,n)
  },

  ROW_REDUCTION_METHOD: {
    INPUT:
      matrix_A,

    PROCESS: [
      compute_row_echelon_or_reduced_row_echelon_form,
      count_pivot_rows_or_pivot_positions
    ],

    OUTPUT:
      rank(A)
  },

  PIVOT_RELATION: {
    number_of_pivots:
      rank(A)
  },

  ROW_SPACE_RELATION: {
    rank(A):
      dimension_of_RowSpace(A),

    basis:
      nonzero_rows_of_row_echelon_form_can_form_basis_for_row_space
  },

  COLUMN_SPACE_RELATION: {
    rank(A):
      dimension_of_ColumnSpace(A),

    basis_selection:
      pivot_columns_of_original_matrix_form_basis_for_column_space
  },

  ROW_RANK_COLUMN_RANK_THEOREM: {
    rule:
      row_rank(A)=column_rank(A)
  },

  LINEAR_TRANSFORMATION_RELATION: {
    T:V->W,

    rank(T):
      dim(Image(T))
  },

  KERNEL_NULLITY_RELATION: {
    nullity(T):
      dim(Kernel(T))
  },

  RANK_NULLITY_THEOREM: {
    finite_dimensional_domain_V:
      dim(V)=rank(T)+nullity(T),

    matrix_A_m_by_n:
      n=rank(A)+nullity(A)
  },

  INJECTIVITY_RELATION: {
    T_injective
      IFF nullity(T)=0,

    finite_matrix_case:
      full_column_rank
      -> injective_linear_map
  },

  SURJECTIVITY_RELATION: {
    T_surjective
      IFF rank(T)=dim(codomain)
      in_finite_dimensional_case,

    matrix_case:
      full_row_rank
      -> surjective_map_to_F^m
  },

  BIJECTIVITY_RELATION: {
    square_linear_map:
      rank=n
      IFF invertible
  },

  DETERMINANT_RELATION: {
    square_matrix_A_n_by_n:
      rank(A)=n
      IFF det(A)!=0
  },

  SINGULARITY_RELATION: {
    square_matrix:
      rank(A)<n
      IFF singular
  },

  SYSTEM_OF_EQUATIONS_RELATION: {
    A*x=b,

    consistency_condition:
      rank(A)=rank([A|b]),

    unique_solution_condition:
      rank(A)=rank([A|b])=n,

    infinite_solution_condition:
      rank(A)=rank([A|b])<n,

    no_solution_condition:
      rank(A)!=rank([A|b])
  },

  AUGMENTED_MATRIX_RELATION: {
    augmented_rank:
      rank([A|b]),

    semantic_role:
      consistency_analysis
  },

  MINOR_DEFINITION: {
    rank(A):
      largest_integer_r
      such_that_some_r_by_r_minor_has_nonzero_determinant
  },

  DETERMINANT_MINOR_RELATION: {
    all_(r+1)_by_(r+1)_minors_zero
      AND
      some_r_by_r_minor_nonzero
      -> rank(A)=r
  },

  FACTORISATION_RELATION: {
    rank(A*B):
      <= min(rank(A),rank(B))
  },

  SUM_RELATION: {
    rank(A+B):
      <= rank(A)+rank(B)
  },

  TRANSPOSE_INVARIANCE: {
    rank(A^T):
      rank(A)
  },

  SIMILARITY_INVARIANCE: {
    IF B=P^(-1)*A*P:
      rank(B)=rank(A)
  },

  EQUIVALENCE_INVARIANCE: {
    IF B=P*A*Q
    WHERE P,Q invertible:
      rank(B)=rank(A)
  },

  SCALAR_MULTIPLICATION: {
    IF c!=0:
      rank(c*A)=rank(A),

    IF c=0:
      rank(c*A)=0
  },

  OUTER_PRODUCT_RELATION: {
    A=u*v^T,

    IF u!=0 AND v!=0:
      rank(A)=1
  },

  RANK_ONE_MATRIX: {
    characterisation:
      nonzero_matrix_expressible_as_outer_product_of_two_nonzero_vectors
  },

  LOW_RANK_MATRIX: {
    meaning:
      rank_much_smaller_than_matrix_dimensions,

    applications: [
      compression,
      approximation,
      latent_factor_models,
      numerical_linear_algebra
    ]
  },

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

    rank:
      number_of_nonzero_singular_values
  },

  NUMERICAL_RANK: {
    concept:
      effective_rank_under_tolerance,

    caution:
      floating_point_near_zero_singular_values_require_threshold
  },

  EXACT_VS_NUMERICAL_RANK: {
    exact_rank:
      algebraic_nonzero_structure,

    numerical_rank:
      tolerance_dependent
  },

  GRAM_MATRIX_RELATION: {
    A^T*A:
      rank_same_as_A
      over_real_or_complex_inner_product_context,

    also:
      rank(A^*A)=rank(A)
  },

  NORMAL_EQUATION_RELATION: {
    least_squares:
      A^T*A*x=A^T*b,

    rank_deficiency:
      affects_uniqueness
  },

  PSEUDOINVERSE_RELATION: {
    MoorePenroseInverse:
      handles_rank_deficient_matrices,

    rank:
      rank(A^+)=rank(A)
  },

  PROJECTOR_RELATION: {
    projection_matrix_P:
      rank(P)=trace(P)
      for_idempotent_projection_over_standard_finite_dimensional_context
  },

  IDEMPOTENT_MATRIX_RELATION: {
    P^2=P,

    eigenvalues:
      0_or_1,

    rank:
      number_of_nonzero_eigenvalues_counting_multiplicity_in_diagonalisable_context
  },

  EIGENVALUE_RELATION: {
    general_rank:
      not_equal_to_number_of_nonzero_eigenvalues_for_arbitrary_nondiagonalisable_matrix,

    special_cases:
      diagonal_or_diagonalisable_matrices_allow_direct_counting_of_nonzero_diagonal_or_eigenvalue_entries
  },

  TRACE_CAUTION: {
    rank_not_generally_equal_trace:
      TRUE
  },

  TENSOR_RANK_CAUTION: {
    matrix_rank:
      differs_from_higher_order_tensor_rank,

    redirect:
      TensorRankOntology
  },

  MODULE_RANK_RELATION: {
    module_rank:
      broader_algebraic_concept,

    caution:
      may_require_free_module_or_integral_domain_context
  },

  VECTOR_FAMILY_RANK: {
    matrix_columns_as_vectors:
      rank_equals_maximum_number_of_linearly_independent_columns,

    matrix_rows_as_vectors:
      rank_equals_maximum_number_of_linearly_independent_rows
  },

  LINEAR_DEPENDENCE_RELATION: {
    rank_less_than_number_of_columns:
      columns_linearly_dependent,

    rank_less_than_number_of_rows:
      rows_linearly_dependent
  },

  BASIS_EXTRACTION: {
    column_space_basis:
      pivot_columns_of_original_matrix,

    row_space_basis:
      nonzero_rows_of_echelon_form
  },

  DIMENSION_INTERPRETATION: {
    rank:
      number_of_independent_output_directions_generated_by_linear_map
  },

  GEOMETRIC_MEANING: {
    linear_map:
      rank_equals_dimension_of_transformed_space_image
  },

  DIMENSION_COLLAPSE: {
    rank_deficiency:
      indicates_loss_of_dimensions_under_linear_map
  },

  CHANGE_OF_BASIS_INVARIANCE: {
    matrix_representation_changes:
      rank_unchanged
  },

  BLOCK_MATRIX_RELATION: {
    block_diagonal:
      rank(diag(A,B))=rank(A)+rank(B)
  },

  DIRECT_SUM_RELATION: {
    linear_maps_T_and_S:
      rank(T⊕S)=rank(T)+rank(S)
  },

  COMPOSITION_RELATION: {
    rank(S∘T):
      <= min(rank(S),rank(T))
  },

  SYLVESTER_RANK_INEQUALITY: {
    for_A_m_by_n_and_B_n_by_p:
      rank(A*B)>=rank(A)+rank(B)-n
  },

  FROBENIUS_RANK_INEQUALITY: {
    relation:
      rank(A*B)+rank(B*C)
      <=
      rank(B)+rank(A*B*C)
      under_compatible_dimensions
  },

  PARAMETER_REASONING: {
    matrix_A(t):
      entries_depend_on_parameter_t,

    tasks: [
      determine_parameter_values_where_rank_drops,
      analyse_minors,
      classify_piecewise_rank
    ]
  },

  RANK_DROP_LOCUS: {
    condition:
      all_r_by_r_minors_vanish,

    algebraic_geometry_relation:
      determinantal_variety
  },

  DETERMINANTAL_VARIETY_RELATION: {
    matrices_of_rank_at_most_r:
      algebraic_set_defined_by_vanishing_of_all_(r+1)_minors
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "rank(A)",
      "dimension of column space",
      "number of pivots",
      "rank of linear map T"
    ],

    AMBIGUITY: [
      "rank" may refer_to_group_rank_module_rank_tensor_rank_or_ordering
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "rank of a matrix":
      dimension_of_column_or_row_space,

    "full rank":
      maximum_possible_rank,

    "rank deficient":
      rank_less_than_maximum_possible,

    "number of pivots":
      rank
  },

  ERROR_DETECTION: {
    PivotCountError:
      incorrect_number_of_pivots
      -> flag,

    ColumnBasisError:
      pivot_columns_taken_from_reduced_matrix_instead_of_original_for_column_space_basis
      -> flag,

    RankNullityError:
      domain_dimension_not_equal_rank_plus_nullity
      -> flag,

    DeterminantRankError:
      det_nonzero_but_rank_not_full_for_square_matrix
      -> flag,

    NumericalToleranceError:
      near_zero_singular_values_treated_without_declared_threshold
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "Rank IS_A DimensionInvariant"
    ],

    RELATED_TO: [
      "Rank RELATED_TO Matrix",
      "Rank RELATED_TO LinearTransformation",
      "Rank RELATED_TO RowSpace",
      "Rank RELATED_TO ColumnSpace",
      "Rank RELATED_TO Nullity",
      "Rank RELATED_TO Determinant",
      "Rank RELATED_TO SingularValueDecomposition"
    ],

    DEPENDS_ON: [
      VectorSpace,
      LinearIndependence,
      Dimension
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    equivalent_matrix_definitions: [
      "dimension of column space",
      "dimension of row space",
      "number of pivots",
      "maximum number of linearly independent columns",
      "maximum number of linearly independent rows",
      "largest nonzero minor order"
    ]
  },

  CONFIDENCE: {
    exact_rank_confidence:
      IF row_reduction_or_minor_analysis_verified
      THEN 1.0,

    numerical_rank_confidence:
      depends_on [
        tolerance,
        singular_value_separation,
        numerical_precision
      ],

    transformation_rank_confidence:
      IF image_dimension_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_rank_query,
      compute_rank_by_row_reduction,
      count pivots,
      identify row and column space dimensions,
      extract bases,
      compute nullity,
      apply rank-nullity,
      analyse system consistency,
      test full rank,
      infer invertibility for square matrices,
      compute rank from SVD,
      analyse parameter-dependent rank,
      detect rank reasoning errors,
      link related ontologies
    ],

    preferred_representation:
      typed_dimension_invariant_with_row_column_image_views,

    reasoning_mode:
      recursive_row_reduction_dimension_and_kernel_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseRank(AorT,Context):

      object := ParseLinearObject(AorT)

      IF IsMatrix(object):
        [m,n] := Dimensions(object)
        echelon := RowReduce(object)
        pivots := CountPivots(echelon)
        rank_value := pivots

        column_basis :=
          OriginalPivotColumns(object,echelon)

        row_basis :=
          NonzeroRows(echelon)

        nullity :=
          n-rank_value

        properties := {
          full_rank:(rank_value=min(m,n)),
          full_row_rank:(rank_value=m),
          full_column_rank:(rank_value=n),
          nullity:nullity
        }

      ELSE IF IsLinearTransformation(object):
        image := ComputeImage(object)
        kernel := ComputeKernel(object)
        rank_value := Dimension(image)
        nullity := Dimension(kernel)

        properties := {
          image:image,
          kernel:kernel,
          nullity:nullity
        }

      ELSE:
        RETURN RedirectToAppropriateRankOntology

      verified :=
        VerifyRankNullityAndEquivalentDefinitions(
          object,
          rank_value,
          properties
        )

      RETURN {
        entity:Rank,
        object:object,
        rank:rank_value,
        properties,
        verified
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      row_rank_equals_column_rank=TRUE,

    invariant_2:
      pivot_count_equals_rank=TRUE,

    invariant_3:
      rank_plus_nullity_equals_domain_dimension=TRUE,

    invariant_4:
      rank_invariant_under_invertible_row_and_column_transformations=TRUE,

    invariant_5:
      square_full_rank_matches_nonzero_determinant=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      rank_definition,
      row_column_equivalence,
      pivot_semantics,
      rank_nullity_relation,
      determinant_relation,
      system_consistency_rules
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      rank_is_image_dimension,
      row_rank_equals_column_rank,
      rank_bounds_by_matrix_dimensions,
      rank_nullity_theorem,
      full_square_rank_equivalent_to_invertibility
    ],

    revision_triggers: [
      semantic_conflict,
      MatrixOntology_update,
      VectorSpaceOntology_update,
      DeterminantOntology_update,
      numerical_rank_model_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      Rank,
      Matrix,
      LinearTransformation,
      RowSpace,
      ColumnSpace,
      Image,
      Kernel,
      Nullity,
      Pivot,
      Determinant,
      SingularValue,
      SystemOfEquations
    ],

    edges: [
      Rank -> MEASURES_DIMENSION_OF -> Image,
      Matrix -> HAS_ROW_SPACE -> RowSpace,
      Matrix -> HAS_COLUMN_SPACE -> ColumnSpace,
      Rank -> EQUALS_DIMENSION_OF -> RowSpace,
      Rank -> EQUALS_DIMENSION_OF -> ColumnSpace,
      Rank -> EQUALS_COUNT_OF -> Pivot,
      Rank -> RELATED_TO -> Nullity,
      Rank -> RELATED_TO -> Determinant,
      Rank -> EQUALS_COUNT_OF_NONZERO -> SingularValue,
      Rank -> CLASSIFIES -> SystemOfEquations
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    MatrixOntology:
      direct_matrix_context,

    VectorSpaceOntology:
      row_column_image_dimensions,

    LinearTransformationOntology:
      image_dimension,

    DeterminantOntology:
      full_rank_square_equivalence,

    EigenvalueOntology:
      singularity_and_zero_eigenvalue_relation,

    SystemOfEquationsOntology:
      consistency_and_solution_count,

    SingularValueDecompositionOntology:
      numerical_and exact rank,

    AlgebraicGeometryOntology:
      determinantal_varieties
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      rank_defined,
      row_and_column_space_equivalence_defined,
      pivot_method_defined,
      rank_nullity_defined,
      determinant_and_invertibility_relations_defined,
      system_consistency_relations_defined,
      minor_definition_defined,
      SVD_relation_defined,
      numerical_rank_distinction_defined,
      parameter_rank_reasoning_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Rank_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyMatrixOrLinearTransformation
    -> DetermineDimensions
    -> ComputeRowEchelonFormOrImage
    -> CountPivotsOrImageBasisDimension
    -> ComputeRank
    -> DeriveRowAndColumnSpaceBases
    -> ComputeNullity
    -> ApplyRankNullity
    -> DetermineFullRankAndInvertibilityStatus
    -> AnalyseSystemConsistencyWhenRelevant
    -> ApplyMinorOrSVDReasoningWhenRequired
    -> VerifyEquivalentRankDefinitions
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    object,
    dimensions,
    rank,
    row_space,
    column_space,
    row_space_basis,
    column_space_basis,
    pivots,
    nullity,
    full_rank_status,
    injectivity,
    surjectivity,
    invertibility,
    determinant_relation,
    system_consistency_relation,
    singular_values,
    numerical_rank,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Rank_Ontology_v1.0