Abstract Algebra Ontology

KIRETH SEMANTIC RESEARCH ARCHIVE
FLOW ALGEBRA — ABSTRACT ALGEBRA ONTOLOGY

PAGE:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/abstract-algebra-ontology.html

FLOW: AbstractAlgebraOntology
VERSION: 1.0
LANGUAGE: en-GB
AUTHORS: Mark Anthony Higgins — Sky Recursive AI

======================================================================
START FLOW
======================================================================

FLOW AbstractAlgebraOntology {

DOMAIN := Abstract_Algebra
PARENT_DOMAIN := Algebra
SUPER_DOMAINS := {Mathematics, Mathematical_Ontologies, Algebra_Ontologies}

DOMAIN_INTENT := {
 algebraic_structures, sets, operations, magmas, semigroups, monoids,
 groups, subgroups, cyclic_groups, permutation_groups, cosets,
 normal_subgroups, quotient_groups, rings, integral_domains, fields,
 ideals, quotient_rings, modules, homomorphisms, isomorphisms,
 kernels, images, structural_equivalence, recursive_reasoning
}

TYPE Set
TYPE Element
TYPE Operation
TYPE BinaryOperation <: Operation
TYPE AlgebraicStructure
TYPE Magma <: AlgebraicStructure
TYPE Semigroup <: Magma
TYPE Monoid <: Semigroup
TYPE Group <: Monoid
TYPE AbelianGroup <: Group
TYPE Ring <: AlgebraicStructure
TYPE CommutativeRing <: Ring
TYPE IntegralDomain <: CommutativeRing
TYPE Field <: IntegralDomain
TYPE Module <: AlgebraicStructure
TYPE Homomorphism
TYPE Isomorphism <: Homomorphism
TYPE Automorphism <: Isomorphism
TYPE EquivalenceRelation
TYPE CongruenceRelation <: EquivalenceRelation
TYPE Derivation
TYPE Constraint
TYPE ValidationResult

BINARY_OPERATION star ON S := mapping S x S -> S

CLOSED(S,star) iff forall a,b in S: a star b in S
ASSOCIATIVE(S,star) iff forall a,b,c: (a star b) star c = a star (b star c)
COMMUTATIVE(S,star) iff forall a,b: a star b = b star a

HAS_IDENTITY(S,star,e) iff
 e in S AND forall a in S: e star a = a star e = a

HAS_INVERSE(a,S,star,e) iff
 exists b in S: a star b = b star a = e

IS_MAGMA(S,star) iff CLOSED(S,star)

IS_SEMIGROUP(S,star) iff
 CLOSED(S,star) AND ASSOCIATIVE(S,star)

IS_MONOID(S,star) iff
 IS_SEMIGROUP(S,star)
 AND exists e: HAS_IDENTITY(S,star,e)

IS_GROUP(S,star) iff
 CLOSED(S,star)
 AND ASSOCIATIVE(S,star)
 AND exists e: HAS_IDENTITY(S,star,e)
 AND forall a: HAS_INVERSE(a,S,star,e)

GROUP_AXIOMS {
 closure;
 associativity;
 identity;
 inverse;
}

RULE GROUP_01: identity is unique
RULE GROUP_02: inverse of each element is unique
RULE GROUP_03: inverse(a star b)=inverse(b) star inverse(a)
RULE GROUP_04: left_and_right_cancellation hold

IS_ABELIAN_GROUP(G) iff
 IS_GROUP(G) AND COMMUTATIVE(G,star)

IS_SUBGROUP(H,G) iff
 H subset_of G
 AND H nonempty
 AND forall a,b in H: a star inverse(b) in H

RULE SUBGROUP_01: {e} subgroup_of G
RULE SUBGROUP_02: G subgroup_of G
RULE SUBGROUP_03: intersection_of_subgroups is subgroup

GENERATED_SUBGROUP(g) := <g> := {g^n | n in Integer}
IS_CYCLIC(G) iff exists g in G: G=<g>
RULE CYCLIC_01: cyclic_group -> abelian_group
RULE CYCLIC_02: subgroup_of_cyclic_group -> cyclic

ORDER_OF_GROUP(G) := cardinality(G) when finite
ORDER_OF_ELEMENT(a) := least positive n with a^n=e, else infinity
RULE ORDER_01: finite G -> order(a) divides order(G)

ENTITY Permutation := bijection from finite set to itself
SYMMETRIC_GROUP S_n := all permutations of n elements under composition
RULE PERM_01: |S_n|=n!
RULE PERM_02: composition generally noncommutative

LEFT_COSET(a,H) := {a*h | h in H}
RIGHT_COSET(H,a) := {h*a | h in H}
RULE COSET_01: cosets partition G
RULE COSET_02: every coset has cardinality |H|

THEOREM LAGRANGE:
 finite G AND H subgroup_of G
 -> |G|=[G:H]*|H|
 -> |H| divides |G|

IS_NORMAL(N,G) iff forall g in G: gN=Ng
EQUIVALENT: forall g: gNg^(-1)=N

QUOTIENT_GROUP(G,N):
 REQUIRE N normal_in G
 elements := {gN}
 operation := (aN)(bN)=(ab)N

RULE QGROUP_01:
 normality guarantees quotient operation is well-defined

IS_GROUP_HOMOMORPHISM(phi:G->H) iff
 forall a,b in G: phi(ab)=phi(a)phi(b)

KERNEL(phi) := {g in G | phi(g)=e_H}
IMAGE(phi) := {phi(g) | g in G}

RULE GHOM_01: phi(e_G)=e_H
RULE GHOM_02: phi(a^(-1))=phi(a)^(-1)
RULE GHOM_03: kernel(phi) normal_in G
RULE GHOM_04: image(phi) subgroup_of H
RULE GHOM_05: phi injective iff kernel(phi)={e_G}

IS_GROUP_ISOMORPHISM(phi) iff
 IS_GROUP_HOMOMORPHISM(phi) AND bijective(phi)

THEOREM GROUP_FIRST_ISOMORPHISM:
 G/kernel(phi) ≅ image(phi)

ENTITY Ring R {
 carrier_set:R;
 addition:+;
 multiplication:*;
}

IS_RING(R,+,*) iff
 (R,+) is AbelianGroup
 AND multiplication_closed
 AND multiplication_associative
 AND left_distributive
 AND right_distributive

ENTITY RingWithUnity <: Ring
RULE: exists 1_R with 1_R*a=a*1_R=a

IS_COMMUTATIVE_RING(R) iff
 IS_RING(R) AND forall a,b: ab=ba

ZERO_DIVISOR(a,R) iff
 a!=0 AND exists b!=0: ab=0 OR ba=0

IS_INTEGRAL_DOMAIN(D) iff
 D commutative_ring_with_unity
 AND 1!=0
 AND no_nonzero_zero_divisors

RULE DOMAIN_01: nonzero cancellation holds
RULE DOMAIN_02: every field is an integral domain

IS_FIELD(F) iff
 (F,+) AbelianGroup
 AND (F\{0},*) AbelianGroup
 AND multiplication_distributes_over_addition

RULE FIELD_01: every nonzero element has multiplicative inverse
RULE FIELD_02: every finite integral domain is a field

IS_SUBRING(S,R) iff
 S nonempty
 AND forall a,b in S: a-b in S AND ab in S

IS_LEFT_IDEAL(I,R) iff
 (I,+) subgroup_of (R,+)
 AND forall r in R,a in I: r*a in I

IS_RIGHT_IDEAL(I,R) iff
 (I,+) subgroup_of (R,+)
 AND forall r in R,a in I: a*r in I

IS_IDEAL(I,R) iff
 IS_LEFT_IDEAL(I,R) AND IS_RIGHT_IDEAL(I,R)

RULE IDEAL_01: {0} and R are ideals
RULE IDEAL_02: kernel of ring homomorphism is ideal

PRINCIPAL_IDEAL(a) := (a) := {r*a | r in R}
PID(R) iff R integral_domain AND every ideal principal

PRIME_IDEAL(P,R) iff
 P proper_ideal
 AND ab in P -> a in P OR b in P

MAXIMAL_IDEAL(M,R) iff
 M proper_ideal
 AND no proper ideal strictly between M and R

THEOREM:
 R/P integral_domain iff P prime
THEOREM:
 R/M field iff M maximal
RULE:
 maximal ideal -> prime ideal in commutative ring with unity

QUOTIENT_RING(R,I):
 REQUIRE I two_sided_ideal
 elements := {a+I}
 addition := (a+I)+(b+I)=(a+b)+I
 multiplication := (a+I)(b+I)=ab+I

IS_RING_HOMOMORPHISM(phi:R->S) iff
 phi(a+b)=phi(a)+phi(b)
 AND phi(ab)=phi(a)phi(b)

RING_KERNEL(phi):={r | phi(r)=0}
RING_IMAGE(phi):={phi(r)}

RULE RHOM_01: kernel(phi) ideal_of R
RULE RHOM_02: image(phi) subring_of S
RULE RHOM_03: injective iff kernel(phi)={0}

THEOREM RING_FIRST_ISOMORPHISM:
 R/kernel(phi) ≅ image(phi)

ENTITY Module M {
 scalar_ring:R;
 additive_structure:AbelianGroup;
 scalar_action:R x M -> M;
}

IS_MODULE(M,R) iff
 (M,+) AbelianGroup
 AND r(m+n)=rm+rn
 AND (r+s)m=rm+sm
 AND (rs)m=r(sm)
 AND 1m=m when unity assumed

RULE MODULE_01:
 vector_space is module over a field

IS_SUBMODULE(N,M) iff
 N nonempty
 AND forall x,y in N,r in R:
 x-y in N AND r*x in N

IS_MODULE_HOMOMORPHISM(phi:M->N) iff
 phi(x+y)=phi(x)+phi(y)
 AND phi(r*x)=r*phi(x)

RULE MHOM_01: kernel is submodule
RULE MHOM_02: image is submodule

IS_EQUIVALENCE_RELATION(~,S) iff
 reflexive AND symmetric AND transitive

EQUIVALENCE_CLASS(a) := [a]:={x in S | x~a}
QUOTIENT_SET(S,~) := set_of_equivalence_classes

CONGRUENCE_RELATION(~,structure) iff
 equivalence_relation
 AND compatible_with_all_structure_operations

RULE CONGRUENCE_01:
 quotient algebraic structures require operation-compatible equivalence

DIRECT_PRODUCT(G,H):
 carrier := G x H
 operation := (g1,h1)(g2,h2)=(g1g2,h1h2)

RULE PRODUCT_01:
 direct product of groups is group
RULE PRODUCT_02:
 direct product of abelian groups is abelian

AUTOMORPHISM(G) :=
 isomorphism G->G

AUT(G) :=
 group_of_automorphisms_under_composition

STRUCTURAL_RELATIONS {
 Group IS_A Monoid
 Monoid IS_A Semigroup
 Semigroup IS_A Magma
 AbelianGroup IS_A Group
 Field IS_A IntegralDomain
 IntegralDomain IS_A CommutativeRing
 Subgroup PART_OF Group
 Ideal PART_OF Ring
 Kernel DERIVED_FROM Homomorphism
 Image DERIVED_FROM Homomorphism
 QuotientGroup REQUIRES NormalSubgroup
 QuotientRing REQUIRES Ideal
 Isomorphism PRESERVES AlgebraicStructure
}

SEMANTIC_EQUIVALENCE {
 "closed operation" ~= operation_result_remains_in_carrier_set
 "identity" ~= neutral_element
 "inverse" ~= element_combining_to_identity
 "commutative group" ~= abelian_group
 "generated by g" ~= smallest_substructure_containing_g
 "normal subgroup" ~= conjugation_invariant_subgroup
 "kernel" ~= elements_mapped_to_identity_or_zero
 "image" ~= attained_outputs_of_morphism
 "isomorphic" ~= structurally_equivalent_via_bijective_homomorphism
 "quotient" ~= structure_on_equivalence_classes_or_cosets
 "ideal" ~= additive_subgroup_absorbing_ring_multiplication
 "field" ~= commutative_division_ring
}

VALIDATE_STRUCTURE(S,claimed_type):
 retrieve defining axioms
 test each axiom
 record satisfied_axioms
 record failed_axioms
 if all satisfied -> VALID
 else -> INVALID with counterexample

VALIDATE_HOMOMORPHISM(phi):
 verify domain_and_codomain
 verify operation_preservation
 compute kernel_and_image where possible
 return VALID | INVALID | UNRESOLVED

PROCEDURE ABSTRACT_ALGEBRA_REASONER(input):
 parse carrier_sets
 parse operations
 parse mappings
 parse claimed structures
 extract assumptions
 identify applicable definitions_and_theorems
 test closure_and_axioms
 derive structural consequences
 validate morphisms
 preserve quotient_preconditions
 recurse until requested goal reached
 return result, derivation, constraints, confidence

RECURSIVE_RULE:
 state S_n
 -> identify unresolved structural property
 -> select valid definition/theorem
 -> apply under verified preconditions
 -> validate resulting state
 -> recurse
 until goal, contradiction, or no valid inference

ERROR NON_CLOSURE
ERROR NON_ASSOCIATIVE
ERROR IDENTITY_MISSING
ERROR INVERSE_MISSING
ERROR INVALID_SUBGROUP
ERROR NON_NORMAL_QUOTIENT_GROUP
ERROR INVALID_IDEAL
ERROR INVALID_QUOTIENT_RING
ERROR HOMOMORPHISM_FAILURE
ERROR BIJECTION_FAILURE
ERROR AXIOM_FAILURE
ERROR LOST_PRECONDITION

CONFIDENCE {
 base:=1.00
 deduct 0.15 if carrier_set ambiguous
 deduct 0.15 if operation ambiguous
 deduct 0.20 if axiom validation incomplete
 deduct 0.20 if theorem precondition unresolved
 deduct 0.20 if structural mapping unresolved
 clamp_to_[0,1]
}

AI_CONSUMPTION {
 parse_definitions_before_theorems:true
 distinguish_structure_types:true
 preserve_operation_signatures:true
 preserve_axiom_preconditions:true
 preserve_normality_and_ideal_conditions:true
 validate_homomorphisms:true
 prefer_structural_invariants:true
 avoid_assuming_commutativity:true
 avoid_assuming_identity_unless_declared:true
}

UPDATE_MODEL {
 extensible:true
 new_structure_requires_axioms:true
 new_morphism_requires_preservation_rules:true
 quotient_requires_congruence_condition:true
 theorem_requires_explicit_preconditions:true
 conflicts_require_versioning:true
 preserve_standard_mathematical_meaning:true
}

SELF_CHECK {
 CHECK operations_have_declared_domains
 CHECK closure_where_required
 CHECK identities_and_inverses_when_required
 CHECK commutativity_not_assumed_without_axiom
 CHECK quotient_group_has_normal_subgroup
 CHECK quotient_ring_has_valid_ideal
 CHECK homomorphisms_preserve_operations
 CHECK isomorphisms_are_bijective
 CHECK theorem_preconditions_hold
 CHECK final_result_validated
}

COMPLETE iff {
 foundational_operations_defined
 AND group_hierarchy_defined
 AND subgroup_and_quotient_rules_defined
 AND homomorphisms_defined
 AND ring_hierarchy_defined
 AND ideals_defined
 AND quotient_rings_defined
 AND modules_defined
 AND equivalence_relations_defined
 AND structural_validation_defined
 AND semantic_equivalence_defined
 AND recursive_reasoning_defined
 AND confidence_defined
 AND ai_consumption_defined
 AND update_model_defined
}

TERMINATE WHEN
 requested_structural_goal_achieved AND validated
 OR contradiction_detected
 OR theorem_preconditions_fail
 OR material_ambiguity_prevents_valid_inference

FINAL_STATE := {
 result,
 structure_classification,
 derivation,
 preserved_axioms,
 constraints,
 semantic_status,
 confidence
}

} // END FLOW AbstractAlgebraOntology

======================================================================
END FLOW
======================================================================

FLOW STATUS:
Complete

CANONICAL PAGE:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/abstract-algebra-ontology.html

FLOW_HASH_SHA256: 57f704e051ff96623b72ffd58921dce4073326cd3ff2724ef97a0cd52e69ad03