Abelian Group Ontology

FLOW Abelian_Group_Ontology_v1.0

PAGE:
  title: "Abelian Group Ontology"
  canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/abelian-group-ontology.html"
  language: "en-GB"
  domain: "Mathematics > Algebra > Abstract Algebra > Abelian Groups"

DEFINE AbelianGroupOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: AbelianGroup,
    parent_entities: [Group, AlgebraicStructure],
    related_entities: [
      Set,
      BinaryOperation,
      IdentityElement,
      InverseElement,
      Commutativity,
      Subgroup,
      CyclicGroup,
      DirectProduct,
      QuotientGroup,
      Homomorphism,
      Module,
      VectorSpace,
      FinitelyGeneratedAbelianGroup
    ]
  },

  DEFINITION: {
    meaning:
      "An abelian group is a group whose binary operation is commutative.",
    structure:
      (G,*),
    axioms: [
      closure,
      associativity,
      identity,
      inverses,
      commutativity
    ]
  },

  SEMANTIC_PRIMITIVES: {
    CarrierSet:
      G,
    Operation:
      *,
    Identity:
      e,
    Inverse:
      a^(-1),
    Commutativity:
      a*b=b*a
  },

  GROUP_AXIOMS: {
    closure:
      FOR_ALL a,b IN G:
        a*b IN G,

    associativity:
      FOR_ALL a,b,c IN G:
        (a*b)*c=a*(b*c),

    identity:
      EXISTS e IN G:
        e*a=a*e=a,

    inverses:
      FOR_ALL a IN G:
        EXISTS a^(-1) IN G:
          a*a^(-1)=a^(-1)*a=e
  },

  COMMUTATIVITY_AXIOM: {
    FOR_ALL a,b IN G:
      a*b=b*a
  },

  ADDITIVE_NOTATION: {
    common_for_abelian_groups:
      TRUE,

    operation:
      +,

    identity:
      0,

    inverse:
      -a,

    commutativity:
      a+b=b+a
  },

  MULTIPLICATIVE_NOTATION: {
    allowed:
      TRUE,

    identity:
      1_or_e,

    inverse:
      a^(-1)
  },

  DERIVED_RULES: {
    cancellation:
      a+b=a+c -> b=c,

    inverse_of_sum:
      -(a+b)=(-a)+(-b),

    repeated_operation:
      n*a
      for_integer_n,

    zero_multiple:
      0*a=0
  },

  CYCLIC_GROUP_RELATION: {
    every_cyclic_group:
      abelian=TRUE,

    converse:
      FALSE
  },

  SUBGROUPS: {
    rule:
      every_subgroup_of_abelian_group_is_normal,

    consequence:
      quotient_by_any_subgroup_is_defined
  },

  NORMALITY: {
    H_subgroup_G:
      H_normal_in_G
      automatically_if_G_is_abelian
  },

  QUOTIENT_GROUP: {
    G/H:
      abelian
      whenever_G_is_abelian_and_H_subgroup
  },

  HOMOMORPHISM: {
    phi:G->H,

    additive_notation:
      phi(a+b)=phi(a)+phi(b),

    kernel:
      subgroup_of_G,

    image:
      subgroup_of_H
  },

  ISOMORPHISM: {
    definition:
      bijective_group_homomorphism,

    consequence:
      preserves_abelian_group_structure
  },

  DIRECT_PRODUCT: {
    G×H:
      abelian_if_G_and_H_are_abelian,

    operation:
      componentwise
  },

  DIRECT_SUM: {
    finite_case:
      equivalent_to_direct_product,

    infinite_case:
      elements_have_finite_support
  },

  TORSION_ELEMENT: {
    definition:
      a_has_finite_order,

    additive_form:
      EXISTS n>0:
        n*a=0
  },

  TORSION_SUBGROUP: {
    Tor(G):
      set_of_all_finite_order_elements,

    abelian_group_property:
      Tor(G)_is_subgroup
  },

  TORSION_FREE: {
    condition:
      only_identity_has_finite_order
  },

  FINITELY_GENERATED_ABELIAN_GROUP: {
    definition:
      generated_by_finite_set,

    structure_theorem:
      G ≅ Z^r ⊕ Z/n1Z ⊕ ... ⊕ Z/nkZ,

    divisibility_condition:
      n1 | n2 | ... | nk
  },

  FREE_ABELIAN_GROUP: {
    rank_r:
      isomorphic_to_Z^r,

    basis:
      finite_or_infinite_independent_generating_set
  },

  RANK: {
    finitely_generated_abelian_group:
      number_of_Z_factors_in_free_part
  },

  PRIMARY_DECOMPOSITION: {
    finite_abelian_group:
      direct_sum_of_p_primary_components
  },

  FINITE_ABELIAN_GROUP_CLASSIFICATION: {
    determined_by:
      prime_power_decomposition,

    equivalent_forms: [
      invariant_factor_decomposition,
      elementary_divisor_decomposition
    ]
  },

  EXAMPLES: {
    IntegersUnderAddition:
      abelian=TRUE,

    RationalNumbersUnderAddition:
      abelian=TRUE,

    RealNumbersUnderAddition:
      abelian=TRUE,

    NonzeroRealNumbersUnderMultiplication:
      abelian=TRUE,

    Z_nUnderAddition:
      abelian=TRUE,

    VectorSpaceUnderAddition:
      abelian=TRUE
  },

  NONEXAMPLES: {
    SymmetricGroupS3:
      abelian=FALSE,

    QuaternionGroupQ8:
      abelian=FALSE,

    GeneralLinearGroupGLn:
      generally_abelian=FALSE_for_n>1
  },

  MODULE_RELATION: {
    abelian_group:
      equivalent_to_Z_module,

    significance:
      module_theory_generalises_abelian_group_theory
  },

  VECTOR_SPACE_RELATION: {
    additive_group_of_vector_space:
      abelian
  },

  RING_RELATION: {
    additive_structure_of_any_ring:
      abelian_group
  },

  FIELD_RELATION: {
    additive_group_of_field:
      abelian,

    nonzero_multiplicative_group_of_field:
      abelian
  },

  EXACT_SEQUENCE_RELATION: {
    short_exact_sequence:
      0 -> A -> B -> C -> 0,

    objects:
      abelian_groups,

    significance:
      category_of_abelian_groups_is_an_abelian_category
  },

  CATEGORY_RELATION: {
    category:
      Ab,

    objects:
      abelian_groups,

    morphisms:
      group_homomorphisms
  },

  TENSOR_PRODUCT_RELATION: {
    abelian_groups:
      admit_tensor_product_over_Z
  },

  HOM_FUNCTOR_RELATION: {
    Hom(A,B):
      abelian_group_under_pointwise_addition
  },

  ELEMENT_ORDER: {
    additive_notation:
      ord(a)=least_positive_n_with_n*a=0,

    infinite_order:
      if_no_positive_n_exists
  },

  SUBGROUP_TEST: {
    nonempty_H
    AND FOR_ALL a,b IN H:
      a-b IN H
    -> H_subgroup
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "Z under addition",
      "Z/8Z under addition",
      "R^n under vector addition",
      "nonzero rational numbers under multiplication"
    ],

    REJECT_AS_NONABELIAN: [
      "S3",
      "Q8",
      "GL(2,R)"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "abelian group":
      commutative_group,

    "commutative group":
      AbelianGroup,

    "additive group":
      often_abelian_in_ring_module_vector_space_context
  },

  ERROR_DETECTION: {
    CommutativityFailure:
      -> reject_abelian_classification,

    GroupAxiomFailure:
      -> reject_group_and_abelian_group,

    NormalityError:
      subgroup_of_abelian_group_claimed_non-normal
      -> flag,

    StructureTheoremMisuse:
      applied_to_non_finitely_generated_group_without_conditions
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "AbelianGroup IS_A Group",
      "CyclicGroup IS_A AbelianGroup",
      "AdditiveGroupOfRing IS_A AbelianGroup"
    ],

    RELATED_TO: [
      "AbelianGroup RELATED_TO Module",
      "AbelianGroup RELATED_TO VectorSpace",
      "AbelianGroup RELATED_TO DirectSum",
      "AbelianGroup RELATED_TO HomologicalAlgebra"
    ],

    DEPENDS_ON: [
      GroupAxioms,
      Commutativity
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    isomorphism:
      structural_equivalence,

    finitely_generated_classification:
      same_invariant_factors
      -> isomorphic
  },

  CONFIDENCE: {
    classification_confidence:
      IF group_axioms_verified
      AND commutativity_verified
      THEN 1.0,

    subgroup_confidence:
      IF subgroup_test_verified
      THEN 1.0,

    structure_theorem_confidence:
      IF finitely_generated_condition_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_abelian_group,
      verify_group_axioms,
      verify_commutativity,
      identify_additive_or_multiplicative_notation,
      analyse_subgroups,
      exploit_automatic_normality,
      construct_quotient_groups,
      analyse_homomorphisms,
      identify_torsion,
      identify_rank,
      classify_finitely_generated_abelian_groups,
      decompose_finite_abelian_groups,
      link_module_and_vector_space_relations
    ],

    preferred_representation:
      typed_commutative_group_with_subgroup_and_decomposition_graph,

    reasoning_mode:
      recursive_group_axiom_plus_commutativity_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseAbelianGroupCandidate(S,Operation,Context):

      group_result := GroupOntology.AnalyseGroupCandidate(S,Operation,Context)

      IF group_result is NotGroup:
        RETURN NotAbelianGroup("underlying structure is not a group")

      IF not VerifyCommutativity(group_result.carrier,group_result.operation):
        RETURN NonAbelianGroup

      properties := {
        order:group_result.order,
        generators:group_result.generators,
        all_subgroups_normal:TRUE,
        torsion:AnalyseTorsion(group_result),
        finitely_generated:IsFinitelyGenerated(group_result)
      }

      IF properties.finitely_generated:
        decomposition := ApplyFundamentalTheoremOfFinitelyGeneratedAbelianGroups(group_result)
      ELSE:
        decomposition := ContextDependent

      RETURN {
        entity:AbelianGroup,
        carrier:group_result.carrier,
        operation:group_result.operation,
        identity:group_result.identity,
        properties,
        decomposition,
        verified:TRUE
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      underlying_group_axioms_hold=TRUE,

    invariant_2:
      operation_commutative=TRUE,

    invariant_3:
      every_subgroup_normal=TRUE,

    invariant_4:
      quotient_by_subgroup_remains_abelian=TRUE,

    invariant_5:
      ring_module_vector_space_additive_relations_consistent=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      abelian_group_definition,
      group_axioms,
      commutativity_axiom,
      subgroup_normality,
      decomposition_theory,
      module_relations
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      group_axioms,
      commutativity,
      subgroup_normality_in_abelian_groups,
      quotient_abelian_property
    ],

    revision_triggers: [
      semantic_conflict,
      GroupOntology_update,
      ModuleOntology_update,
      finite_abelian_classification_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      AbelianGroup,
      Group,
      CarrierSet,
      BinaryOperation,
      IdentityElement,
      InverseElement,
      Subgroup,
      NormalSubgroup,
      QuotientGroup,
      TorsionSubgroup,
      DirectSum,
      Module
    ],

    edges: [
      AbelianGroup -> IS_A -> Group,
      AbelianGroup -> HAS_CARRIER -> CarrierSet,
      AbelianGroup -> HAS_OPERATION -> BinaryOperation,
      AbelianGroup -> HAS_IDENTITY -> IdentityElement,
      AbelianElement -> HAS_INVERSE -> InverseElement,
      Subgroup -> SUBSET_OF -> AbelianGroup,
      Subgroup -> IS_AUTOMATICALLY -> NormalSubgroup,
      QuotientGroup -> FORMED_FROM -> AbelianGroup,
      AbelianGroup -> MAY_HAVE -> TorsionSubgroup,
      AbelianGroup -> DECOMPOSES_AS -> DirectSum,
      AbelianGroup -> EQUIVALENT_TO -> ZModule
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    GroupOntology:
      direct_parent,

    RingOntology:
      additive_group_relation,

    FieldOntology:
      additive_and_multiplicative_group_relation,

    ModuleOntology:
      abelian_group_as_Z_module,

    VectorSpaceOntology:
      additive_group_relation,

    HomologicalAlgebraOntology:
      abelian_category_structure,

    NumberTheoryOntology:
      finite_abelian_groups_and_modular_structure
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      abelian_group_defined,
      group_axioms_defined,
      commutativity_defined,
      subgroup_normality_defined,
      quotient_semantics_defined,
      torsion_and_rank_defined,
      finitely_generated_structure_theorem_defined,
      module_relations_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Abelian_Group_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyCarrierSetAndOperation
    -> VerifyGroupAxioms
    -> VerifyCommutativity
    -> IdentifyNotationConvention
    -> DetermineOrderAndElementOrders
    -> AnalyseGeneratorsAndSubgroups
    -> ApplyAutomaticNormality
    -> ConstructQuotientsWhenRequested
    -> AnalyseTorsionAndRank
    -> ApplyFinitelyGeneratedClassificationWhenValid
    -> LinkModuleRingFieldAndVectorSpaceRelations
    -> VerifySemanticConsistency
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    carrier_set,
    operation,
    identity,
    inverses,
    commutativity,
    group_order,
    element_orders,
    generators,
    subgroups,
    quotient_groups,
    torsion_subgroup,
    rank,
    decomposition,
    homomorphisms,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Abelian_Group_Ontology_v1.0