Algebraic Identity Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the mathematical ontology of algebraic identities. An algebraic identity is an equality between expressions that holds for all values of the variables for which both sides are defined. This record is designed for semantic retrieval, symbolic reasoning, ontology linking, knowledge-graph construction and AI consumption within the Kireth Research Semantic Library.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Algebraic Identity Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Algebra"
 SPECIALISATION = "Symbolic Algebra"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/algebraic-identity-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = AlgebraicIdentity
 SYMBOLIC_FORMS = ["A(x,...)=B(x,...)", "LHS ≡ RHS", "identity in variables"]
 ENTITY_CLASS = UniversalEquality
 PRIMARY_CONTEXT = Algebra
 DEFINITION = "An algebraic identity is an equality between two algebraic expressions that is true for all admissible values of the variables."
 DISTINCTION = "An identity differs from an equation to be solved because an identity is universally valid over its stated domain."
}

SCOPE {
 INCLUDE = [
  AlgebraicIdentity,
  PolynomialIdentity,
  RationalIdentity,
  BinomialIdentity,
  FactorisationIdentity,
  ExpansionIdentity,
  DifferenceOfSquares,
  PerfectSquareIdentity,
  DifferenceOfCubes,
  SumOfCubes,
  Verification,
  Simplification,
  Substitution,
  EquivalentExpressions,
  DomainRestrictions
 ]

 EXCLUDE_AS_PRIMARY = [
  ConditionalEquation,
  NumericalApproximation,
  EmpiricalEquality,
  AccidentalEqualityAtSpecificValues
 ]

 DISAMBIGUATION_RULE =
  "When identity occurs with expressions, variables, expansion, factorisation, simplification, polynomial or rational algebra, interpret it as a universally valid algebraic equality."
}

CORE_CONCEPTS {

 AlgebraicIdentity {
  definition = "An equality valid for every admissible assignment of its variables."
  semantic_role = "Encodes equivalence between symbolic forms."
  truth_status = "Universally true over stated domain."
 }

 EquivalentExpressions {
  definition = "Expressions representing the same value for all admissible variable assignments."
  relation = "A ≡ B"
 }

 PolynomialIdentity {
  definition = "An identity between polynomial expressions."
  property = "If two polynomials over an infinite field agree for all values, their coefficients agree term by term."
 }

 RationalIdentity {
  definition = "An identity involving rational expressions, valid wherever both sides are defined."
  requirement = "Exclude values making any denominator zero."
 }

 DomainRestriction {
  definition = "A condition restricting admissible values so every expression in the identity is defined."
 }

 Verification {
  definition = "Process of proving or checking that two expressions are identically equal."
  methods = [
   Expansion,
   Factorisation,
   Simplification,
   CommonDenominator,
   CoefficientComparison,
   SubstitutionAsCheck
  ]
 }
}

CANONICAL_IDENTITIES {

 DISTRIBUTIVE_LAW = "a(b+c)=ab+ac"

 PERFECT_SQUARE_SUM = "(a+b)^2=a^2+2ab+b^2"

 PERFECT_SQUARE_DIFFERENCE = "(a-b)^2=a^2-2ab+b^2"

 DIFFERENCE_OF_SQUARES = "a^2-b^2=(a-b)(a+b)"

 SUM_OF_CUBES = "a^3+b^3=(a+b)(a^2-ab+b^2)"

 DIFFERENCE_OF_CUBES = "a^3-b^3=(a-b)(a^2+ab+b^2)"

 CUBE_OF_SUM = "(a+b)^3=a^3+3a^2b+3ab^2+b^3"

 CUBE_OF_DIFFERENCE = "(a-b)^3=a^3-3a^2b+3ab^2-b^3"
}

RELATIONS {
 AlgebraicIdentity --asserts_equivalence_between--> AlgebraicExpressions
 AlgebraicIdentity --is_universally_valid_over--> Domain
 AlgebraicIdentity --can_be_verified_by--> Expansion
 AlgebraicIdentity --can_be_verified_by--> Factorisation
 AlgebraicIdentity --can_be_verified_by--> Simplification
 AlgebraicIdentity --can_require--> DomainRestriction
 PolynomialIdentity --is_special_case_of--> AlgebraicIdentity
 RationalIdentity --is_special_case_of--> AlgebraicIdentity
 EquivalentExpressions --are_related_by--> AlgebraicIdentity
 AlgebraicIdentity --supports--> SymbolicSimplification
 AlgebraicIdentity --supports--> Rewriting
 AlgebraicIdentity --supports--> ProofTransformation
}

OPERATORS {
 IS_IDENTITY(A,B,D) :=
  FOR_ALL x in D:
  A(x)==B(x)

 VERIFY_BY_SIMPLIFICATION(A,B) :=
  SIMPLIFY(A-B)==0

 VERIFY_BY_EXPANSION(A,B) :=
  EXPAND(A)==EXPAND(B)

 VERIFY_BY_FACTORIZATION(A,B) :=
  FACTOR(A)==FACTOR(B)

 DOMAIN_OF_IDENTITY(A,B) :=
  INTERSECTION(DOMAIN(A),DOMAIN(B))

 REWRITE_USING_IDENTITY(expression,identity,direction) :=
  SUBSTITUTE_MATCHING_SUBEXPRESSION(expression,identity,direction)

 COEFFICIENT_COMPARE(P,Q) :=
  compare_corresponding_coefficients(EXPAND(P),EXPAND(Q))
}

DEFINITIONS {
 D1 = "An identity is true for all admissible values of its variables."
 D2 = "An equation may be true only for particular values; an identity is universally true over its domain."
 D3 = "Equivalent expressions are connected by an identity."
 D4 = "Polynomial identities may be verified by expansion and coefficient comparison."
 D5 = "Rational identities are valid only where all denominators are nonzero."
 D6 = "An identity may be used in either direction as a rewriting rule."
 D7 = "Expansion and factorisation are inverse-style transformations connected by algebraic identities."
 D8 = "Substitution of sample values can test plausibility but does not by itself prove a universal identity."
}

AXIOMS {
 A1_REFLEXIVITY:
  FOR every expression A
  A ≡ A

 A2_SYMMETRY:
  IF A ≡ B
  THEN B ≡ A

 A3_TRANSITIVITY:
  IF A ≡ B AND B ≡ C
  THEN A ≡ C

 A4_SUBSTITUTION:
  IF A ≡ B
  THEN substituting equal admissible expressions for variables preserves identity

 A5_CONTEXT_REPLACEMENT:
  IF A ≡ B
  THEN any algebraically valid context containing A may replace A by B without changing value

 A6_DOMAIN_VALIDITY:
  Identity claims apply only where every participating expression is defined
}

REASONING {

 R1_IDENTITY_TEST {
  INPUT = [expression A, expression B]
  DETERMINE = common_domain
  COMPUTE = simplify(A-B)
  IF result==0 over common_domain
   RETURN Identity
  ELSE
   RETURN NotIdentityOrRequiresFurtherAnalysis
 }

 R2_EXPANSION_TEST {
  INPUT = [A,B]
  COMPUTE = [expand(A),expand(B)]
  IF canonical_forms_equal
   RETURN Identity
 }

 R3_FACTORIZATION_TEST {
  INPUT = [A,B]
  FACTOR_OR_EXPAND = both_sides_to_common_form
  COMPARE = resulting_forms
  RETURN = IdentityStatus
 }

 R4_POLYNOMIAL_COEFFICIENT_TEST {
  INPUT = polynomial expressions P,Q
  EXPAND = standard_polynomial_form
  COMPARE = coefficients
  IF all_coefficients_equal
   RETURN PolynomialIdentity
  ELSE
   RETURN NotPolynomialIdentity
 }

 R5_RATIONAL_IDENTITY_TEST {
  INPUT = rational expressions R1,R2
  DOMAIN = exclude_all_denominator_zeros
  BRING_TO_COMMON_DENOMINATOR
  COMPARE_NUMERATORS_ON_DOMAIN
  RETURN = RationalIdentityStatus
 }

 R6_REWRITE {
  INPUT = [expression E, known identity I]
  IDENTIFY = matching_subexpression
  REPLACE = equivalent_side
  RETURN = equivalent_expression
 }
}

CONSTRAINTS {
 C1 = "Universal validity must be distinguished from truth at selected sample values."
 C2 = "Domain restrictions must be preserved when denominators, radicals or other restricted operations occur."
 C3 = "An algebraic identity cannot be disproved or proved solely by a finite set of substitutions unless a theorem justifies finite verification."
 C4 = "Rewriting must preserve equivalence and all domain conditions."
 C5 = "Polynomial coefficient comparison assumes expressions are interpreted in a compatible polynomial setting."
 C6 = "Do not confuse identity element with algebraic identity; these are distinct concepts."
 C7 = "Do not confuse identity function with algebraic identity."
}

SEMANTIC_EQUIVALENCE {
 "AlgebraicIdentity" <=> "UniversalAlgebraicEquality"
 "EquivalentExpressions" <=> "ExpressionsEqualForAllAdmissibleValues"
 "A ≡ B" <=> "A and B are identically equal"
 "FactorisationIdentity" <=> "ExpansionIdentity in reverse orientation"
}

VALIDATION {
 V1 = "a(b+c)=ab+ac is an identity."
 V2 = "(a+b)^2=a^2+2ab+b^2 is an identity."
 V3 = "a^2-b^2=(a-b)(a+b) is an identity."
 V4 = "An equality true only for selected values is not necessarily an identity."
 V5 = "Rational identities preserve denominator restrictions."
 V6 = "Equivalent expressions may replace each other in valid algebraic contexts."
 V7 = "Polynomial identities can be checked by coefficient equality after expansion."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 IDENTITY_DEFINITION = 0.99
 UNIVERSAL_VALIDITY = 0.99
 DOMAIN_RESTRICTION = 0.99
 POLYNOMIAL_COEFFICIENT_REASONING = 0.99
 REWRITING_RELATION = 0.99
 SAMPLE_SUBSTITUTION_LIMITATION = 0.99

 POLICY =
  "Reduce confidence when the intended domain, algebraic structure or expression semantics are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  SymbolicAlgebraReasoning,
  ExpressionSimplification,
  IdentityVerification,
  Rewriting,
  ProofSupport,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "algebraic identity" -> AlgebraicIdentity
  "identity" -> AlgebraicIdentity WHEN symbolic_algebra_context
  "identically equal" -> AlgebraicIdentity
  "equivalent expressions" -> EquivalentExpressions
  "polynomial identity" -> PolynomialIdentity
  "rational identity" -> RationalIdentity
 }

 INTERPRETATION_ORDER = [
  identify_expressions,
  identify_variables,
  determine_common_domain,
  distinguish_identity_from_equation,
  simplify_difference,
  expand_or_factor_when_required,
  compare_coefficients_when_polynomial,
  preserve_domain_restrictions,
  establish_identity_status,
  expose_rewrite_rules,
  return_semantic_result
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("algebraic identity")
  THEN activate(AlgebraicIdentityOntology)

 E2:
  IF query_mentions("identity")
  AND symbolic_algebra_context
  THEN activate(AlgebraicIdentityOntology)

 E3:
  IF request=="verify identity"
  THEN determine_common_domain
  AND simplify(lhs-rhs)

 E4:
  IF polynomial_context
  THEN permit(expansion_and_coefficient_comparison)

 E5:
  IF rational_expression_context
  THEN calculate_domain_restrictions
  BEFORE identity_verification

 E6:
  IF known_identity_matches_subexpression
  THEN permit_equivalent_rewrite

 E7:
  IF only_sample_substitutions_available
  THEN mark_as("supporting check, not universal proof")
}

RECURSION {
 ENTRY = AlgebraicIdentity

 EXPAND(AlgebraicIdentity) -> [
  AlgebraicExpression,
  EquivalentExpression,
  Equation,
  Polynomial,
  RationalExpression,
  Expansion,
  Factorisation,
  Simplification,
  Domain
 ]

 EXPAND(PolynomialIdentity) -> [
  Polynomial,
  Coefficient,
  Monomial,
  Expansion,
  CanonicalForm
 ]

 EXPAND(RationalIdentity) -> [
  RationalExpression,
  Denominator,
  DomainRestriction,
  CommonDenominator
 ]

 EXPAND(Rewriting) -> [
  PatternMatching,
  Substitution,
  EquivalentExpression,
  Simplification
 ]

 STOP_CONDITION =
  "Stop when identity status, rewrite equivalence or requested canonical form is resolved with sufficient confidence."
}

ROUTING {
 PARENT_ONTOLOGY = "Algebra Ontology"

 IMMEDIATE_CONTEXTS = [
  "Algebraic Expression Ontology",
  "Equation Ontology",
  "Polynomial Ontology"
 ]

 RELATED_ONTOLOGIES = [
  "Algebraic Expression Ontology",
  "Equation Ontology",
  "Polynomial Ontology",
  "Monomial Ontology",
  "Rational Expression Ontology",
  "Linear Equation Ontology"
 ]

 ROUTE_RULES = [
  "Algebraic Identity -> Algebraic Expression for symbolic structure",
  "Algebraic Identity -> Polynomial for coefficient-based verification",
  "Algebraic Identity -> Rational Expression for denominator-domain reasoning",
  "Algebraic Identity -> Equation for identity-versus-equation distinction",
  "Algebraic Identity -> Factorisation or Expansion for rewrite reasoning"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible identities, relations or operators"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve universal-validity semantics.",
  "Preserve distinction between identity and equation.",
  "Preserve domain restrictions.",
  "Preserve equivalence-based rewriting.",
  "Preserve coefficient-comparison reasoning for polynomial identities.",
  "Explicitly distinguish algebraic identity from identity element and identity function."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "An algebraic identity is an equality between algebraic expressions that holds for all admissible values of the variables."

 SYMBOLIC_SUMMARY =
  "A(x,...) ≡ B(x,...)"

 VERIFICATION_SUMMARY =
  "A ≡ B when simplify(A-B)=0 over the common domain."

 POLYNOMIAL_SUMMARY =
  "Polynomial identities can be verified by equality of corresponding coefficients after expansion."

 RATIONAL_SUMMARY =
  "Rational identities are valid only on the common domain where all denominators are nonzero."

 REWRITE_SUMMARY =
  "A known identity may be used in either direction as an equivalence-preserving rewrite rule."
}

FLOW {
 INPUT
 -> detect_identity_context
 -> identify_left_expression
 -> identify_right_expression
 -> identify_variables
 -> determine_common_domain
 -> distinguish_identity_from_conditional_equation
 -> simplify_difference
 -> expand_or_factor_when_required
 -> compare_polynomial_coefficients_when_applicable
 -> enforce_rational_domain_restrictions_when_applicable
 -> establish_universal_equality
 -> expose_equivalent_rewrite
 -> link_related_ontologies
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "An algebraic identity is a universally valid equality between algebraic expressions. It records that two symbolic forms are equivalent throughout their common domain and can therefore be substituted for one another in valid algebraic reasoning. Identities underpin expansion, factorisation, simplification and symbolic rewriting, while differing fundamentally from equations that are true only for particular variable values."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-ALGEBRA-ALGEBRAIC-IDENTITY-ONTOLOGY-V1"
}

}

END_FLOW