Cyclic Group Ontology

FLOW Cyclic_Group_Ontology_v1.0

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

DEFINE CyclicGroupOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: CyclicGroup,
    parent_entities: [AbelianGroup, Group, AlgebraicStructure],
    related_entities: [
      Generator,
      ElementOrder,
      GroupOrder,
      Subgroup,
      QuotientGroup,
      Homomorphism,
      Isomorphism,
      Integers,
      IntegersModuloN,
      DirectProduct,
      FiniteGroup
    ]
  },

  DEFINITION: {
    meaning:
      "A cyclic group is a group generated by a single element, so every group element is an integer power or integer multiple of one generator.",
    multiplicative_form:
      G=<g>={g^n | n in Integers},
    additive_form:
      G=<g>={n*g | n in Integers}
  },

  SEMANTIC_PRIMITIVES: {
    Generator:
      element_whose_integer_iterates_produce_entire_group,
    GeneratedSubgroup:
      <g>,
    ElementOrder:
      least_positive_n_with_g^n=e_if_finite,
    GroupOrder:
      cardinality_of_G
  },

  CYCLICITY_CONDITION: {
    EXISTS g IN G:
      <g>=G
  },

  ABELIAN_PROPERTY: {
    every_cyclic_group:
      abelian=TRUE,

    proof_semantics:
      g^m*g^n=g^(m+n)=g^(n+m)=g^n*g^m
  },

  FINITE_CYCLIC_GROUP: {
    notation:
      C_n_or_Z_n,

    order:
      n,

    canonical_model:
      IntegersModuloN_under_addition
  },

  INFINITE_CYCLIC_GROUP: {
    canonical_model:
      Integers_under_addition,

    isomorphism:
      every_infinite_cyclic_group_is_isomorphic_to_Z
  },

  CLASSIFICATION_THEOREM: {
    finite_case:
      every_finite_cyclic_group_of_order_n_is_isomorphic_to_Z/nZ,

    infinite_case:
      every_infinite_cyclic_group_is_isomorphic_to_Z
  },

  GENERATORS_FINITE_CASE: {
    group:
      <g> of order_n,

    element:
      g^k,

    generator_condition:
      gcd(k,n)=1
  },

  NUMBER_OF_GENERATORS: {
    finite_cyclic_group_order_n:
      phi(n),

    phi:
      EulerTotientFunction
  },

  ELEMENT_ORDER_FINITE_CASE: {
    G=<g>,
    |G|=n,

    element:
      g^k,

    formula:
      ord(g^k)=n/gcd(n,k)
  },

  ADDITIVE_ELEMENT_ORDER: {
    in_Z_n:
      ord([k])=n/gcd(n,k)
  },

  SUBGROUP_STRUCTURE: {
    theorem:
      every_subgroup_of_cyclic_group_is_cyclic,

    finite_case:
      for_each_divisor_d_of_n
      exists_unique_subgroup_of_order_d
  },

  SUBGROUP_GENERATOR: {
    G=<g> order_n,

    subgroup_of_order_d:
      <g^(n/d)>
      WHERE d divides n
  },

  SUBGROUP_LATTICE_RELATION: {
    finite_cyclic_group:
      subgroup_structure_corresponds_to_divisors_of_group_order
  },

  NORMALITY: {
    every_subgroup_of_cyclic_group:
      normal=TRUE,

    reason:
      cyclic_group_is_abelian
  },

  QUOTIENT_GROUP: {
    G_cyclic:
      G/H_is_cyclic_for_every_subgroup_H,

    generator:
      gH
      IF G=<g>
  },

  HOMOMORPHISM_IMAGE: {
    image_of_cyclic_group_under_homomorphism:
      cyclic,

    generator:
      phi(g)
      IF G=<g>
  },

  HOMOMORPHISM_DETERMINATION: {
    homomorphism_from_cyclic_group:
      completely_determined_by_image_of_generator,

    compatibility:
      image_of_generator_must_satisfy_required_order_relation
  },

  ENDOMORPHISM_FINITE: {
    G=Z_n,

    every_endomorphism:
      phi_k([x])=[k*x],

    parameter:
      k_mod_n
  },

  AUTOMORPHISM_GROUP: {
    Aut(Z_n):
      isomorphic_to_units_mod_n,

    notation:
      (Z/nZ)^*
  },

  DIRECT_PRODUCT_CYCLICITY: {
    C_m × C_n:
      cyclic IFF gcd(m,n)=1,

    then:
      C_m × C_n ≅ C_(m*n)
  },

  CHINESE_REMAINDER_RELATION: {
    IF gcd(m,n)=1:
      Z/(mn)Z ≅ Z/mZ × Z/nZ
  },

  PRIME_ORDER_GROUP: {
    theorem:
      every_group_of_prime_order_is_cyclic,

    consequence:
      every_nonidentity_element_is_generator
  },

  CYCLIC_P_GROUP: {
    C_(p^n):
      canonical_finite_cyclic_p_group
  },

  PRESENTATION: {
    finite:
      <g | g^n=e>,

    infinite:
      <g | >
  },

  POWER_REDUCTION_FINITE: {
    group_order:
      n,

    rule:
      g^k=g^(k mod n)
  },

  MODULAR_ARITHMETIC_RELATION: {
    exponent_arithmetic:
      powers_of_generator_correspond_to_addition_mod_n
  },

  DISCRETE_LOG_RELATION: {
    in_finite_cyclic_group:
      given_generator_g_and_element_h,
      find_k_with_g^k=h,

    problem:
      discrete_logarithm_problem
  },

  CRYPTOGRAPHY_RELATION: {
    finite_cyclic_groups:
      foundational_for_multiple_public_key_protocols,

    caution:
      security_depends_on_specific_group_and_problem_hardness
  },

  ROOT_OF_UNITY_RELATION: {
    complex_nth_roots_of_unity:
      form_cyclic_group_under_multiplication,

    generator:
      primitive_nth_root_of_unity
  },

  ROTATION_GROUP_RELATION: {
    rotations_of_regular_n_gon:
      cyclic_subgroup_C_n
  },

  ADDITIVE_NOTATION: {
    common_models: [
      Integers,
      IntegersModuloN
    ],

    generator:
      1_or_equivalent_element
  },

  MULTIPLICATIVE_NOTATION: {
    common_models: [
      roots_of_unity,
      multiplicative_subgroups_of_fields
    ]
  },

  FINITE_FIELD_RELATION: {
    multiplicative_group_of_finite_field_F_q:
      cyclic_of_order_q-1
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "<g>",
      "Z under addition",
      "Z/12Z under addition",
      "nth roots of unity under multiplication"
    ],

    NONCYCLIC_EXAMPLES: [
      "Z/2Z × Z/2Z",
      "S3",
      "Q8"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "generated by one element":
      cyclic_group,

    "single generator":
      cyclicity,

    "order of g":
      least_positive_n_with_g^n=e,

    "primitive element":
      context_may_mean_generator
  },

  ERROR_DETECTION: {
    NonGeneratorError:
      claimed_generator_does_not_generate_entire_group
      -> flag,

    GeneratorCountError:
      incorrect_phi(n)_count
      -> flag,

    ElementOrderError:
      ord(g^k)_formula_misapplied
      -> flag,

    SubgroupUniquenessError:
      finite_cyclic_group_claimed_to_have_multiple_subgroups_of_same_order
      -> flag,

    DirectProductError:
      C_m_times_C_n_called_cyclic_without_coprime_orders
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "CyclicGroup IS_A AbelianGroup",
      "FiniteCyclicGroup IS_A CyclicGroup",
      "InfiniteCyclicGroup IS_A CyclicGroup"
    ],

    RELATED_TO: [
      "CyclicGroup RELATED_TO ModularArithmetic",
      "CyclicGroup RELATED_TO EulerTotientFunction",
      "CyclicGroup RELATED_TO RootsOfUnity",
      "CyclicGroup RELATED_TO FiniteField",
      "CyclicGroup RELATED_TO Cryptography"
    ],

    DEPENDS_ON: [
      GroupOntology,
      AbelianGroupOntology,
      Generator,
      ElementOrder
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    finite_classification:
      cyclic_groups_of_same_order_are_isomorphic,

    infinite_classification:
      all_infinite_cyclic_groups_are_isomorphic
  },

  CONFIDENCE: {
    cyclicity_confidence:
      IF candidate_generator_verified_to_generate_all_elements
      THEN 1.0,

    generator_confidence:
      IF gcd_condition_verified_in_finite_case
      THEN 1.0,

    subgroup_confidence:
      IF divisor_order_relation_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_cyclic_group,
      identify_generator,
      test_generator_candidate,
      determine_group_order,
      determine_element_orders,
      count_generators,
      enumerate_subgroups,
      map_subgroups_to_divisors,
      construct_quotient_groups,
      analyse_homomorphisms_from_generator_image,
      test_direct_product_cyclicity,
      connect_modular_arithmetic,
      detect_noncyclic_counterexamples,
      link_related_ontologies
    ],

    preferred_representation:
      typed_single_generator_group_with_divisor_lattice,

    reasoning_mode:
      recursive_generator_order_and_divisor_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseCyclicGroupCandidate(G,Operation,Context):

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

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

      generators := FindSingleElementGenerators(group_result)

      IF generators = EmptySet:
        RETURN NonCyclicGroup

      order := group_result.order

      IF order is finite:
        canonical_model := Z/orderZ
        generator_count := EulerPhi(order)
        subgroups := {
          FOR_EACH d dividing order:
            UniqueSubgroupOfOrder(d)
        }
      ELSE:
        canonical_model := Integers
        generator_count := 2
        subgroups := {
          nZ for_n>=0
        }

      RETURN {
        entity:CyclicGroup,
        carrier:group_result.carrier,
        operation:group_result.operation,
        order,
        generators,
        canonical_model,
        generator_count,
        subgroups,
        verified:TRUE
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      cyclicity_implies_abelian=TRUE,

    invariant_2:
      every_subgroup_is_cyclic=TRUE,

    invariant_3:
      finite_subgroup_orders_correspond_to_divisors=TRUE,

    invariant_4:
      generator_count_matches_Euler_phi_for_finite_case=TRUE,

    invariant_5:
      finite_cyclic_group_classification_matches_Z_n=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      cyclic_group_definition,
      generator_semantics,
      element_order_formula,
      subgroup_divisor_relation,
      homomorphism_rules,
      classification_theorem
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      single_generator_definition,
      cyclic_implies_abelian,
      subgroup_cyclic_property,
      finite_classification_by_order,
      generator_gcd_condition
    ],

    revision_triggers: [
      semantic_conflict,
      AbelianGroupOntology_update,
      GroupOntology_update,
      modular_arithmetic_relation_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      CyclicGroup,
      AbelianGroup,
      Generator,
      ElementOrder,
      GroupOrder,
      Subgroup,
      QuotientGroup,
      Homomorphism,
      Integers,
      IntegersModuloN,
      EulerTotientFunction
    ],

    edges: [
      CyclicGroup -> IS_A -> AbelianGroup,
      CyclicGroup -> HAS_GENERATOR -> Generator,
      Generator -> HAS_ORDER -> ElementOrder,
      CyclicGroup -> HAS_ORDER -> GroupOrder,
      Subgroup -> SUBSET_OF -> CyclicGroup,
      QuotientGroup -> FORMED_FROM -> CyclicGroup,
      Homomorphism -> DETERMINED_BY -> GeneratorImage,
      FiniteCyclicGroup -> ISOMORPHIC_TO -> IntegersModuloN,
      InfiniteCyclicGroup -> ISOMORPHIC_TO -> Integers,
      GeneratorCount -> GIVEN_BY -> EulerTotientFunction
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    GroupOntology:
      direct_parent,

    AbelianGroupOntology:
      immediate_specialisation_parent,

    NumberTheoryOntology:
      gcd_divisors_and_totient,

    ModularArithmeticOntology:
      finite_cyclic_models,

    FiniteFieldOntology:
      multiplicative_group_relation,

    ComplexNumberOntology:
      roots_of_unity,

    CryptographyOntology:
      discrete_logarithm_context
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      cyclic_group_defined,
      generator_semantics_defined,
      finite_and_infinite_classification_defined,
      element_order_formula_defined,
      generator_count_defined,
      subgroup_structure_defined,
      quotient_and_homomorphism_relations_defined,
      direct_product_condition_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Cyclic_Group_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> VerifyUnderlyingGroup
    -> SearchForSingleGenerator
    -> DetermineFiniteOrInfiniteOrder
    -> ComputeGeneratorSet
    -> ComputeElementOrders
    -> CountGenerators
    -> AnalyseSubgroupsViaDivisors
    -> AnalyseQuotientsAndHomomorphisms
    -> TestDirectProductCyclicityWhenRequired
    -> MapToCanonicalIntegerModel
    -> VerifySemanticConsistency
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    carrier_set,
    operation,
    group_order,
    generators,
    generator_count,
    element_orders,
    canonical_model,
    subgroups,
    quotient_groups,
    homomorphisms,
    direct_product_relations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Cyclic_Group_Ontology_v1.0