Simplification Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the mathematical ontology of algebraic simplification. Simplification transforms an algebraic expression into an equivalent form that is shorter, clearer, more canonical, or easier to reason with, while preserving value over the valid domain. 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 = "Simplification Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Algebra"
 SPECIALISATION = "Symbolic Algebra"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/simplification-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = Simplification
 SYMBOLIC_FORMS = ["SIMPLIFY(E)", "E ≡ S", "canonical form"]
 ENTITY_CLASS = AlgebraicRewrite
 PRIMARY_CONTEXT = Algebra
 DEFINITION = "Algebraic simplification is the process of rewriting an expression into an equivalent form that is structurally simpler or more useful while preserving its value over the valid domain."
 EQUIVALENCE_REQUIREMENT = "Original and simplified expressions must remain equivalent wherever both are defined."
}

SCOPE {
 INCLUDE = [
  Simplification,
  EquivalentExpression,
  CollectionOfLikeTerms,
  Cancellation,
  CommonFactorReduction,
  FractionSimplification,
  RationalExpressionSimplification,
  ExponentSimplification,
  RadicalSimplification,
  AlgebraicIdentity,
  Expansion,
  Factorisation,
  CanonicalForm,
  DomainRestriction
 ]

 EXCLUDE_AS_PRIMARY = [
  NumericalApproximation,
  FloatingPointRounding,
  HeuristicCompression,
  NonEquivalentRewriting
 ]

 DISAMBIGUATION_RULE =
  "When simplification occurs with algebraic expressions, fractions, factors, powers, radicals, polynomials, identities or canonical forms, interpret it as equivalence-preserving symbolic algebraic simplification."
}

CORE_CONCEPTS {

 Simplification {
  definition = "Equivalent transformation of an expression into a simpler or more canonical representation."
  goals = [
   ReducedRedundancy,
   ClearerStructure,
   CanonicalRepresentation,
   EasierEvaluation,
   EasierComparison,
   EasierFurtherReasoning
  ]
 }

 EquivalentExpression {
  definition = "An expression having the same value as another expression over the relevant domain."
  relation = "E ≡ S"
 }

 LikeTerms {
  definition = "Terms with matching variable and exponent structure that can be combined by adding coefficients."
  example = "3x+5x=8x"
 }

 Cancellation {
  definition = "Removal of a common nonzero factor from numerator and denominator or equivalent multiplicative structures."
  requirement = "Domain restrictions must be preserved."
 }

 RationalSimplification {
  definition = "Reduction of a rational expression by factoring numerator and denominator and cancelling common nonzero factors."
 }

 ExponentSimplification {
  definition = "Application of valid exponent laws to produce an equivalent form."
 }

 RadicalSimplification {
  definition = "Equivalent rewriting of radical expressions, subject to domain and sign conditions."
 }

 CanonicalForm {
  definition = "A conventional normal form selected to make equivalent expressions easier to compare or process."
 }
}

RELATIONS {
 Simplification --rewrites--> AlgebraicExpression
 Simplification --preserves--> AlgebraicEquivalence
 Simplification --can_use--> AlgebraicIdentity
 Simplification --can_use--> Expansion
 Simplification --can_use--> Factorisation
 Simplification --can_use--> Cancellation
 Simplification --can_use--> CollectionOfLikeTerms
 Simplification --can_produce--> CanonicalForm
 Simplification --must_preserve--> DomainRestrictions
 RationalExpressionSimplification --depends_on--> Factorisation
 Cancellation --requires--> NonzeroFactorCondition
}

OPERATORS {
 SIMPLIFY(E) :=
  apply_equivalence_preserving_rewrite_rules_until_target_normal_form

 COLLECT_LIKE_TERMS(E) :=
  combine_coefficients_of_matching_term_signatures

 CANCEL_COMMON_FACTOR(N,D,F) :=
  (N/F)/(D/F) WHEN F!=0

 REDUCE_RATIONAL_EXPRESSION(R) :=
  factor_numerator_and_denominator
  then_cancel_common_nonzero_factors

 SIMPLIFY_EXPONENTS(E) :=
  apply_valid_exponent_laws(E)

 SIMPLIFY_RADICALS(E) :=
  apply_valid_radical_laws_with_domain_checks(E)

 CANONICALISE(E) :=
  convert_to_selected_normal_form

 VERIFY_SIMPLIFICATION(E,S) :=
  SIMPLIFY(E-S)==0 over common_valid_domain
}

DEFINITIONS {
 D1 = "Simplification preserves algebraic equivalence."
 D2 = "Like terms may be combined by adding or subtracting coefficients."
 D3 = "Common factors may be cancelled only where the cancelled factor is nonzero."
 D4 = "Factoring may expose cancellable structure."
 D5 = "Expansion may expose like terms or canonical polynomial structure."
 D6 = "A simplified form is not necessarily unique unless a normal-form convention is specified."
 D7 = "Domain restrictions must be retained even when factors cancel syntactically."
 D8 = "Simpler means more suitable under a chosen objective, not universally shortest in every representation."
}

AXIOMS {
 A1_EQUIVALENCE:
  IF E simplifies to S
  THEN E ≡ S over the preserved domain

 A2_LIKE_TERMS:
  "a*x + b*x = (a+b)*x"

 A3_CANCELLATION:
  IF F!=0
  THEN "(A*F)/(B*F)=A/B" wherever all expressions are defined

 A4_IDENTITY_REWRITE:
  IF A ≡ B
  THEN replacing A by B in a valid algebraic context preserves equivalence

 A5_DOMAIN_PRESERVATION:
  Simplification must not silently enlarge the original valid domain

 A6_CANONICALISATION:
  Equivalent expressions may be mapped to the same selected normal form
}

REASONING {

 R1_GENERAL_SIMPLIFICATION {
  INPUT = expression E
  IDENTIFY = expression_type
  APPLY = local_equivalence_rules
  REMOVE = redundant_structure
  COLLECT = like_terms
  NORMALISE = selected_form
  RETURN = simplified_expression
 }

 R2_POLYNOMIAL {
  INPUT = polynomial expression E
  EXPAND = when needed
  COLLECT = like_terms
  ORDER = monomials
  RETURN = canonical_polynomial_form
 }

 R3_RATIONAL {
  INPUT = rational expression N/D
  RECORD = denominator_domain_restrictions
  FACTOR = [N,D]
  IDENTIFY = common_factors
  CANCEL = common_nonzero_factors
  PRESERVE = original_domain_restrictions
  RETURN = reduced_rational_expression
 }

 R4_EXPONENTS {
  INPUT = exponential algebraic expression
  APPLY = valid_product_quotient_power_rules
  CHECK = exponent_domain_conditions
  RETURN = simplified_power_expression
 }

 R5_RADICALS {
  INPUT = radical expression
  IDENTIFY = perfect_power_factors
  EXTRACT = valid_factors
  CHECK = real_or_complex_domain_conditions
  RETURN = simplified_radical_form
 }

 R6_CHOOSE_DIRECTION {
  INPUT = expression E and target_reasoning_goal
  IF goal=="collect coefficients"
   THEN prefer_expansion
  IF goal=="cancel factors"
   THEN prefer_factorisation
  IF goal=="solve product equation"
   THEN prefer_factorisation
  RETURN = strategy
 }

 R7_VERIFY {
  INPUT = [original E, proposed simplified S]
  DETERMINE = common_domain
  TEST = symbolic_equivalence
  RETURN = SimplificationValidity
 }
}

CONSTRAINTS {
 C1 = "Simplification must preserve algebraic value over the valid domain."
 C2 = "Cancelled factors must be nonzero."
 C3 = "Original domain exclusions remain relevant after cancellation."
 C4 = "Like terms can be combined only when their symbolic variable structure matches."
 C5 = "Exponent laws may require restrictions depending on the scalar domain."
 C6 = "Radical simplification may require sign or domain conditions."
 C7 = "A shorter expression is not valid simplification if equivalence is lost."
 C8 = "Do not treat numerical approximation as exact algebraic simplification."
}

SEMANTIC_EQUIVALENCE {
 "Simplification" <=> "EquivalencePreservingAlgebraicRewrite"
 "ReducedForm" <=> "SimplifiedEquivalentExpression"
 "CanonicalForm" <=> "SelectedNormalRepresentation"
 "Cancellation" <=> "RemovalOfCommonNonzeroFactor"
}

VALIDATION {
 V1 = "3x+5x=8x is valid simplification."
 V2 = "x(x+1)/x = x+1 only under the inherited restriction x!=0."
 V3 = "(x^2-1)/(x-1)=x+1 with original restriction x!=1."
 V4 = "Collecting like terms preserves equivalence."
 V5 = "Factoring and cancellation may simplify rational expressions."
 V6 = "Simplification must preserve original domain restrictions."
 V7 = "Equivalent expressions need not have identical syntax."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 SIMPLIFICATION_DEFINITION = 0.99
 EQUIVALENCE_PRESERVATION = 0.99
 CANCELLATION_RULE = 0.99
 DOMAIN_PRESERVATION = 0.99
 LIKE_TERM_REASONING = 0.99
 CANONICAL_FORM_REASONING = 0.98

 POLICY =
  "Reduce confidence when the intended domain, normal form, or simplification objective is underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  SymbolicAlgebraReasoning,
  ExpressionNormalisation,
  RationalExpressionReasoning,
  EquationManipulation,
  IdentityVerification,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "simplify" -> Simplification
  "simplification" -> Simplification
  "reduce expression" -> Simplification
  "collect like terms" -> CollectionOfLikeTerms
  "cancel common factors" -> Cancellation
  "simplest form" -> SimplifiedForm
  "canonical form" -> CanonicalForm
 }

 INTERPRETATION_ORDER = [
  identify_expression_type,
  identify_domain,
  identify_simplification_goal,
  detect_like_terms,
  detect_common_factors,
  decide_expansion_or_factorisation_direction,
  apply_valid_rewrite_rules,
  preserve_domain_restrictions,
  canonicalise_when_requested,
  verify_equivalence,
  return_semantic_result
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("simplify")
  OR query_mentions("simplification")
  AND algebraic_context
  THEN activate(SimplificationOntology)

 E2:
  IF like_terms_present
  THEN combine_coefficients

 E3:
  IF rational_expression_context
  THEN record_denominator_restrictions
  BEFORE cancellation

 E4:
  IF cancellation_requires_factorisation
  THEN factor_first

 E5:
  IF polynomial_canonical_form_requested
  THEN expand_if_needed
  AND collect_like_terms
  AND order_terms

 E6:
  IF proposed_rewrite_changes_domain
  THEN preserve_original_domain_metadata

 E7:
  IF request=="verify simplification"
  THEN test_symbolic_equivalence_over_common_domain
}

RECURSION {
 ENTRY = Simplification

 EXPAND(Simplification) -> [
  AlgebraicExpression,
  EquivalentExpression,
  AlgebraicIdentity,
  Expansion,
  Factorisation,
  RationalExpression,
  Polynomial,
  Monomial,
  DomainRestriction,
  CanonicalForm
 ]

 EXPAND(RationalSimplification) -> [
  Numerator,
  Denominator,
  Factorisation,
  CommonFactor,
  Cancellation,
  DomainRestriction
 ]

 EXPAND(PolynomialSimplification) -> [
  Expansion,
  Monomial,
  LikeTerm,
  Coefficient,
  CanonicalPolynomialForm
 ]

 EXPAND(CanonicalForm) -> [
  NormalisationRule,
  Ordering,
  EquivalentExpression
 ]

 STOP_CONDITION =
  "Stop when the requested simplification objective is satisfied, equivalence is verified, and domain restrictions have been preserved."
}

ROUTING {
 PARENT_ONTOLOGY = "Algebra Ontology"

 IMMEDIATE_CONTEXTS = [
  "Algebraic Expression Ontology",
  "Algebraic Identity Ontology",
  "Factorisation Ontology",
  "Expansion Ontology"
 ]

 RELATED_ONTOLOGIES = [
  "Algebraic Expression Ontology",
  "Polynomial Ontology",
  "Monomial Ontology",
  "Rational Expression Ontology",
  "Equation Ontology",
  "Algebraic Identity Ontology",
  "Factorisation Ontology",
  "Expansion Ontology"
 ]

 ROUTE_RULES = [
  "Simplification -> Algebraic Expression for symbolic structure",
  "Simplification -> Factorisation when common-factor exposure is useful",
  "Simplification -> Expansion when like-term collection is useful",
  "Simplification -> Rational Expression for cancellation and domain reasoning",
  "Simplification -> Algebraic Identity for equivalence-preserving rewrites",
  "Simplification -> Polynomial for canonical polynomial form"
 ]
}

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

 RULES = [
  "Preserve equivalence as the primary correctness criterion.",
  "Preserve original domain restrictions.",
  "Preserve nonzero requirements for cancellation.",
  "Preserve context-dependent choice between expansion and factorisation.",
  "Preserve distinction between exact simplification and approximation.",
  "Preserve explicit normal-form semantics when canonicalisation is requested."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Algebraic simplification rewrites an expression into an equivalent form that is clearer, more compact, more canonical, or more useful for further reasoning."

 SYMBOLIC_SUMMARY =
  "E ≡ SIMPLIFY(E)"

 CANCELLATION_SUMMARY =
  "(A*F)/(B*F)=A/B where F!=0, with original domain restrictions retained."

 POLYNOMIAL_SUMMARY =
  "Polynomial simplification commonly expands when needed, collects like terms, and orders terms canonically."

 RATIONAL_SUMMARY =
  "Rational simplification factors numerator and denominator, cancels common nonzero factors, and preserves excluded values."

 VERIFICATION_SUMMARY =
  "A proposed simplification is valid when it is algebraically equivalent to the original over the preserved domain."
}

FLOW {
 INPUT
 -> detect_simplification_context
 -> identify_expression
 -> identify_domain
 -> identify_target_normal_form_or_goal
 -> detect_like_terms
 -> detect_common_factors
 -> choose_expansion_factorisation_or_direct_rewrite
 -> apply_equivalence_preserving_rules
 -> perform_cancellation_with_nonzero_checks
 -> collect_like_terms
 -> canonicalise_when_requested
 -> preserve_original_domain_restrictions
 -> verify_equivalence
 -> link_related_ontologies
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "Algebraic simplification transforms an expression into an equivalent form that is easier to interpret, compare, evaluate or manipulate. It may use expansion, factorisation, collection of like terms, cancellation and algebraic identities, but it must preserve both algebraic value and relevant domain restrictions. The most useful simplified form depends on the intended reasoning goal."
}

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

}

END_FLOW