Module Ontology

FLOW Module_Ontology_v1.0

PAGE:
  title: "Module Ontology"
  canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/module-ontology.html"
  language: "en-GB"
  domain: "Mathematics > Algebra > Abstract Algebra > Modules"

DEFINE ModuleOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: Module,
    parent_entities: [AlgebraicStructure, AbelianGroupWithScalarAction],
    related_entities: [
      Ring,
      AbelianGroup,
      VectorSpace,
      ScalarMultiplication,
      Submodule,
      QuotientModule,
      ModuleHomomorphism,
      FreeModule,
      FinitelyGeneratedModule,
      TorsionModule,
      DirectSum,
      TensorProduct
    ]
  },

  DEFINITION: {
    meaning:
      "A module is an abelian group equipped with scalar multiplication by elements of a ring, satisfying compatibility and distributive axioms.",
    structure:
      M_over_R,
    notation:
      _R M for_left_module
      OR
      M_R for_right_module
  },

  SEMANTIC_PRIMITIVES: {
    CarrierSet:
      M,
    ScalarRing:
      R,
    Addition:
      M×M -> M,
    ScalarMultiplication:
      R×M -> M for_left_module,
    ZeroVector:
      additive_identity_in_M,
    AdditiveInverse:
      -m
  },

  ADDITIVE_STRUCTURE: {
    requirement:
      (M,+)_is_abelian_group,

    axioms: [
      closure,
      associativity,
      additive_identity,
      additive_inverses,
      commutativity
    ]
  },

  LEFT_MODULE_AXIOMS: {
    scalar_additivity:
      r*(m+n)=r*m+r*n,

    ring_additivity:
      (r+s)*m=r*m+s*m,

    associativity_of_scalar_action:
      (r*s)*m=r*(s*m),

    identity_action:
      1_R*m=m
      for_unital_module_over_unital_ring
  },

  RIGHT_MODULE_AXIOMS: {
    additive_distributivity:
      (m+n)*r=m*r+n*r,

    scalar_distributivity:
      m*(r+s)=m*r+m*s,

    action_associativity:
      m*(r*s)=(m*r)*s
  },

  LEFT_RIGHT_DISTINCTION: {
    commutative_ring:
      left_and_right_modules_often_identified,

    noncommutative_ring:
      left_and_right_module_structures_distinct
  },

  VECTOR_SPACE_RELATION: {
    vector_space:
      module_over_a_field,

    consequence:
      every_vector_space_is_module,

    converse:
      FALSE
  },

  ABELIAN_GROUP_RELATION: {
    abelian_group:
      equivalent_to_module_over_Z,

    relation:
      every_abelian_group_is_a_Z_module
  },

  RING_AS_MODULE: {
    ring_R:
      left_module_over_itself,

    also:
      right_module_over_itself
  },

  SUBMODULE: {
    definition:
      N SUBSET_OR_EQUAL M
      AND N_is_module_under_inherited_operations,

    test:
      nonempty_N
      AND closed_under_subtraction
      AND closed_under_scalar_multiplication
  },

  QUOTIENT_MODULE: {
    construction:
      M/N,

    condition:
      N_submodule_of_M,

    elements:
      cosets_m+N,

    scalar_action:
      r*(m+N)=r*m+N
  },

  MODULE_HOMOMORPHISM: {
    phi:M->N,

    additive:
      phi(m1+m2)=phi(m1)+phi(m2),

    scalar_compatible:
      phi(r*m)=r*phi(m)
  },

  KERNEL: {
    ker(phi):
      {m IN M | phi(m)=0},

    property:
      submodule_of_M
  },

  IMAGE: {
    im(phi):
      {phi(m) | m IN M},

    property:
      submodule_of_N
  },

  FIRST_ISOMORPHISM_THEOREM: {
    relation:
      M/ker(phi) ≅ im(phi)
  },

  ISOMORPHISM: {
    definition:
      bijective_module_homomorphism,

    consequence:
      modules_have_same_structure_over_same_ring
  },

  FREE_MODULE: {
    definition:
      module_with_basis,

    basis:
      linearly_independent_generating_set_over_ring,

    finite_rank_case:
      M ≅ R^n
  },

  BASIS_CAUTION: {
    general_modules:
      need_not_have_basis,

    unlike_vector_spaces:
      modules_may_be_nonfree
  },

  LINEAR_COMBINATION: {
    form:
      r1*m1+...+rk*mk,

    coefficients:
      r_i IN R
  },

  SPAN: {
    generated_submodule:
      span_R(S)
      =
      set_of_finite_R_linear_combinations_of_S
  },

  GENERATING_SET: {
    S_generates_M:
      span_R(S)=M
  },

  LINEAR_INDEPENDENCE: {
    relation:
      sum(r_i*m_i)=0
      implies_all_r_i=0,

    caution:
      ring_zero_divisors_can_complicate_module_independence_behaviour
  },

  RANK: {
    free_module:
      cardinality_of_basis,

    note:
      rank_may_require_additional_conditions_on_ring_for_well_behaved_uniqueness
  },

  FINITELY_GENERATED_MODULE: {
    condition:
      finite_generating_set_exists
  },

  CYCLIC_MODULE: {
    condition:
      generated_by_single_element,

    form:
      M=R*m
  },

  TORSION_ELEMENT: {
    over_integral_domain_R:

    m_is_torsion_if:
      EXISTS nonzero_r IN R:
        r*m=0
  },

  TORSION_MODULE: {
    every_element:
      torsion
  },

  TORSION_FREE_MODULE: {
    nonzero_scalar_times_nonzero_element_never_zero
      over_integral_domain_context
  },

  ANNIHILATOR_OF_ELEMENT: {
    Ann(m):
      {r IN R | r*m=0},

    property:
      ideal_of_R
  },

  ANNIHILATOR_OF_MODULE: {
    Ann(M):
      {r IN R | r*m=0 FOR_ALL m IN M}
  },

  SIMPLE_MODULE: {
    only_submodules:
      {0}
      AND
      M
  },

  SEMISIMPLE_MODULE: {
    decomposes_as:
      direct_sum_of_simple_submodules
  },

  DIRECT_SUM: {
    M=N1⊕N2:

    requirements: [
      M=N1+N2,
      N1∩N2={0}
    ]
  },

  INTERNAL_DIRECT_SUM: {
    M:
      sum_of_submodules_with_unique_component_decomposition
  },

  EXTERNAL_DIRECT_SUM: {
    family_of_modules:
      tuples_with_finite_support
  },

  DIRECT_PRODUCT: {
    family_of_modules:
      unrestricted_product_of_component_modules
  },

  EXACT_SEQUENCE: {
    sequence:
      M1 -> M2 -> M3,

    exact_at_M2:
      image(previous_map)=kernel(next_map)
  },

  SHORT_EXACT_SEQUENCE: {
    form:
      0 -> A -> B -> C -> 0,

    interpretation:
      A_embeds_as_submodule_of_B
      AND C_is_corresponding_quotient
  },

  SPLIT_EXACT_SEQUENCE: {
    consequence:
      B ≅ A⊕C
      under_splitting_conditions
  },

  PROJECTIVE_MODULE: {
    lifting_property:
      homomorphisms_lift_across_surjections,

    free_modules:
      projective=TRUE
  },

  INJECTIVE_MODULE: {
    extension_property:
      homomorphisms_extend_across_embeddings
  },

  FLAT_MODULE: {
    tensoring_preserves_exact_sequences_of_appropriate_type,

    free_modules:
      flat=TRUE
  },

  TENSOR_PRODUCT: {
    M⊗_R N:

    purpose:
      universal_bilinear_construction,

    relation:
      combines_module_structures
  },

  HOM_MODULE: {
    Hom_R(M,N):

    if_R_commutative_and_N_module:
      often_has_R_module_structure
  },

  DUAL_MODULE: {
    M^*:
      Hom_R(M,R)
  },

  MODULE_OVER_PID: {
    finitely_generated_module_structure_theorem:
      M ≅ R^r ⊕ torsion_component
      under_PID_conditions
  },

  FINITELY_GENERATED_MODULE_OVER_PID: {
    decomposition:
      free_part
      PLUS
      cyclic_torsion_factors,

    analogous_to:
      finitely_generated_abelian_group_structure_theorem
  },

  MODULE_OVER_FIELD: {
    specialisation:
      VectorSpace,

    stronger_properties: [
      every_submodule_has_complement_under_finite_dimensional_or_choice_context,
      every_module_free
    ]
  },

  REPRESENTATION_RELATION: {
    group_representation:
      module_over_group_ring
  },

  GROUP_RING_RELATION: {
    R[G]:
      ring_built_from_group_and_coefficient_ring,

    modules_over_R[G]:
      correspond_to_linear_representations_of_G_over_R
  },

  MATRIX_REPRESENTATION: {
    homomorphism_between_free_finite_rank_modules:
      represented_by_matrix
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "Z^n as a Z-module",
      "R^n as an R-module",
      "abelian group A as a Z-module",
      "R[x] as an R-module"
    ],

    REDIRECT_VECTOR_SPACE: [
      "module over field F"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "module over R":
      abelian_group_with_R_scalar_action,

    "submodule":
      subset_closed_under_module_operations,

    "free module":
      module_with_basis,

    "finitely generated":
      generated_by_finite_set
  },

  ERROR_DETECTION: {
    AdditiveGroupFailure:
      -> reject_module,

    ScalarClosureFailure:
      -> reject_module,

    DistributivityFailure:
      -> reject_module,

    ActionAssociativityFailure:
      -> reject_module,

    BasisAssumptionError:
      arbitrary_module_assumed_free
      -> flag,

    LeftRightConfusion:
      noncommutative_ring_module_side_ignored
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "FreeModule IS_A Module",
      "FinitelyGeneratedModule IS_A Module",
      "VectorSpace IS_A Module"
    ],

    RELATED_TO: [
      "Module RELATED_TO Ring",
      "Module RELATED_TO AbelianGroup",
      "Module RELATED_TO VectorSpace",
      "Module RELATED_TO TensorProduct",
      "Module RELATED_TO HomologicalAlgebra"
    ],

    DEPENDS_ON: [
      AbelianGroup,
      Ring,
      ScalarAction
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    module_isomorphism:
      structural_equivalence_over_same_scalar_ring,

    matrix_change_of_basis:
      represents_same_homomorphism_under_different_bases
  },

  CONFIDENCE: {
    classification_confidence:
      IF additive_abelian_group
      AND scalar_action_axioms_verified
      THEN 1.0,

    free_module_confidence:
      IF basis_verified
      THEN 1.0,

    submodule_confidence:
      IF subtraction_and_scalar_closure_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_module_candidate,
      identify_scalar_ring,
      distinguish_left_and_right_module,
      verify_additive_abelian_group,
      verify_scalar_action_axioms,
      identify_submodules,
      construct_quotient_modules,
      analyse_module_homomorphisms,
      compute_kernel_and_image,
      detect_free_module_structure,
      analyse_generators_and_relations,
      detect_torsion,
      construct_direct_sums,
      reason_about_exact_sequences,
      connect_to_vector_spaces_and_abelian_groups
    ],

    preferred_representation:
      typed_abelian_group_with_ring_action_graph,

    reasoning_mode:
      recursive_additive_structure_and_scalar_action_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseModuleCandidate(M,R,Action,Context):

      ring_result := RingOntology.AnalyseRingCandidate(R,Context)

      IF ring_result is NotRing:
        RETURN NotModule("scalar structure is not a ring")

      additive_result :=
        AbelianGroupOntology.AnalyseAbelianGroupCandidate(
          M,
          Addition,
          Context
        )

      IF additive_result is NotAbelianGroup:
        RETURN NotModule("module addition is not an abelian group")

      IF not VerifyScalarActionClosure(R,M,Action):
        RETURN NotModule("scalar action not closed")

      IF not VerifyDistributiveAxioms(R,M,Action):
        RETURN NotModule("distributivity failure")

      IF not VerifyActionAssociativity(R,M,Action):
        RETURN NotModule("scalar associativity failure")

      side := DetectLeftRightOrBimoduleStructure(R,M,Action)

      properties := {
        scalar_ring:R,
        side:side,
        finitely_generated:DetectFiniteGeneration(M,R),
        free:DetectFreeModule(M,R),
        torsion:AnalyseTorsionWhenMeaningful(M,R)
      }

      RETURN {
        entity:Module,
        carrier:M,
        scalar_ring:R,
        action:Action,
        properties,
        verified:TRUE
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      additive_structure_is_abelian_group=TRUE,

    invariant_2:
      scalar_action_distributes_over_module_addition=TRUE,

    invariant_3:
      scalar_addition_distributes_over_action=TRUE,

    invariant_4:
      scalar_multiplication_action_associative=TRUE,

    invariant_5:
      quotient_requires_submodule=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      module_definition,
      additive_group_axioms,
      scalar_action_axioms,
      submodule_semantics,
      quotient_module_semantics,
      homomorphism_relations,
      free_torsion_structure
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      additive_abelian_group,
      scalar_action_closure,
      distributivity,
      scalar_action_associativity,
      quotient_requires_submodule
    ],

    revision_triggers: [
      semantic_conflict,
      RingOntology_update,
      AbelianGroupOntology_update,
      VectorSpaceOntology_update,
      homological_structure_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      Module,
      Ring,
      AbelianGroup,
      ScalarAction,
      Submodule,
      QuotientModule,
      ModuleHomomorphism,
      FreeModule,
      TorsionModule,
      DirectSum,
      TensorProduct
    ],

    edges: [
      Module -> HAS_SCALAR_RING -> Ring,
      Module -> HAS_ADDITIVE_STRUCTURE -> AbelianGroup,
      Module -> HAS_ACTION -> ScalarAction,
      Submodule -> SUBSET_OF -> Module,
      QuotientModule -> FORMED_FROM -> Module,
      ModuleHomomorphism -> MAPS -> Module,
      FreeModule -> IS_A -> Module,
      TorsionModule -> IS_A -> Module,
      Module -> MAY_DECOMPOSE_AS -> DirectSum,
      Module -> RELATED_TO -> TensorProduct
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    RingOntology:
      scalar_structure,

    AbelianGroupOntology:
      additive_structure,

    VectorSpaceOntology:
      module_over_field_specialisation,

    GroupOntology:
      additive_group_foundation,

    TensorProductOntology:
      bilinear_construction,

    HomologicalAlgebraOntology:
      exact_sequences_projective_injective_modules,

    RepresentationTheoryOntology:
      modules_over_group_rings,

    LinearAlgebraOntology:
      free_modules_and_matrix_maps
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      module_defined,
      additive_structure_defined,
      scalar_action_defined,
      left_right_distinction_defined,
      submodule_semantics_defined,
      quotient_module_defined,
      homomorphism_semantics_defined,
      free_and_finitely_generated_modules_defined,
      torsion_defined,
      direct_sum_and_tensor_relations_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Module_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyCarrierSet
    -> IdentifyScalarRing
    -> IdentifyScalarAction
    -> VerifyUnderlyingAbelianGroup
    -> VerifyScalarClosure
    -> VerifyDistributiveAxioms
    -> VerifyActionAssociativity
    -> DetectLeftRightOrBimoduleStructure
    -> AnalyseSubmodulesAndQuotients
    -> AnalyseHomomorphisms
    -> DetectFreeFiniteGenerationAndTorsion
    -> AnalyseDirectSumTensorAndExactSequenceRelations
    -> VerifySemanticConsistency
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    carrier_set,
    scalar_ring,
    module_side,
    addition_operation,
    scalar_action,
    zero_element,
    submodules,
    quotient_modules,
    homomorphisms,
    kernels,
    images,
    generators,
    basis,
    rank,
    torsion,
    direct_sum_structure,
    tensor_relations,
    exact_sequences,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Module_Ontology_v1.0