Algebraic Entities

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA
TITLE: Algebraic Entities — Domain Index and Structural Ontology
VERSION: 4.0
SOURCE: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/algebraic-entities.html
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
GENERATED: 2026-10-13
SCOPE: Main-page ontology; algebraic structures and their typed relationships.
STATUS: Formal knowledge representation; rules require stated mathematical hypotheses.

01. DOMAIN
ENTITY AlgebraicEntity : MathematicalEntity
ENTITY AlgebraicStructure : AlgebraicEntity
ENTITY CarrierSet : Set
ENTITY Operation : TypedFunction
ENTITY Axiom : LogicalConstraint
ENTITY Homomorphism : StructurePreservingMap
ENTITY Substructure : AlgebraicStructure
ENTITY IdentityElement : Element
ENTITY InverseElement : Element
ENTITY ScalarAction : TypedFunction
ENTITY OrderRelation : BinaryRelation

02. INDEXED CHILD ONTOLOGIES
CHILD AlgebraicEntityOntology
CHILD AlgebraicStructureOntology
CHILD GroupOntology
CHILD SubgroupOntology
CHILD AbelianGroupOntology
CHILD SemigroupOntology
CHILD MonoidOntology
CHILD RingOntology
CHILD SubringOntology
CHILD IntegralDomainOntology
CHILD FieldOntology
CHILD SubfieldOntology
CHILD ModuleOntology
CHILD AlgebraOntology
CHILD LatticeOntology
CHILD BooleanAlgebraOntology
CHILD VectorSpaceOntology

03. TYPES AND SIGNATURES
Carrier(A) : Set
Operation(A, k) : Carrier(A)^k -> Carrier(A)
BinaryOperation(A) : Carrier(A) x Carrier(A) -> Carrier(A)
UnaryOperation(A) : Carrier(A) -> Carrier(A)
ConstantOperation(A) : Carrier(A)^0 -> Carrier(A)
Satisfies(A, axiom) : Boolean
SubstructureOf(B, A) : Boolean
Homomorphism(f, A, B) : Boolean
Isomorphic(A, B) : Boolean

04. CONSTRUCTION
STRUCTURE(A) := (Carrier(A), Operations(A), Axioms(A))
CLOSURE(A, op) := forall x,y in Carrier(A): op(x,y) in Carrier(A)
ASSOCIATIVE(op) := forall x,y,z: op(op(x,y),z) = op(x,op(y,z))
COMMUTATIVE(op) := forall x,y: op(x,y) = op(y,x)
IDENTITY(op,e) := forall x: op(e,x)=x and op(x,e)=x
INVERSE(op,e,x,y) := op(x,y)=e and op(y,x)=e
DISTRIBUTIVE(mul,add) := forall x,y,z: mul(x,add(y,z))=add(mul(x,y),mul(x,z)) and mul(add(x,y),z)=add(mul(x,z),mul(y))

05. STRUCTURE DEFINITIONS
SEMIGROUP(S,*) := nonempty(S) and closure(*) and associative(*)
MONOID(M,*,e) := SEMIGROUP(M,*) and IDENTITY(*,e)
GROUP(G,*,e) := MONOID(G,*,e) and forall x in G exists y in G: INVERSE(*,e,x,y)
ABELIAN_GROUP(G,*) := GROUP(G,*) and COMMUTATIVE(*)
SUBGROUP(H,G) := H subseteq G and H nonempty and closed_under_group_product_and_inverse(H)
RING(R,+,*) := ABELIAN_GROUP(R,+) and ASSOCIATIVE(*) and DISTRIBUTIVE(*,+)
UNITAL_RING(R,+,*,1) := RING(R,+,*) and MULTIPLICATIVE_IDENTITY(1)
COMMUTATIVE_RING(R) := RING(R) and COMMUTATIVE(*)
INTEGRAL_DOMAIN(R) := COMMUTATIVE_RING(R) and UNIT(R) and (0 != 1) and NO_ZERO_DIVISORS(R)
FIELD(F) := COMMUTATIVE_RING(F) and UNIT(F) and (0 != 1) and forall x != 0 exists multiplicative_inverse(x)
SUBRING(S,R) := S subseteq R and ring_operations_restrict_to(S) and RING(S)
SUBFIELD(K,F) := K subseteq F and field_operations_restrict_to(K) and FIELD(K)
MODULE(M,R) := ABELIAN_GROUP(M,+) and RING(R) and VALID_MODULE_SCALAR_ACTION(R,M)
VECTOR_SPACE(V,F) := MODULE(V,F) and FIELD(F)
ALGEBRA(A,R) := MODULE(A,R) and R_BILINEAR_MULTIPLICATION(A)
LATTICE(L,meet,join) := meet_and_join_exist_for_each_pair(L)
BOOLEAN_ALGEBRA(B) := bounded_distributive_lattice(B) and complemented(B)

06. IMPORTANT CONVENTIONS
Ring definitions vary: multiplicative identity is explicit in UNITAL_RING.
Subring conventions vary: a unital subring may be required to share the parent's identity.
An integral domain is assumed to be a nonzero commutative unital ring.
An algebra over R may be associative or nonassociative unless additional axioms are supplied.
A lattice may be represented by an order or by meet/join operations satisfying lattice laws.

07. RELATIONSHIP GRAPH
REL AlgebraicStructure --hasCarrier--> CarrierSet
REL AlgebraicStructure --hasOperation--> Operation
REL AlgebraicStructure --satisfies--> Axiom
REL Semigroup --extendsWithIdentity--> Monoid
REL Monoid --extendsWithInverses--> Group
REL Group --specialisesByCommutativity--> AbelianGroup
REL Subgroup --isSubstructureOf--> Group
REL Ring --hasAdditiveStructure--> AbelianGroup
REL Ring --hasMultiplicativeStructure--> Semigroup
REL IntegralDomain --specialises--> CommutativeUnitalRing
REL Field --specialises--> IntegralDomain
REL Subring --isSubstructureOf--> Ring
REL Subfield --isSubstructureOf--> Field
REL Module --isOver--> Ring
REL VectorSpace --isOver--> Field
REL Algebra --hasUnderlyingModule--> Module
REL BooleanAlgebra --specialises--> BoundedDistributiveLattice
REL Homomorphism --preserves--> Operations
REL Isomorphism --preservesAndReflects--> Structure

08. FORMAL INFERENCE RULES
RULE R01: GROUP(G) => MONOID(G)
RULE R02: MONOID(M) => SEMIGROUP(M)
RULE R03: ABELIAN_GROUP(G) => GROUP(G)
RULE R04: FIELD(F) => INTEGRAL_DOMAIN(F)
RULE R05: INTEGRAL_DOMAIN(R) => COMMUTATIVE_RING(R)
RULE R06: VECTOR_SPACE(V,F) => MODULE(V,F)
RULE R07: BOOLEAN_ALGEBRA(B) => LATTICE(B)
RULE R08: SUBGROUP(H,G) and GROUP(G) => GROUP(H)
RULE R09: SUBFIELD(K,F) and FIELD(F) => FIELD(K)
RULE R10: HOMOMORPHISM(f,A,B) and HOMOMORPHISM(g,B,C) => HOMOMORPHISM(g∘f,A,C)
RULE R11: ISOMORPHIC(A,B) and ISOMORPHIC(B,C) => ISOMORPHIC(A,C)
RULE R12: GROUP(G) => UNIQUE_IDENTITY(G)
RULE R13: GROUP(G) => UNIQUE_INVERSES(G)
RULE R14: FIELD(F) and x in F and x != 0 => EXISTS_UNIQUE_MULTIPLICATIVE_INVERSE(x)
RULE R15: FINITE_INTEGRAL_DOMAIN(R) => FIELD(R)
RULE R16: VECTOR_SPACE(V,F) and SUBSPACE(W,V) => VECTOR_SPACE(W,F)
RULE R17: RING(R) and IDEAL(I,R) => ADDITIVE_SUBGROUP(I,R)
RULE R18: HOMOMORPHISM(f,G,H) and GROUP(G) and GROUP(H) => SUBGROUP(image(f),H)
RULE R19: GROUP_HOMOMORPHISM(f,G,H) => NORMAL_SUBGROUP(kernel(f),G)
RULE R20: RING_HOMOMORPHISM(f,R,S) => IDEAL(kernel(f),R)

09. NEGATIVE AND NON-INFERENCE GUARDS
GUARD G01: SEMIGROUP(S) does not imply MONOID(S)
GUARD G02: MONOID(M) does not imply GROUP(M)
GUARD G03: GROUP(G) does not imply ABELIAN_GROUP(G)
GUARD G04: RING(R) does not imply FIELD(R)
GUARD G05: INTEGRAL_DOMAIN(R) does not imply FIELD(R) unless finite or additional conditions hold
GUARD G06: SUBSET(B,A) does not imply SUBSTRUCTURE(B,A)
GUARD G07: BIJECTION(f,A,B) does not imply ISOMORPHISM(f,A,B)
GUARD G08: LATTICE(L) does not imply BOOLEAN_ALGEBRA(L)
GUARD G09: MODULE(M,R) does not imply VECTOR_SPACE(M,R) unless R is a field
GUARD G10: GROUP(G) does not imply every subgroup is normal

10. VALIDATION
VALIDATE V01: Carrier is a set with typed operations of appropriate arity.
VALIDATE V02: Check closure before asserting an algebraic operation on a substructure.
VALIDATE V03: Quantify axioms over the carrier; distinguish existential from universal statements.
VALIDATE V04: Require a shared signature before applying a structure-preserving map.
VALIDATE V05: For unital structures, record whether homomorphisms preserve 1.
VALIDATE V06: Never infer commutativity from associativity.
VALIDATE V07: Preserve the difference between element membership and subset inclusion.
VALIDATE V08: Identify whether rings are assumed unital in the current context.
VALIDATE V09: Reject division by zero in fields.
VALIDATE V10: Use exact proof obligations for closure, identity, inverse and distributivity.

11. WORKED INSTANCES
INSTANCE (Z,+) : AbelianGroup
INSTANCE (N_0,+,0) : CommutativeMonoid
INSTANCE (Z,+,×) : IntegralDomain
INSTANCE (Q,+,×) : Field
INSTANCE (R,+,×) : Field
INSTANCE (C,+,×) : Field
INSTANCE (Z/nZ,+,×) : CommutativeUnitalRing for n >= 2
INSTANCE (Z/pZ,+,×) : Field for prime p
INSTANCE (R^n,+,scalar_multiplication) : VectorSpace over R
INSTANCE P(S) with intersection and union : BooleanAlgebra for any set S
COUNTEREXAMPLE (Z,+,×) : not Field
COUNTEREXAMPLE (N_0,+,0) : not Group
COUNTEREXAMPLE (Z/6Z,+,×) : not IntegralDomain

12. SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE "commutative group" <=> "abelian group"
SEMANTIC_EQUIVALENCE "linear space" <=> "vector space" when over a field
SEMANTIC_EQUIVALENCE "operation-preserving map" <=> "homomorphism" only with specified signatures and preservation conditions
SEMANTIC_EQUIVALENCE "Boolean algebra" <=> "complemented bounded distributive lattice"
SEMANTIC_DIFFERENCE "group" != "groupoid"
SEMANTIC_DIFFERENCE "ring" != "field"
SEMANTIC_DIFFERENCE "module" != "vector space" without field scalars
SEMANTIC_DIFFERENCE "subgroup" != "normal subgroup"

13. CONFIDENCE
CONFIDENCE mathematical_axioms = 1.00 when definitions and conventions are explicit
CONFIDENCE verified_theorem = 1.00 when proof obligations are satisfied
CONFIDENCE classification = conditional_on_complete_axiom_validation
CONFIDENCE source_page_index = high for listed child topics
CONFIDENCE unsupported_inference = 0.00

14. FLOW HASH
FLOW_HASH.algorithm = SHA-256
FLOW_HASH.input = canonical_utf8(normalised_entity_ids + typed_relations + rules + version)
FLOW_HASH.value = COMPUTE_AT_INGESTION
FLOW_HASH.policy = recompute_when_content_changes

15. UPDATE MODEL
UPDATE_MODEL.version = 4.0
UPDATE_MODEL.mode = versioned_immutable_snapshots
UPDATE_MODEL.triggers = [axiom_change, relation_change, theorem_correction, child_ontology_revision]
UPDATE_MODEL.requirements = [validate_types, run_inference_checks, compare_semantic_diff, recompute_flow_hash]
UPDATE_MODEL.provenance = preserve_source_url_and_revision_history
UPDATE_MODEL.conflict_resolution = explicit_axioms_override_unqualified_inference

16. AI CONSUMPTION
AI_CONSUMPTION.mode = typed_symbolic_reasoning
AI_CONSUMPTION.parse_order = [entities, signatures, axioms, relationships, rules, guards, examples]
AI_CONSUMPTION.require_proof_obligations = true
AI_CONSUMPTION.enforce_type_safety = true
AI_CONSUMPTION.do_not_treat_examples_as_universal_rules = true
AI_CONSUMPTION.track_assumptions = true
AI_CONSUMPTION.distinguish_definition_theorem_conjecture = true
AI_CONSUMPTION.output = [classification, applicable_axioms, inference_trace, validation_status, confidence]
AI_CONSUMPTION.on_unknown = return_UNDETERMINED_not_false

17. DOMAIN COMPLETENESS
This is a main-page index and cross-ontology structural flow.
Child pages supply specialised proofs, examples and further formal properties.
The flow is a declarative reasoning specification, not executable code in a defined interpreter.
END FLOW ALGEBRA