Group Ontology

FLOW Group_Ontology_v1.0

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

DEFINE GroupOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: Group,
    parent_entities: [AlgebraicStructure, SetWithOperation],
    related_entities: [
      Set,
      BinaryOperation,
      IdentityElement,
      InverseElement,
      Associativity,
      AbelianGroup,
      Subgroup,
      CyclicGroup,
      PermutationGroup,
      SymmetryGroup,
      GroupHomomorphism,
      NormalSubgroup,
      QuotientGroup,
      Coset,
      Generator
    ]
  },

  DEFINITION: {
    meaning:
      "A group is a set equipped with a binary operation satisfying closure, associativity, identity, and inverse axioms.",
    structure:
      (G,*),
    axioms: [
      closure,
      associativity,
      identity,
      inverses
    ]
  },

  SEMANTIC_PRIMITIVES: {
    CarrierSet:
      G,
    BinaryOperation:
      *,
    IdentityElement:
      e,
    InverseElement:
      a^(-1),
    Product:
      a*b,
    GroupOrder:
      cardinality_of_G
  },

  CLOSURE_AXIOM: {
    FOR_ALL a,b IN G:
      a*b IN G
  },

  ASSOCIATIVITY_AXIOM: {
    FOR_ALL a,b,c IN G:
      (a*b)*c=a*(b*c)
  },

  IDENTITY_AXIOM: {
    EXISTS e IN G
    SUCH_THAT FOR_ALL a IN G:
      e*a=a
      AND
      a*e=a
  },

  INVERSE_AXIOM: {
    FOR_ALL a IN G:
      EXISTS a^(-1) IN G
      SUCH_THAT:
        a*a^(-1)=e
        AND
        a^(-1)*a=e
  },

  IDENTITY_UNIQUENESS: {
    rule:
      group_identity_is_unique
  },

  INVERSE_UNIQUENESS: {
    rule:
      each_group_element_has_unique_inverse
  },

  DERIVED_RULES: {
    left_cancellation:
      a*b=a*c -> b=c,

    right_cancellation:
      b*a=c*a -> b=c,

    inverse_of_inverse:
      (a^(-1))^(-1)=a,

    inverse_of_product:
      (a*b)^(-1)=b^(-1)*a^(-1),

    identity_inverse:
      e^(-1)=e
  },

  CLASSIFICATION: {

    AbelianGroup: {
      condition:
        a*b=b*a
        FOR_ALL a,b IN G
    },

    NonAbelianGroup: {
      condition:
        multiplication_not_commutative_in_general
    },

    FiniteGroup: {
      |G| finite
    },

    InfiniteGroup: {
      |G| infinite
    },

    CyclicGroup: {
      EXISTS g IN G:
        every_element_is_power_or_multiple_of_g
    },

    TrivialGroup: {
      G={e}
    }
  },

  ORDER_OF_GROUP: {
    notation:
      |G|,
    meaning:
      number_of_elements_when_finite
  },

  ORDER_OF_ELEMENT: {
    ord(a):
      least_positive_n
      SUCH_THAT a^n=e,

    IF no_positive_n_exists:
      infinite_order
  },

  CYCLIC_GROUP: {
    notation:
      <g>,

    generated_set:
      {g^n | n IN Integers},

    abelian:
      TRUE
  },

  GENERATOR: {
    element_g:
      generates_G
      IF <g>=G
  },

  SUBGROUP: {
    definition:
      H SUBSET_OR_EQUAL G
      AND H_is_group_under_inherited_operation,

    subgroup_test:
      H_nonempty
      AND FOR_ALL a,b IN H:
        a*b^(-1) IN H
  },

  TRIVIAL_SUBGROUPS: {
    identity_subgroup:
      {e},

    whole_group:
      G
  },

  COSETS: {
    left_coset:
      gH={g*h | h IN H},

    right_coset:
      Hg={h*g | h IN H}
  },

  COSET_PROPERTIES: {
    size:
      every_coset_has_same_cardinality_as_H,

    partition:
      left_cosets_partition_G,

    equality_condition:
      g1H=g2H
      IFF g2^(-1)*g1 IN H
  },

  LAGRANGE_THEOREM: {
    finite_group:
      |H| divides |G|
      for_every_subgroup_H,

    consequence:
      ord(g) divides |G|
  },

  INDEX_OF_SUBGROUP: {
    notation:
      [G:H],

    definition:
      number_of_left_cosets_of_H_in_G,

    finite_relation:
      |G|=[G:H]*|H|
  },

  NORMAL_SUBGROUP: {
    notation:
      N normal_in G,

    equivalent_conditions: [
      gN=Ng_for_all_g,
      gNg^(-1)=N_for_all_g
    ]
  },

  QUOTIENT_GROUP: {
    notation:
      G/N,

    condition:
      N_normal_in_G,

    elements:
      cosets_gN,

    operation:
      (gN)(hN)=(gh)N
  },

  GROUP_HOMOMORPHISM: {
    phi:G->H,

    law:
      phi(a*b)=phi(a)*phi(b)
  },

  HOMOMORPHISM_PROPERTIES: {
    identity_preservation:
      phi(e_G)=e_H,

    inverse_preservation:
      phi(a^(-1))=phi(a)^(-1)
  },

  KERNEL: {
    ker(phi):
      {g IN G | phi(g)=e_H},

    property:
      normal_subgroup_of_G
  },

  IMAGE: {
    im(phi):
      {phi(g) | g IN G},

    property:
      subgroup_of_H
  },

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

  GROUP_ISOMORPHISM: {
    definition:
      bijective_group_homomorphism,

    consequence:
      groups_have_same_abstract_structure
  },

  AUTOMORPHISM: {
    definition:
      isomorphism_G_to_G,

    automorphism_group:
      Aut(G)
  },

  DIRECT_PRODUCT: {
    G×H:
      componentwise_operation,

    identity:
      (e_G,e_H),

    inverse:
      (g,h)^(-1)=(g^(-1),h^(-1))
  },

  SEMIDIRECT_PRODUCT_RELATION: {
    structure:
      combines_normal_subgroup_and_acting_subgroup,

    note:
      operation_depends_on_homomorphism_into_automorphism_group
  },

  PERMUTATION_GROUP: {
    carrier:
      permutations_of_set,

    operation:
      composition,

    canonical_example:
      symmetric_group_S_n
  },

  SYMMETRIC_GROUP: {
    S_n:
      all_permutations_of_n_elements,

    order:
      n!
  },

  ALTERNATING_GROUP: {
    A_n:
      even_permutations,

    order:
      n!/2
      for_n>=2,

    relation:
      normal_subgroup_of_S_n
  },

  CAYLEY_THEOREM: {
    rule:
      every_group_is_isomorphic_to_a_subgroup_of_a_symmetric_group
  },

  GROUP_ACTION: {
    action:
      G×X -> X,

    axioms: [
      e·x=x,
      (g*h)·x=g·(h·x)
    ]
  },

  ORBIT: {
    Orb(x):
      {g·x | g IN G}
  },

  STABILISER: {
    Stab(x):
      {g IN G | g·x=x}
  },

  ORBIT_STABILISER_THEOREM: {
    finite_group:
      |G|=|Orb(x)|*|Stab(x)|
  },

  SYMMETRY_GROUP: {
    meaning:
      group_of_structure_preserving_transformations,

    examples: [
      rotational_symmetry,
      reflection_symmetry,
      permutation_symmetry
    ]
  },

  DIHEDRAL_GROUP: {
    D_n:
      symmetries_of_regular_n_gon,

    order:
      commonly_2n,

    generators: [
      rotation_r,
      reflection_s
    ],

    relations: [
      r^n=e,
      s^2=e,
      s*r*s=r^(-1)
    ]
  },

  MATRIX_GROUP: {
    elements:
      invertible_matrices_under_multiplication,

    example:
      GL(n,F)
  },

  GENERAL_LINEAR_GROUP: {
    GL(n,F):
      invertible_n_by_n_matrices_over_field_F
  },

  SPECIAL_LINEAR_GROUP: {
    SL(n,F):
      matrices_with_determinant_1
  },

  ORTHOGONAL_GROUP: {
    O(n):
      real_matrices_Q_with_Q^T*Q=I
  },

  SPECIAL_ORTHOGONAL_GROUP: {
    SO(n):
      orthogonal_matrices_with_determinant_1
  },

  UNITARY_GROUP: {
    U(n):
      complex_matrices_U_with_U^*U=I
  },

  LIE_GROUP_RELATION: {
    group:
      also_smooth_manifold,

    operations:
      smooth
  },

  QUATERNION_GROUP_RELATION: {
    quaternion_group_Q8:
      finite_nonabelian_group,

    elements:
      {±1,±i,±j,±k}
  },

  GROUP_PRESENTATION: {
    notation:
      < generators | relations >,

    purpose:
      specify_group_abstractly
  },

  FREE_GROUP: {
    generators:
      chosen_set,

    property:
      no_relations_other_than_group_axioms
  },

  ABELIANISATION: {
    construction:
      G/[G,G],

    result:
      largest_abelian_quotient_of_G
  },

  COMMUTATOR: {
    [a,b]:
      a*b*a^(-1)*b^(-1),

    abelian_condition:
      [a,b]=e_for_all_a_b
  },

  COMMUTATOR_SUBGROUP: {
    [G,G]:
      subgroup_generated_by_all_commutators,

    property:
      normal_in_G
  },

  CENTER: {
    Z(G):
      {z IN G | z*g=g*z FOR_ALL g IN G},

    property:
      abelian_normal_subgroup
  },

  CONJUGATION: {
    action:
      g*x*g^(-1),

    conjugacy_class:
      orbit_under_conjugation
  },

  CLASS_EQUATION_RELATION: {
    finite_group:
      |G|=|Z(G)|+sum_of_sizes_of_noncentral_conjugacy_classes
  },

  P_GROUP_RELATION: {
    finite_group:
      |G|=p^n
      for_prime_p
  },

  SYLOW_THEOREMS_RELATION: {
    concerns:
      subgroups_of_prime_power_order_in_finite_groups
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "Z under addition",
      "Z/nZ under addition",
      "S_3 under composition",
      "GL(2,R)",
      "nonzero real numbers under multiplication"
    ],

    REJECT_AS_GROUP: [
      "Natural numbers under addition",
      "integers under multiplication"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "group":
      set_with_associative_operation_identity_and_inverses,

    "abelian group":
      group_with_commutative_operation,

    "subgroup":
      subset_closed_under_group_structure,

    "generator":
      element_or_set_generating_group,

    "normal subgroup":
      subgroup_invariant_under_conjugation
  },

  ERROR_DETECTION: {
    ClosureFailure:
      -> reject_group,

    AssociativityFailure:
      -> reject_group,

    MissingIdentity:
      -> reject_group,

    MissingInverse:
      -> reject_group,

    CommutativityAssumption:
      nonabelian_group_treated_as_abelian
      -> flag,

    QuotientWithoutNormality:
      G/H_called_group_without_H_normal
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "AbelianGroup IS_A Group",
      "CyclicGroup IS_A AbelianGroup",
      "PermutationGroup IS_A Group",
      "LieGroup IS_A Group"
    ],

    RELATED_TO: [
      "Group RELATED_TO Symmetry",
      "Group RELATED_TO Ring",
      "Group RELATED_TO Field",
      "Group RELATED_TO Module",
      "Group RELATED_TO Geometry",
      "Group RELATED_TO NumberTheory"
    ],

    DEPENDS_ON: [
      Set,
      BinaryOperation,
      Associativity,
      Identity,
      Inverse
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    group_isomorphism:
      structural_equivalence,

    examples:
      cyclic_groups_of_same_finite_order_are_isomorphic
  },

  CONFIDENCE: {
    classification_confidence:
      IF closure_associativity_identity_inverse_verified
      THEN 1.0,

    abelian_confidence:
      IF commutativity_verified
      THEN 1.0,

    subgroup_confidence:
      IF subgroup_test_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_group_candidate,
      verify_closure,
      verify_associativity,
      identify_identity,
      identify_inverses,
      classify_abelian_or_nonabelian,
      determine_group_order,
      determine_element_orders,
      identify_generators,
      test_subgroups,
      compute_cosets,
      test_normality,
      construct_quotient_groups,
      analyse_homomorphisms,
      compute_kernel_and_image,
      analyse_group_actions,
      detect_group_axiom_failures,
      link_related_ontologies
    ],

    preferred_representation:
      typed_algebraic_structure_with_operation_axiom_and_subgroup_graph,

    reasoning_mode:
      recursive_axiom_subgroup_and_symmetry_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseGroupCandidate(S,Operation,Context):

      carrier := ParseSet(S)
      op := ParseOperation(Operation)

      IF not VerifyClosure(carrier,op):
        RETURN NotGroup("closure failure")

      IF not VerifyAssociativity(carrier,op):
        RETURN NotGroup("associativity failure")

      identity := FindIdentity(carrier,op)

      IF identity=NONE:
        RETURN NotGroup("identity missing")

      IF not EveryElementHasInverse(carrier,op,identity):
        RETURN NotGroup("inverse axiom failure")

      abelian := VerifyCommutativity(carrier,op)
      order := CardinalityIfFinite(carrier)
      generators := FindGeneratorsWhenFeasible(carrier,op)

      classifications := [Group]

      IF abelian:
        classifications += AbelianGroup
      ELSE:
        classifications += NonAbelianGroup

      IF order is finite:
        classifications += FiniteGroup
      ELSE:
        classifications += InfiniteGroup

      IF ExistsSingleGenerator(generators):
        classifications += CyclicGroup

      RETURN {
        entity:Group,
        carrier,
        operation:op,
        identity,
        order,
        generators,
        classifications,
        verified:TRUE
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      closure_holds=TRUE,

    invariant_2:
      associativity_holds=TRUE,

    invariant_3:
      identity_unique=TRUE,

    invariant_4:
      inverse_unique_for_each_element=TRUE,

    invariant_5:
      quotient_group_requires_normal_subgroup=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      group_definition,
      closure_axiom,
      associativity_axiom,
      identity_axiom,
      inverse_axiom,
      subgroup_and_homomorphism_relations
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      closure,
      associativity,
      identity,
      inverses,
      quotient_requires_normal_subgroup
    ],

    revision_triggers: [
      semantic_conflict,
      AlgebraicStructureOntology_update,
      RingOntology_update,
      GroupActionOntology_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      Group,
      AlgebraicStructure,
      CarrierSet,
      BinaryOperation,
      IdentityElement,
      InverseElement,
      AbelianGroup,
      Subgroup,
      NormalSubgroup,
      QuotientGroup,
      GroupHomomorphism,
      Coset,
      Generator
    ],

    edges: [
      Group -> IS_A -> AlgebraicStructure,
      Group -> HAS_CARRIER -> CarrierSet,
      Group -> HAS_OPERATION -> BinaryOperation,
      Group -> HAS_IDENTITY -> IdentityElement,
      GroupElement -> HAS_INVERSE -> InverseElement,
      AbelianGroup -> IS_A -> Group,
      Subgroup -> SUBSET_OF -> Group,
      NormalSubgroup -> IS_A -> Subgroup,
      QuotientGroup -> FORMED_FROM -> Group,
      GroupHomomorphism -> MAPS -> Group,
      Group -> MAY_HAVE -> Generator,
      Group -> PARTITIONED_BY -> Coset
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    AlgebraicStructureOntology:
      direct_parent,

    RingOntology:
      additive_group_foundation,

    FieldOntology:
      additive_and_nonzero_multiplicative_groups,

    ModuleOntology:
      additive_abelian_group_structure,

    SymmetryOntology:
      transformation_groups,

    PermutationOntology:
      symmetric_and_permutation_groups,

    LinearAlgebraOntology:
      matrix_groups,

    GeometryOntology:
      isometry_and_rotation_groups,

    NumberTheoryOntology:
      finite_and_modular_groups
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      group_defined,
      carrier_and_operation_defined,
      closure_defined,
      associativity_defined,
      identity_defined,
      inverse_defined,
      major_group_classes_defined,
      subgroup_and_coset_semantics_defined,
      normal_and_quotient_group_semantics_defined,
      homomorphism_semantics_defined,
      group_action_semantics_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Group_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyCarrierSetAndOperation
    -> VerifyClosure
    -> VerifyAssociativity
    -> FindIdentity
    -> VerifyInverses
    -> DetectCommutativity
    -> DetermineGroupOrder
    -> IdentifyGenerators
    -> AnalyseSubgroupsAndCosets
    -> TestNormalityAndConstructQuotients
    -> AnalyseHomomorphismsAndActions
    -> VerifySemanticConsistency
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    carrier_set,
    operation,
    identity,
    inverses,
    commutativity,
    group_order,
    element_orders,
    generators,
    subgroups,
    normal_subgroups,
    cosets,
    quotient_groups,
    homomorphisms,
    kernels,
    images,
    actions,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Group_Ontology_v1.0