Boolean Algebra Ontology
Algebra Ontologies
Authors: MArk Anthony Higgins - Sky Recursive Ai
Revised Date: 13 September 2026
Audio Overview
======================================================================
KIRETH SEMANTIC RESEARCH ARCHIVE
FLOW ALGEBRA — BOOLEAN ALGEBRA ONTOLOGY
======================================================================
PAGE:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/boolean-algebra-ontology.html
FLOW:
BooleanAlgebraOntology
VERSION:
1.0
LANGUAGE:
en-GB
AUTHORS:
Mark Anthony Higgins — Sky Recursive AI
PURPOSE:
To provide a machine-readable, recursively executable semantic and
reasoning specification for Boolean algebra, including Boolean values,
operations, laws, identities, expressions, truth tables, normal forms,
duality, simplification, switching interpretations, set-theoretic
interpretations and logical equivalence.
AI INTERPRETATION NOTE:
Execute the following specification as formal semantic and reasoning
rules. Preserve Boolean domains, operator meanings, equivalence,
duality and canonical-form invariants.
======================================================================
START FLOW
======================================================================
FLOW BooleanAlgebraOntology {
----------------------------------------------------------------------
1. DOMAIN DECLARATION
----------------------------------------------------------------------
DOMAIN := Boolean_Algebra
PARENT_DOMAIN := Algebra
SUPER_DOMAINS := {
Mathematics,
Mathematical_Ontologies,
Algebra_Ontologies,
Abstract_Algebra
}
DOMAIN_INTENT := {
represent_boolean_values,
represent_boolean_variables,
represent_boolean_operations,
represent_boolean_expressions,
represent_boolean_functions,
represent_truth_tables,
represent_boolean_identies,
represent_boolean_equivalence,
represent_duality,
represent_normal_forms,
represent_minterms,
represent_maxterms,
represent_simplification,
represent_set_interpretations,
represent_logic_interpretations,
support_symbolic_boolean_reasoning,
support_recursive_equivalence_validation
}
----------------------------------------------------------------------
2. PRIMITIVE TYPES
----------------------------------------------------------------------
TYPE BooleanValue
TYPE BooleanVariable
TYPE BooleanConstant
TYPE BooleanExpression
TYPE BooleanFunction
TYPE UnaryBooleanOperation
TYPE BinaryBooleanOperation
TYPE TruthTable
TYPE Minterm
TYPE Maxterm
TYPE NormalForm
TYPE SumOfProducts <: NormalForm
TYPE ProductOfSums <: NormalForm
TYPE CanonicalSOP <: SumOfProducts
TYPE CanonicalPOS <: ProductOfSums
TYPE Statement
TYPE Equivalence
TYPE Derivation
TYPE ProofStep
TYPE ValidationResult
BOOLEAN_DOMAIN := {0,1}
INTERPRETATION:
0 ~= false
1 ~= true
----------------------------------------------------------------------
3. CORE OPERATIONS
----------------------------------------------------------------------
OPERATOR NOT(x) := ¬x
OPERATOR AND(x,y) := x ∧ y
OPERATOR OR(x,y) := x ∨ y
OPERATOR XOR(x,y) := x ⊕ y
OPERATOR NAND(x,y) := ¬(x ∧ y)
OPERATOR NOR(x,y) := ¬(x ∨ y)
OPERATOR IMPLIES(x,y) := ¬x ∨ y
OPERATOR EQUIV(x,y) := (x ∧ y) ∨ (¬x ∧ ¬y)
RULE OP_01:
NOT(0)=1
NOT(1)=0
RULE OP_02:
AND(x,y)=1 iff x=1 and y=1
RULE OP_03:
OR(x,y)=1 iff x=1 or y=1
RULE OP_04:
XOR(x,y)=1 iff x!=y
----------------------------------------------------------------------
4. BOOLEAN ALGEBRA STRUCTURE
----------------------------------------------------------------------
ENTITY BooleanAlgebra B {
carrier_set: B
operations: {∨, ∧, ¬}
constants: {0,1}
}
IS_BOOLEAN_ALGEBRA(B) iff
satisfies:
commutativity,
associativity,
distributivity,
identity_laws,
complement_laws
AXIOM BA_01:
x ∨ y = y ∨ x
AXIOM BA_02:
x ∧ y = y ∧ x
AXIOM BA_03:
x ∨ (y ∨ z) = (x ∨ y) ∨ z
AXIOM BA_04:
x ∧ (y ∧ z) = (x ∧ y) ∧ z
AXIOM BA_05:
x ∨ (y ∧ z) = (x ∨ y) ∧ (x ∨ z)
AXIOM BA_06:
x ∧ (y ∨ z) = (x ∧ y) ∨ (x ∧ z)
AXIOM BA_07:
x ∨ 0 = x
AXIOM BA_08:
x ∧ 1 = x
AXIOM BA_09:
x ∨ ¬x = 1
AXIOM BA_10:
x ∧ ¬x = 0
----------------------------------------------------------------------
5. DERIVED LAWS
----------------------------------------------------------------------
LAW IDENTITY_OR:
x ∨ 0 = x
LAW IDENTITY_AND:
x ∧ 1 = x
LAW DOMINATION_OR:
x ∨ 1 = 1
LAW DOMINATION_AND:
x ∧ 0 = 0
LAW IDEMPOTENT_OR:
x ∨ x = x
LAW IDEMPOTENT_AND:
x ∧ x = x
LAW DOUBLE_NEGATION:
¬(¬x)=x
LAW COMPLEMENT_OR:
x ∨ ¬x = 1
LAW COMPLEMENT_AND:
x ∧ ¬x = 0
LAW ABSORPTION_01:
x ∨ (x ∧ y) = x
LAW ABSORPTION_02:
x ∧ (x ∨ y) = x
----------------------------------------------------------------------
6. DE MORGAN'S LAWS
----------------------------------------------------------------------
LAW DEMORGAN_01:
¬(x ∧ y) = ¬x ∨ ¬y
LAW DEMORGAN_02:
¬(x ∨ y) = ¬x ∧ ¬y
RULE DEMORGAN_03:
complement distributes across compound expressions by
swapping AND and OR and complementing operands recursively.
----------------------------------------------------------------------
7. CONSENSUS THEOREM
----------------------------------------------------------------------
LAW CONSENSUS_01:
xy ∨ ¬x z ∨ yz
=
xy ∨ ¬x z
DUAL_CONSENSUS:
(x∨y)(¬x∨z)(y∨z)
=
(x∨y)(¬x∨z)
----------------------------------------------------------------------
8. BOOLEAN EXPRESSIONS
----------------------------------------------------------------------
ENTITY BooleanExpression E {
variables: BooleanVariable*
constants: BooleanConstant*
operators: BooleanOperation*
}
WELL_FORMED(E) iff
all operators have correct arity
AND all leaves are variables or constants
RULE EXPR_01:
every well-formed Boolean expression defines a Boolean function.
----------------------------------------------------------------------
9. BOOLEAN FUNCTIONS
----------------------------------------------------------------------
ENTITY BooleanFunction f {
arity: n
mapping:
{0,1}^n -> {0,1}
}
RULE BF_01:
n-variable Boolean function has exactly 2^n possible input rows.
RULE BF_02:
number of distinct n-variable Boolean functions
= 2^(2^n)
----------------------------------------------------------------------
10. TRUTH TABLES
----------------------------------------------------------------------
ENTITY TruthTable T {
variables: [x1,...,xn]
rows: 2^n
outputs: BooleanValue*
}
PROCEDURE BUILD_TRUTH_TABLE(E):
identify variables
enumerate all binary assignments
evaluate E for each assignment
record output
RETURN TruthTable
RULE TT_01:
two expressions are equivalent iff their truth tables are identical.
----------------------------------------------------------------------
11. BOOLEAN EQUIVALENCE
----------------------------------------------------------------------
BOOLEAN_EQUIVALENT(A,B) iff
forall assignments alpha:
EVAL(A,alpha)=EVAL(B,alpha)
NOTATION:
A ≡ B
PROCEDURE VALIDATE_EQUIVALENCE(A,B):
attempt symbolic simplification
if same normal form:
return VALID
otherwise compare truth tables
if all rows equal:
return VALID
else:
return INVALID with counterexample assignment
----------------------------------------------------------------------
12. DUALITY
----------------------------------------------------------------------
DUAL_TRANSFORM(expression):
exchange:
∨ <-> ∧
0 <-> 1
preserve:
variables
complements
PRINCIPLE_OF_DUALITY:
if Boolean identity is valid,
its dual identity is also valid.
EXAMPLE:
x ∨ 0 = x
dual:
x ∧ 1 = x
----------------------------------------------------------------------
13. LITERAL
----------------------------------------------------------------------
ENTITY Literal {
variable: x
polarity: positive | negative
}
POSITIVE_LITERAL(x) := x
NEGATIVE_LITERAL(x) := ¬x
----------------------------------------------------------------------
14. MINTERMS
----------------------------------------------------------------------
ENTITY Minterm {
literals:
exactly one literal for every variable
connective:
AND
}
RULE MINTERM_01:
a minterm evaluates to 1 on exactly one assignment.
FUNCTION MINTERM(index,variables):
encode assignment bits
use positive literal for 1
use complemented literal for 0
----------------------------------------------------------------------
15. MAXTERMS
----------------------------------------------------------------------
ENTITY Maxterm {
literals:
exactly one literal for every variable
connective:
OR
}
RULE MAXTERM_01:
a maxterm evaluates to 0 on exactly one assignment.
FUNCTION MAXTERM(index,variables):
encode assignment bits
use complemented literal for 1
use positive literal for 0
----------------------------------------------------------------------
16. SUM OF PRODUCTS
----------------------------------------------------------------------
ENTITY SumOfProducts {
structure:
OR of product terms
}
SOP(E):
-
expression represented as:
P1 ∨ P2 ∨ ... ∨ Pk
where each Pi is AND of literals.
----------------------------------------------------------------------
17. PRODUCT OF SUMS
----------------------------------------------------------------------
ENTITY ProductOfSums {
structure:
AND of sum terms
}
POS(E):
-
expression represented as:
S1 ∧ S2 ∧ ... ∧ Sk
where each Si is OR of literals.
----------------------------------------------------------------------
18. CANONICAL SOP
----------------------------------------------------------------------
CANONICAL_SOP(f):
identify truth-table rows where f=1
generate corresponding minterm for each row
OR all minterms
RETURN canonical_sum_of_products
NOTATION:
f = Σm(indices)
----------------------------------------------------------------------
19. CANONICAL POS
----------------------------------------------------------------------
CANONICAL_POS(f):
identify truth-table rows where f=0
generate corresponding maxterm for each row
AND all maxterms
RETURN canonical_product_of_sums
NOTATION:
f = ΠM(indices)
----------------------------------------------------------------------
20. COMPLEMENTS
----------------------------------------------------------------------
RULE COMP_01:
¬0=1
RULE COMP_02:
¬1=0
RULE COMP_03:
¬¬x=x
RULE COMP_04:
complement of SOP may be transformed to POS using De Morgan.
RULE COMP_05:
complement of POS may be transformed to SOP using De Morgan.
----------------------------------------------------------------------
21. SIMPLIFICATION ENGINE
----------------------------------------------------------------------
PROCEDURE SIMPLIFY_BOOLEAN(E):
repeat until stable:
remove_double_negations
apply_identity_laws
apply_domination_laws
apply_idempotent_laws
apply_complement_laws
apply_absorption_laws
apply_distributive_laws_when_complexity_reduces
apply_De_Morgan_when_useful
apply_consensus_rule
remove_duplicate_terms
validate equivalence
RETURN simplified_expression
----------------------------------------------------------------------
22. COMPLEXITY MODEL
----------------------------------------------------------------------
FUNCTION COMPLEXITY(E):
literals := count_literals(E)
operators := count_operators(E)
nesting := max_depth(E)
return:
literals
+ operators
+ nesting
RULE COMPLEXITY_01:
simplification SHOULD reduce complexity while preserving equivalence.
----------------------------------------------------------------------
23. DISTRIBUTIVITY
----------------------------------------------------------------------
LAW DIST_01:
x ∧ (y ∨ z)
=
(x ∧ y) ∨ (x ∧ z)
LAW DIST_02:
x ∨ (y ∧ z)
=
(x ∨ y) ∧ (x ∨ z)
RULE DIST_03:
Boolean algebra is distributive in both directions.
----------------------------------------------------------------------
24. ABSORPTION
----------------------------------------------------------------------
LAW ABS_01:
x ∨ xy = x
LAW ABS_02:
x(x∨y)=x
LAW ABS_03:
x ∨ ¬x y = x ∨ y
LAW ABS_04:
x(¬x∨y)=xy
----------------------------------------------------------------------
25. REDUNDANCY
----------------------------------------------------------------------
RULE REDUNDANCY_01:
duplicate terms may be removed:
x∨x=x
RULE REDUNDANCY_02:
duplicate factors may be removed:
xx=x
RULE REDUNDANCY_03:
absorbed terms may be eliminated.
----------------------------------------------------------------------
26. XOR IDENTITIES
----------------------------------------------------------------------
XOR(x,y) :=
x¬y ∨ ¬x y
RULE XOR_01:
x⊕0=x
RULE XOR_02:
x⊕1=¬x
RULE XOR_03:
x⊕x=0
RULE XOR_04:
x⊕¬x=1
RULE XOR_05:
x⊕y=y⊕x
RULE XOR_06:
(x⊕y)⊕z=x⊕(y⊕z)
----------------------------------------------------------------------
27. XNOR / EQUIVALENCE
----------------------------------------------------------------------
XNOR(x,y) :=
xy ∨ ¬x¬y
RULE XNOR_01:
XNOR(x,y)=¬(x⊕y)
RULE XNOR_02:
XNOR(x,y)=1 iff x=y
----------------------------------------------------------------------
28. NAND FUNCTIONAL COMPLETENESS
----------------------------------------------------------------------
NAND(x,y):=¬(xy)
DERIVE_NOT_FROM_NAND:
¬x = NAND(x,x)
DERIVE_AND_FROM_NAND:
xy = NAND(NAND(x,y),NAND(x,y))
DERIVE_OR_FROM_NAND:
x∨y =
NAND(
NAND(x,x),
NAND(y,y)
)
THEOREM NAND_COMPLETE:
every Boolean function can be expressed using NAND alone.
----------------------------------------------------------------------
29. NOR FUNCTIONAL COMPLETENESS
----------------------------------------------------------------------
NOR(x,y):=¬(x∨y)
DERIVE_NOT_FROM_NOR:
¬x=NOR(x,x)
DERIVE_OR_FROM_NOR:
x∨y=NOR(NOR(x,y),NOR(x,y))
DERIVE_AND_FROM_NOR:
xy=
NOR(
NOR(x,x),
NOR(y,y)
)
THEOREM NOR_COMPLETE:
every Boolean function can be expressed using NOR alone.
----------------------------------------------------------------------
30. FUNCTIONAL COMPLETENESS
----------------------------------------------------------------------
ENTITY FunctionallyCompleteOperatorSet S
FUNCTIONALLY_COMPLETE(S) iff
every Boolean function can be represented using operators from S.
KNOWN_COMPLETE_SETS include:
{NOT,AND}
{NOT,OR}
{NAND}
{NOR}
----------------------------------------------------------------------
31. SET-THEORETIC INTERPRETATION
----------------------------------------------------------------------
MAP BooleanAlgebra -> SetAlgebra {
Boolean 0 -> empty_set
Boolean 1 -> universal_set
x ∧ y -> intersection(X,Y)
x ∨ y -> union(X,Y)
¬x -> complement(X)
}
RULE SET_01:
Boolean identities correspond to set identities under this mapping.
----------------------------------------------------------------------
32. PROPOSITIONAL LOGIC INTERPRETATION
----------------------------------------------------------------------
MAP BooleanAlgebra -> PropositionalLogic {
0 -> False
1 -> True
∧ -> conjunction
∨ -> disjunction
¬ -> negation
⊕ -> exclusive_or
}
RULE LOGIC_01:
Boolean equivalence corresponds to logical equivalence.
----------------------------------------------------------------------
33. SWITCHING ALGEBRA INTERPRETATION
----------------------------------------------------------------------
MAP BooleanValue -> SwitchingState {
0 -> OFF
1 -> ON
}
MAP:
AND -> series_condition
OR -> parallel_condition
NOT -> inversion
RULE SWITCH_01:
switching circuits may be represented as Boolean expressions.
----------------------------------------------------------------------
34. PARTIAL ORDER
----------------------------------------------------------------------
DEFINE:
x <= y iff x ∧ y = x
EQUIVALENT:
x <= y iff x ∨ y = y
RULE ORDER_01:
Boolean algebra induces a bounded partial order.
BOTTOM := 0
TOP := 1
----------------------------------------------------------------------
35. BOOLEAN ALGEBRA AS LATTICE
----------------------------------------------------------------------
MAP:
meet := ∧
join := ∨
bottom := 0
top := 1
complement := ¬
THEOREM:
Boolean algebra is a complemented distributive bounded lattice.
----------------------------------------------------------------------
36. ATOMS
----------------------------------------------------------------------
ENTITY Atom a {
condition:
a != 0
AND no x exists such that 0 < x < a
}
RULE ATOM_01:
finite Boolean algebras are atomic.
RULE ATOM_02:
every element of finite Boolean algebra is join of atoms below it.
----------------------------------------------------------------------
37. FINITE BOOLEAN ALGEBRAS
----------------------------------------------------------------------
THEOREM FINITE_BA_01:
finite Boolean algebra has cardinality 2^n
for some nonnegative integer n.
THEOREM FINITE_BA_02:
every finite Boolean algebra is isomorphic to power set algebra
P(X) for some finite X.
----------------------------------------------------------------------
38. POWER SET BOOLEAN ALGEBRA
----------------------------------------------------------------------
ENTITY PowerSetBooleanAlgebra P(X) {
carrier:
power_set(X)
meet:
intersection
join:
union
complement:
relative_complement_in_X
zero:
empty_set
one:
X
}
----------------------------------------------------------------------
39. BOOLEAN HOMOMORPHISMS
----------------------------------------------------------------------
IS_BOOLEAN_HOMOMORPHISM(h:A->B) iff
h(0_A)=0_B
h(1_A)=1_B
h(x∨y)=h(x)∨h(y)
h(x∧y)=h(x)∧h(y)
h(¬x)=¬h(x)
RULE BHOM_01:
preservation of suitable primitive operations may imply preservation
of the remaining derived operations.
----------------------------------------------------------------------
40. BOOLEAN ISOMORPHISM
----------------------------------------------------------------------
IS_BOOLEAN_ISOMORPHISM(h) iff
IS_BOOLEAN_HOMOMORPHISM(h)
AND bijective(h)
RULE BISO_01:
isomorphic Boolean algebras satisfy identical Boolean identities.
----------------------------------------------------------------------
41. IDEALS
----------------------------------------------------------------------
ENTITY BooleanIdeal I {
parent: B
}
IS_IDEAL(I,B) iff
0 in I
downward_closed:
x in I AND y<=x -> y in I
join_closed:
x,y in I -> x∨y in I
----------------------------------------------------------------------
42. FILTERS
----------------------------------------------------------------------
ENTITY BooleanFilter F {
parent: B
}
IS_FILTER(F,B) iff
1 in F
upward_closed:
x in F AND x<=y -> y in F
meet_closed:
x,y in F -> x∧y in F
RULE FILTER_01:
complements exchange ideals and filters.
----------------------------------------------------------------------
43. ULTRAFILTERS
----------------------------------------------------------------------
IS_ULTRAFILTER(U,B) iff
U proper_filter
AND maximal among proper filters
EQUIVALENT_PROPERTY:
for every x in B:
exactly one of x or ¬x lies in U
----------------------------------------------------------------------
44. BOOLEAN RINGS
----------------------------------------------------------------------
MAP BooleanAlgebra -> BooleanRing {
multiplication:
x*y := x∧y
addition:
x+y := x⊕y
zero:
0
}
BOOLEAN_RING_PROPERTY:
x^2=x
THEOREM:
Boolean algebras and Boolean rings are categorically equivalent
under standard constructions.
----------------------------------------------------------------------
45. EXPRESSION PARSING
----------------------------------------------------------------------
PRECEDENCE := [
NOT,
AND,
XOR,
OR
]
RULE PARSE_01:
explicit parentheses override default precedence.
RULE PARSE_02:
repeated NOT associates inward to its operand.
----------------------------------------------------------------------
46. EVALUATION
----------------------------------------------------------------------
PROCEDURE EVALUATE(E,assignment):
substitute Boolean values
evaluate NOT
evaluate AND/NAND
evaluate XOR/XNOR if present
evaluate OR/NOR
RETURN 0 or 1
----------------------------------------------------------------------
47. NORMALISATION
----------------------------------------------------------------------
PROCEDURE NORMALISE_TO_SOP(E):
eliminate implication/equivalence if present
push NOT inward using De Morgan
eliminate double negation
distribute AND over OR
simplify
RETURN SOP
PROCEDURE NORMALISE_TO_POS(E):
eliminate implication/equivalence if present
push NOT inward
distribute OR over AND
simplify
RETURN POS
----------------------------------------------------------------------
48. CANONICALISATION
----------------------------------------------------------------------
PROCEDURE TO_CANONICAL_SOP(E):
build truth table
identify rows output=1
create minterms
OR minterms
RETURN canonical_SOP
PROCEDURE TO_CANONICAL_POS(E):
build truth table
identify rows output=0
create maxterms
AND maxterms
RETURN canonical_POS
----------------------------------------------------------------------
49. SEMANTIC RELATIONSHIPS
----------------------------------------------------------------------
RELATION HAS_VARIABLE(BooleanExpression,BooleanVariable)
RELATION HAS_OPERATOR(BooleanExpression,BooleanOperation)
RELATION DEFINES(BooleanExpression,BooleanFunction)
RELATION HAS_TRUTH_TABLE(BooleanFunction,TruthTable)
RELATION EQUIVALENT_TO(BooleanExpression,BooleanExpression)
RELATION DUAL_OF(BooleanExpression,BooleanExpression)
RELATION SIMPLIFIES_TO(BooleanExpression,BooleanExpression)
RELATION NORMALISES_TO(BooleanExpression,NormalForm)
RELATION HAS_MINTERM(BooleanFunction,Minterm)
RELATION HAS_MAXTERM(BooleanFunction,Maxterm)
----------------------------------------------------------------------
50. SEMANTIC EQUIVALENCE
----------------------------------------------------------------------
SEMANTIC_EQUIVALENCE {
"Boolean addition" ~= OR
"Boolean multiplication" ~= AND
"logical sum" ~= OR
"logical product" ~= AND
"complement" ~= NOT
"negation" ~= NOT
"exclusive OR" ~= XOR
"logical equivalence" ~= XNOR
"product term" ~= conjunction_of_literals
"sum term" ~= disjunction_of_literals
"SOP" ~= SumOfProducts
"POS" ~= ProductOfSums
"canonical SOP" ~= sum_of_minterms
"canonical POS" ~= product_of_maxterms
"truth assignment" ~= variable_to_boolean_mapping
}
----------------------------------------------------------------------
51. QUERY INTERPRETATION
----------------------------------------------------------------------
QUERY_CLASS Q1:
"simplify E"
-> SIMPLIFY_BOOLEAN(E)
QUERY_CLASS Q2:
"are A and B equivalent"
-> VALIDATE_EQUIVALENCE(A,B)
QUERY_CLASS Q3:
"truth table for E"
-> BUILD_TRUTH_TABLE(E)
QUERY_CLASS Q4:
"canonical SOP"
-> TO_CANONICAL_SOP(E)
QUERY_CLASS Q5:
"canonical POS"
-> TO_CANONICAL_POS(E)
QUERY_CLASS Q6:
"dual of E"
-> DUAL_TRANSFORM(E)
QUERY_CLASS Q7:
"implement using NAND"
-> transform using NAND completeness rules
QUERY_CLASS Q8:
"implement using NOR"
-> transform using NOR completeness rules
----------------------------------------------------------------------
52. RECURSIVE REASONING ENGINE
----------------------------------------------------------------------
PROCEDURE BOOLEAN_REASONER(input):
parse variables
parse constants
parse operators
parse grouping
validate expression syntax
classify target
extract requested form
choose valid Boolean laws
apply transformations atomically
preserve equivalence
reduce complexity where possible
validate final expression by:
symbolic equivalence
OR truth-table equivalence
RETURN:
result
derivation
canonical_status
confidence
----------------------------------------------------------------------
53. RECURSIVE TRANSITION
----------------------------------------------------------------------
RECURSIVE_RULE RR_01:
state := E_n
if target form reached:
terminate
identify applicable Boolean identities
choose transformation T satisfying:
BOOLEAN_EQUIVALENT(E_n,T(E_n))
E_(n+1):=T(E_n)
validate local equivalence
recurse(E_(n+1))
TERMINATION_CONDITIONS := {
simplified_fixed_point,
requested_normal_form,
requested_canonical_form,
proof_complete,
counterexample_found,
no_valid_rule
}
----------------------------------------------------------------------
54. ERROR MODEL
----------------------------------------------------------------------
ERROR E_INVALID_BOOLEAN_VALUE
ERROR E_UNKNOWN_VARIABLE
ERROR E_MALFORMED_EXPRESSION
ERROR E_ARITY_MISMATCH
ERROR E_INVALID_DISTRIBUTION
ERROR E_INVALID_DEMORGAN
ERROR E_NON_EQUIVALENT_TRANSFORMATION
ERROR E_CANONICAL_TERM_MISSING_LITERAL
ERROR E_TRUTH_TABLE_ROW_MISMATCH
ERROR E_OPERATOR_PRECEDENCE
ERROR E_LOST_COMPLEMENT
----------------------------------------------------------------------
55. VALIDATION ENGINE
----------------------------------------------------------------------
PROCEDURE VALIDATE_TRANSFORMATION(A,B):
symbolic_result :=
derive_equivalence(A,B)
if symbolic_result=VALID:
return VALID
compare truth tables
if identical:
return VALID
else:
return INVALID with first differing assignment
----------------------------------------------------------------------
56. CONFIDENCE MODEL
----------------------------------------------------------------------
CONFIDENCE {
base := 1.00
deduct 0.10 if operator notation ambiguous
deduct 0.10 if precedence inferred
deduct 0.15 if symbolic proof incomplete
deduct 0.20 if truth-table verification omitted when needed
deduct 0.25 if variable domain unclear
clamp_to_[0,1]
classification:
[0.95,1.00] -> very_high
[0.85,0.95) -> high
[0.70,0.85) -> moderate
[0.50,0.70) -> low
[0.00,0.50) -> insufficient
}
----------------------------------------------------------------------
57. AI CONSUMPTION MODEL
----------------------------------------------------------------------
AI_CONSUMPTION {
read_order := [
domain,
operators,
axioms,
derived_laws,
expressions,
equivalence,
truth_tables,
normal_forms,
canonical_forms,
duality,
simplification,
validation
]
execution_policy := {
preserve_boolean_domain,
preserve_operator_semantics,
preserve_equivalence,
respect_precedence,
distinguish_SOP_from_canonical_SOP,
distinguish_POS_from_canonical_POS,
validate transformations,
use_truth_tables_as_semantic_ground_truth
}
}
----------------------------------------------------------------------
58. UPDATE MODEL
----------------------------------------------------------------------
UPDATE_MODEL {
extensible := true
new_operator_requires:
arity,
truth_function
new_identity_requires:
formal_equivalence_proof
OR exhaustive_truth_validation
new_normal_form_requires:
formation_rules,
equivalence_preservation,
validation_method
conflicts_require:
explicit_versioning
standard_boolean_meaning_has_priority := true
}
----------------------------------------------------------------------
59. SELF-CHECK
----------------------------------------------------------------------
SELF_CHECK {
CHECK all variables Boolean-valued
CHECK operator arities correct
CHECK every transformation equivalence-preserving
CHECK complements applied to correct scope
CHECK De Morgan swaps AND/OR correctly
CHECK canonical minterms contain every variable
CHECK canonical maxterms contain every variable
CHECK truth table has exactly 2^n rows
CHECK simplified result matches original truth table
CHECK dual transformation swaps 0/1 and AND/OR
CHECK final result validated
}
----------------------------------------------------------------------
60. COMPLETION CONDITIONS
----------------------------------------------------------------------
COMPLETE iff {
boolean_domain_defined
AND operators_defined
AND axioms_defined
AND derived_laws_defined
AND expressions_defined
AND functions_defined
AND truth_tables_defined
AND equivalence_defined
AND duality_defined
AND simplification_defined
AND SOP_defined
AND POS_defined
AND canonical_forms_defined
AND NAND_NOR_completeness_defined
AND lattice_interpretation_defined
AND semantic_equivalence_defined
AND recursive_reasoning_defined
AND validation_defined
AND confidence_defined
AND ai_consumption_defined
AND update_model_defined
}
IF NOT COMPLETE:
semantic_status := incomplete_flow
----------------------------------------------------------------------
61. FLOW TERMINATION
----------------------------------------------------------------------
TERMINATE WHEN:
requested Boolean goal achieved
AND result equivalence-validated
OR
requested equivalence disproved by counterexample assignment
OR
expression malformed
OR
no valid transformation remains
FINAL_STATE := {
boolean_result,
equivalent_expression,
derivation,
truth_validation,
normal_form_status,
semantic_status,
confidence
}
} // END FLOW BooleanAlgebraOntology
======================================================================
END FLOW
======================================================================
FLOW STATUS:
Complete
CANONICAL PAGE:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/boolean-algebra-ontology.html
FLOW_HASH_SHA256: 785f39f9f69bec1b4aeb947165107f199859a86842efa884182d4a67644a6886