Eigenvector Ontology

FLOW Eigenvector_Ontology_v1.0

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

DEFINE EigenvectorOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: Eigenvector,
    parent_entities: [LinearAlgebraConcept, SpectralConcept, VectorConcept],
    related_entities: [
      Eigenvalue,
      Eigenspace,
      LinearTransformation,
      Matrix,
      VectorSpace,
      Kernel,
      CharacteristicPolynomial,
      Diagonalisation,
      Spectrum,
      Basis,
      InvariantSubspace
    ]
  },

  DEFINITION: {
    meaning:
      "An eigenvector of a linear transformation is a nonzero vector whose direction is preserved by the transformation, changing only by a scalar factor.",
    canonical_relation:
      T(v)=lambda*v,
    constraints: [
      v != 0,
      lambda belongs_to_scalar_field
    ]
  },

  MATRIX_FORM: {
    relation:
      A*v=lambda*v,
    equivalent:
      (A-lambda*I)*v=0
  },

  SEMANTIC_PRIMITIVES: {
    Eigenvector:
      nonzero_vector_scaled_by_linear_operator,
    Eigenvalue:
      associated_scalar_scale_factor,
    Eigenspace:
      vector_space_of_all_vectors_satisfying_same_eigenvalue_equation,
    Direction:
      one_dimensional_subspace_spanned_by_nonzero_vector,
    InvariantDirection:
      direction_preserved_by_linear_transformation
  },

  NONZERO_REQUIREMENT: {
    zero_vector:
      NEVER_eigenvector,

    reason:
      zero_vector_satisfies_Av=lambda_v_trivially_for_all_lambda
      and_would_destroy_eigenvalue_specific_semantics
  },

  EIGENVALUE_RELATION: {
    v_is_eigenvector:
      EXISTS lambda:
        A*v=lambda*v,

    lambda:
      eigenvalue_associated_with_v
  },

  EIGENSPACE_RELATION: {
    E_lambda:
      ker(A-lambda*I),

    eigenvectors_for_lambda:
      E_lambda\{0}
  },

  SPAN_PROPERTY: {
    IF v_is_eigenvector_for_lambda:
      every_nonzero_scalar_multiple_c*v
      is_also_eigenvector_for_lambda
  },

  ONE_DIMENSIONAL_DIRECTION: {
    eigendirection:
      span(v),

    geometric_meaning:
      transformation_preserves_line_through_origin_generated_by_v
  },

  INVARIANT_SUBSPACE_RELATION: {
    eigenspace:
      invariant_under_A,

    rule:
      A(E_lambda) SUBSET_OR_EQUAL E_lambda
  },

  DISTINCT_EIGENVALUE_INDEPENDENCE: {
    theorem:
      eigenvectors_corresponding_to_distinct_eigenvalues_are_linearly_independent
  },

  BASIS_OF_EIGENVECTORS: {
    condition:
      enough_linearly_independent_eigenvectors_to_span_space,

    consequence:
      operator_diagonalisable
  },

  DIAGONALISATION_RELATION: {
    A=P*D*P^(-1),

    columns_of_P:
      linearly_independent_eigenvectors,

    diagonal_entries_of_D:
      corresponding_eigenvalues
  },

  SCALAR_MULTIPLE_AMBIGUITY: {
    v_and_c*v:
      same_eigendirection,

    c:
      nonzero_scalar,

    semantic_rule:
      eigenvectors_are_not_unique_as_individual_vectors
  },

  NORMALISATION: {
    purpose:
      choose_representative_of_eigendirection,

    common_rule:
      v_hat=v/||v||,

    condition:
      norm_defined_and_v!=0
  },

  ORIENTATION_SIGN_RELATION: {
    real_vector_space:
      v_and_-v
      represent_same_eigendirection
  },

  COMPLEX_PHASE_RELATION: {
    complex_vector_space:
      v_and_e^(i*theta)*v
      represent_same_complex_eigenline
  },

  COMPUTATION_FROM_EIGENVALUE: {
    INPUT:
      matrix_A,
      known_eigenvalue_lambda,

    PROCESS: [
      form_A_minus_lambda_I,
      solve_homogeneous_system,
      find_basis_for_null_space,
      discard_zero_vector
    ],

    OUTPUT:
      eigenspace_basis_and_eigenvectors
  },

  COMPUTATION_WITHOUT_EIGENVALUE: {
    PROCESS: [
      compute_characteristic_polynomial,
      solve_for_eigenvalues,
      compute_eigenspace_for_each_eigenvalue
    ]
  },

  KERNEL_RELATION: {
    eigenvector_for_lambda:
      nonzero_element_of_kernel(A-lambda*I)
  },

  GEOMETRIC_MULTIPLICITY: {
    definition:
      dimension_of_eigenspace,

    relation:
      number_of_linearly_independent_eigenvectors_for_lambda
  },

  ALGEBRAIC_MULTIPLICITY_RELATION: {
    rule:
      geometric_multiplicity <= algebraic_multiplicity
  },

  REPEATED_EIGENVALUE: {
    may_have:
      one_or_more_linearly_independent_eigenvectors,

    diagonalisation_requirement:
      enough_eigenvectors_to_match_algebraic_structure
  },

  DEFECTIVE_EIGENVALUE: {
    condition:
      geometric_multiplicity < algebraic_multiplicity,

    consequence:
      may_prevent_diagonalisation
  },

  GENERALISED_EIGENVECTOR_RELATION: {
    definition:
      vector_v_satisfying
      (A-lambda*I)^k*v=0
      for_some_k>=1,

    ordinary_eigenvector:
      k=1
  },

  JORDAN_CHAIN_RELATION: {
    generalised_eigenvectors:
      arranged_in_chains_associated_with_Jordan_blocks
  },

  JORDAN_FORM_RELATION: {
    when_diagonalisation_fails:
      generalised_eigenvectors_support_Jordan_canonical_form
  },

  MATRIX_POWER_RELATION: {
    IF A*v=lambda*v:
      A^n*v=lambda^n*v
      for_integer_n>=0
  },

  POLYNOMIAL_OPERATOR_RELATION: {
    IF A*v=lambda*v:
      p(A)*v=p(lambda)*v
  },

  INVERSE_OPERATOR_RELATION: {
    IF A_invertible
    AND A*v=lambda*v
    AND lambda!=0:
      A^(-1)*v=(1/lambda)*v
  },

  SHIFTED_OPERATOR_RELATION: {
    (A+c*I)*v:
      (lambda+c)*v
  },

  SCALED_OPERATOR_RELATION: {
    (c*A)*v:
      (c*lambda)*v
  },

  COMMUTING_OPERATORS_RELATION: {
    IF A_and_B_commute
    AND eigenspaces_satisfy_required_conditions:
      common_eigenvectors_may_exist,

    simultaneous_diagonalisation:
      requires_additional_hypotheses
  },

  HERMITIAN_OPERATOR_RELATION: {
    eigenvectors_for_distinct_eigenvalues:
      orthogonal
  },

  REAL_SYMMETRIC_MATRIX_RELATION: {
    orthonormal_basis_of_eigenvectors:
      exists
  },

  NORMAL_MATRIX_RELATION: {
    spectral_theorem:
      orthonormal_basis_of_eigenvectors_over_ComplexNumbers
  },

  ORTHOGONAL_MATRIX_RELATION: {
    real_eigenvectors:
      associated_with_eigenvalues_plus_or_minus_one_when_real
      for_reflection_rotation_special_cases
  },

  ROTATION_MATRIX_RELATION: {
    three_dimensional_real_rotation:
      rotation_axis_vector_is_eigenvector_with_eigenvalue_1
      for_proper_rotation
  },

  MARKOV_CHAIN_RELATION: {
    stochastic_matrix:
      stationary_distribution_related_to_eigenvector_for_eigenvalue_1
      under_orientation_convention
  },

  GRAPH_THEORY_RELATION: {
    adjacency_matrix_eigenvectors:
      encode_spectral_graph_structure,

    centrality_relation:
      principal_eigenvector_used_in_eigenvector_centrality
  },

  PCA_RELATION: {
    covariance_matrix_eigenvectors:
      principal_component_directions,

    ordering:
      sorted_by_corresponding_eigenvalues
  },

  DYNAMICAL_SYSTEM_RELATION: {
    x_(k+1)=A*x_k,

    initial_state_along_eigenvector:
      evolves_by_scalar_factor_lambda_each_step
  },

  DIFFERENTIAL_EQUATION_RELATION: {
    x'(t)=A*x(t),

    eigenvector_v_with_eigenvalue_lambda:
      mode_solution=e^(lambda*t)*v
  },

  QUANTUM_MECHANICS_RELATION: {
    eigenvector_of_observable_operator:
      state_associated_with_definite_measurement_value_in_idealised_formalism
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "Av=lambda v",
      "v is an eigenvector of A",
      "ker(A-lambda I)",
      "principal eigenvector"
    ],

    REJECT: [
      "v=0 as an eigenvector"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "eigenvector":
      nonzero_vector_preserved_up_to_scale,

    "eigendirection":
      one_dimensional_subspace_spanned_by_eigenvector,

    "principal eigenvector":
      context_dependent_eigenvector_associated_with_distinguished_eigenvalue,

    "characteristic vector":
      historical_or_contextual_synonym
  },

  ERROR_DETECTION: {
    ZeroVectorError:
      v=0
      -> reject,

    WrongEigenvalueError:
      A*v_not_equal_lambda*v
      -> reject,

    SingleVectorMultiplicityError:
      one_eigenvector_treated_as_entire_eigenspace_without_span
      -> flag,

    DependenceError:
      claimed_eigenbasis_vectors_not_linearly_independent
      -> flag,

    NormalisationError:
      zero_vector_normalised
      -> reject,

    GeometricMultiplicityError:
      number_of_basis_vectors_of_eigenspace_computed_incorrectly
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "Eigenvector IS_A Vector",
      "Eigenvector IS_A SpectralConcept"
    ],

    RELATED_TO: [
      "Eigenvector RELATED_TO Eigenvalue",
      "Eigenvector RELATED_TO Eigenspace",
      "Eigenvector RELATED_TO Diagonalisation",
      "Eigenvector RELATED_TO InvariantSubspace",
      "Eigenvector RELATED_TO JordanForm"
    ],

    DEPENDS_ON: [
      VectorSpace,
      LinearTransformation,
      ScalarField
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    equivalent_conditions: [
      "v eigenvector for lambda",
      "v!=0 and Av=lambda v",
      "v is nonzero element of ker(A-lambda I)"
    ],

    projective_equivalence:
      nonzero_scalar_multiples_represent_same_eigendirection
  },

  CONFIDENCE: {
    eigenvector_confidence:
      IF v!=0
      AND Av=lambda*v_verified
      THEN 1.0,

    eigenspace_confidence:
      IF null_space_basis_verified
      THEN 1.0,

    eigenbasis_confidence:
      IF eigenvectors_independent_and_span_space
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_eigenvector_problem,
      verify_nonzero_condition,
      verify_Av_equals_lambda_v,
      compute_eigenvectors_from_eigenvalues,
      compute_eigenspace_basis,
      normalise_eigenvectors,
      detect eigendirections,
      test linear independence,
      construct eigenbasis,
      support diagonalisation,
      analyse generalised eigenvectors,
      connect eigenvectors to applications,
      detect spectral reasoning errors,
      link related ontologies
    ],

    preferred_representation:
      typed_nonzero_vector_with_spectral_scalar_relation,

    reasoning_mode:
      recursive_kernel_direction_and_basis_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseEigenvectorCandidate(A,V,Lambda,Context):

      IF V=0:
        RETURN NotEigenvector("zero vector excluded")

      IF A*V != Lambda*V:
        RETURN NotEigenvector("eigen relation fails")

      eigenspace :=
        Kernel(A-Lambda*I)

      basis :=
        Basis(eigenspace)

      normalised :=
        IF NormDefined(V)
        THEN V/Norm(V)
        ELSE V

      RETURN {
        entity:Eigenvector,
        vector:V,
        eigenvalue:Lambda,
        eigenspace:eigenspace,
        eigenspace_basis:basis,
        normalised_representative:normalised,
        eigendirection:Span(V),
        verified:TRUE
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      eigenvector_is_nonzero=TRUE,

    invariant_2:
      Av_equals_lambda_v=TRUE,

    invariant_3:
      scalar_multiples_share_same_eigenvalue=TRUE,

    invariant_4:
      eigenspace_equals_kernel_of_shifted_operator=TRUE,

    invariant_5:
      eigenbasis_requires_independence_and_spanning=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      eigenvector_definition,
      nonzero_constraint,
      eigenvalue_relation,
      eigenspace_relation,
      scalar_multiple_equivalence,
      diagonalisation_relations
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      nonzero_vector_requirement,
      Av_equals_lambda_v,
      eigenspace_kernel_relation,
      scalar_multiple_eigendirection_equivalence,
      eigenbasis_independence_requirement
    ],

    revision_triggers: [
      semantic_conflict,
      EigenvalueOntology_update,
      VectorSpaceOntology_update,
      LinearTransformationOntology_update,
      JordanTheory_extension,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      Eigenvector,
      Eigenvalue,
      Eigenspace,
      Vector,
      VectorSpace,
      LinearTransformation,
      Matrix,
      Kernel,
      Eigenbasis,
      GeneralisedEigenvector,
      InvariantSubspace
    ],

    edges: [
      Eigenvector -> IS_A -> Vector,
      Eigenvector -> HAS_EIGENVALUE -> Eigenvalue,
      Eigenvector -> BELONGS_TO -> Eigenspace,
      Eigenspace -> IS_A -> VectorSpace,
      Eigenspace -> EQUALS -> Kernel,
      LinearTransformation -> MAPS -> Eigenvector,
      Eigenvector -> SPANS -> Eigendirection,
      Eigenbasis -> CONTAINS -> Eigenvector,
      GeneralisedEigenvector -> RELATED_TO -> JordanChain,
      Eigenspace -> IS_A -> InvariantSubspace
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    EigenvalueOntology:
      paired_spectral_scalar,

    VectorSpaceOntology:
      ambient_vector_structure,

    LinearTransformationOntology:
      operator_action,

    MatrixOntology:
      finite_dimensional_representation,

    KernelOntology:
      eigenspace_computation,

    DiagonalisationOntology:
      eigenbasis_construction,

    DifferentialEquationOntology:
      modal_solutions,

    DynamicalSystemsOntology:
      eigendirection_growth_modes,

    StatisticsOntology:
      PCA_and_spectral_methods
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      eigenvector_defined,
      nonzero_requirement_defined,
      eigenvalue_relation_defined,
      eigenspace_relation_defined,
      scalar_multiple_semantics_defined,
      eigenbasis_and_diagonalisation_relations_defined,
      generalised_eigenvector_relation_defined,
      application_links_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Eigenvector_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyVectorAndOperator
    -> ResolveOrDetermineEigenvalue
    -> RejectZeroVector
    -> VerifyEigenRelation
    -> ComputeEigenspace
    -> FindEigenspaceBasis
    -> DetermineGeometricMultiplicity
    -> NormaliseRepresentativeWhenRequested
    -> AnalyseEigendirectionAndIndependence
    -> SupportEigenbasisOrJordanAnalysis
    -> LinkApplicationSemantics
    -> VerifySemanticConsistency
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    vector,
    eigenvalue,
    eigenspace,
    eigenspace_basis,
    geometric_multiplicity,
    eigendirection,
    normalised_representative,
    independence_relations,
    eigenbasis_status,
    generalised_eigenvector_relations,
    application_relations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Eigenvector_Ontology_v1.0