Expression Simplification Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Expression Simplification Ontology within the Kireth Research Semantic Library. Expression simplification concerns the exact transformation of symbolic mathematical expressions into forms that are mathematically equivalent but structurally reduced, more canonical, easier to interpret, easier to compare, or computationally more efficient. This ontology supports algebraic simplification, rational cancellation, common-factor extraction, collection of like terms, trigonometric and logarithmic identities, radical and power simplification, assumptions, canonical forms, rewrite systems, expression complexity, branch conditions, verification and reproducibility.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Expression Simplification Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Symbolic Computation / Expression Simplification"
 CANONICAL_PAGE = "https://kirethframeworkold.co.uk/books/semantic-library/ai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/symbolic-computation/expression-simplification-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = ExpressionSimplification
 ENTITY_CLASS = SemanticPreservingExpressionReductionFramework
 PRIMARY_CONTEXT = SymbolicComputation
 DEFINITION = "Expression simplification is the transformation of a symbolic mathematical expression into an equivalent form that is reduced, canonicalised, easier to evaluate, compare or interpret under declared assumptions."
 SYMBOLIC_FORMS = [
  "simplify(expr) -> expr'",
  "expr = expr' under assumptions A",
  "(x^2-1)/(x-1) -> x+1 where x != 1",
  "a*x+b*x -> (a+b)*x"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for algebraic reduction, canonicalisation, identity application, cancellation, collection, assumption-aware rewriting, complexity reduction and validation."
}

SCOPE {
 INCLUDE = [
  ExpressionSimplification,Simplification,
  SymbolicSimplification,AlgebraicSimplification,
  RationalSimplification,PolynomialSimplification,
  TrigonometricSimplification,LogarithmicSimplification,
  ExponentialSimplification,RadicalSimplification,
  PowerSimplification,PiecewiseSimplification,
  BooleanSimplificationRelationship,
  MatrixExpressionSimplificationRelationship,
  TensorExpressionSimplificationRelationship,
  SymbolicExpression,MathematicalExpression,
  AlgebraicExpression,RationalExpression,
  PolynomialExpression,TrigonometricExpression,
  LogarithmicExpression,ExponentialExpression,
  RadicalExpression,PowerExpression,
  PiecewiseExpression,ConditionalExpression,
  ExpressionTree,AbstractSyntaxTree,AST,
  DirectedAcyclicExpressionGraphRelationship,
  Symbol,Variable,Constant,Parameter,Coefficient,
  Term,Factor,Monomial,Polynomial,
  Numerator,Denominator,
  Operator,Operand,Function,
  Addition,Subtraction,Multiplication,Division,
  Exponentiation,Negation,
  StructuralEquality,SyntacticEquality,
  MathematicalEquality,MathematicalEquivalence,
  AlgebraicEquivalence,FunctionalEquivalence,
  CanonicalForm,NormalForm,
  Canonicalisation,Normalisation,
  ReducedForm,MinimalFormRelationship,
  ExpandedForm,FactoredForm,
  HornerFormRelationship,
  PolynomialNormalForm,
  RationalNormalForm,
  CommonDenominator,
  LowestTerms,
  LikeTerm,CombineLikeTerms,
  CollectTerms,CoefficientCollection,
  CommonFactor,CommonFactorExtraction,
  Cancellation,CancellationRule,
  FractionReduction,
  RationalisationRelationship,
  DenominatorRationalisationRelationship,
  PolynomialGCD,
  FactorCancellation,
  SignNormalisation,
  PowerCombination,
  ProductOfPowers,
  PowerOfProduct,
  PowerOfPower,
  ExponentReduction,
  LogarithmIdentity,
  LogProductRuleRelationship,
  LogQuotientRuleRelationship,
  LogPowerRuleRelationship,
  ExponentialIdentity,
  TrigonometricIdentity,
  PythagoreanIdentity,
  AngleAdditionIdentityRelationship,
  DoubleAngleIdentityRelationship,
  ReciprocalIdentityRelationship,
  QuotientIdentityRelationship,
  RadicalIdentity,
  RootSimplification,
  SquareRootSimplification,
  PerfectPowerExtraction,
  AbsoluteValueSimplification,
  SignAnalysis,
  Domain,Assumption,AssumptionContext,
  RealAssumption,ComplexAssumption,
  IntegerAssumption,PositiveAssumption,
  NonnegativeAssumption,NonzeroAssumption,
  OrderingAssumption,
  BranchCondition,PrincipalBranch,
  BranchCutRelationship,
  PiecewiseCondition,
  RewriteRule,RewriteSystem,
  TransformationRule,
  PatternMatching,WildcardPattern,
  RuleApplication,
  ConditionalRewrite,
  RulePriority,
  RewriteStrategy,
  BottomUpRewrite,TopDownRewrite,
  FixedPointSimplification,
  LocalSimplification,
  GlobalSimplification,
  ContextSensitiveSimplification,
  AssumptionAwareSimplification,
  DomainAwareSimplification,
  ConstantFolding,
  AlgebraicConstantEvaluation,
  IdentityElimination,
  ZeroElimination,
  OneElimination,
  DoubleNegationEliminationRelationship,
  CommonSubexpression,
  CommonSubexpressionEliminationRelationship,
  ExpressionSharingRelationship,
  Memoisation,
  ExpressionHash,
  HashConsingRelationship,
  ExpressionSize,
  TreeSize,TreeDepth,
  OperationCount,
  ArithmeticOperationCount,
  ExpressionComplexity,
  ComplexityMeasure,
  CostFunction,
  SimplificationCost,
  EvaluationCost,
  ExpressionSwell,
  IntermediateExpressionGrowth,
  SimplificationHeuristic,
  HeuristicCostFunction,
  CanonicalOrdering,
  TermOrdering,
  MonomialOrdering,
  LexicographicOrder,
  GradedLexicographicOrder,
  SemanticPreservation,
  EquivalencePreservation,
  SideCondition,
  DomainRestriction,
  ExcludedValue,
  SingularPoint,
  UndefinedPoint,
  RemovableSingularityRelationship,
  SimplifyUnderAssumptions,
  GenericSimplify,
  FullSimplifyRelationship,
  TargetedSimplify,
  ExpandThenSimplifyRelationship,
  FactorThenSimplifyRelationship,
  RationalTogetherRelationship,
  CancelRelationship,
  CollectRelationship,
  ApartRelationship,
  TrigSimplifyRelationship,
  PowerExpandRelationship,
  ExactArithmetic,
  RationalArithmetic,
  AlgebraicNumberRelationship,
  SymbolicAlgebra,
  SymbolicMathematics,
  SymbolicComputation,
  ComputerAlgebraSystem,CAS,
  SymbolicDifferentiation,
  SymbolicIntegration,
  EquationSolvingRelationship,
  Verification,
  IdentityCheck,
  SubstituteAndCheck,
  ExactResidual,
  RandomisedIdentityTestingRelationship,
  NumericSpotCheck,
  ReferenceExpression,
  KnownIdentity,
  RegressionTest,
  Benchmark,
  Reproducibility,
  Provenance,
  RuleSetVersion,
  CASVersion,
  AlgorithmVersion,
  ImplementationVersion
 ]
 EXCLUDE_AS_PRIMARY = [
  ExpansionWhenExpressionGrowthRatherThanReductionIsPrimary,
  FactorisationWhenFactorStructureIsPrimaryRatherThanSimplification,
  NumericApproximationWithoutSymbolicEquivalence,
  CompilerOptimisationWithoutMathematicalExpressionSemantics
 ]
 DISAMBIGUATION_RULE = "When a symbolic mathematical expression is transformed into an equivalent but simpler, more canonical or computationally favourable form, interpret the context as expression simplification."
}

CORE_CONCEPTS {
 ExpressionSimplification = "Equivalence-preserving reduction of symbolic mathematical expressions."
 CanonicalForm = "Standardised expression representation chosen for comparison or computation."
 RewriteRule = "Pattern-directed transformation preserving declared semantics."
 Assumption = "Contextual condition required for some simplification rules."
 Cancellation = "Removal of common factors under valid nonzero conditions."
 CombineLikeTerms = "Aggregation of terms sharing the same symbolic factor."
 ComplexityMeasure = "Criterion used to compare candidate simplified forms."
 SemanticPreservation = "Requirement that simplification preserve mathematical meaning under declared conditions."
}

RELATIONS {
 ExpressionSimplification --is_child_of--> SymbolicComputation
 ExpressionSimplification --uses--> RewriteRules
 ExpressionSimplification --preserves--> MathematicalEquivalence
 Canonicalisation --produces--> CanonicalForm
 Assumption --enables--> ConditionalRewrite
 CombineLikeTerms --reduces--> TermCount
 CommonFactorExtraction --can_reduce--> ExpressionComplexity
 Cancellation --requires--> NonzeroCondition
 PolynomialGCD --supports--> RationalSimplification
 TrigonometricIdentity --supports--> TrigonometricSimplification
 LogarithmIdentity --supports--> LogarithmicSimplification
 ComplexityMeasure --guides--> SimplificationChoice
 Verification --checks--> SemanticPreservation
}

OPERATORS {
 SIMPLIFY(expr,A) := equivalent_reduced_form(expr,A)
 CANONICALISE(expr,domain) := canonical_form(expr,domain)
 COLLECT(expr,var) := collect_like_terms(expr,var)
 CANCEL(num,den,A) := cancel_common_factors(num,den,A)
 FACTOR_COMMON(expr) := extract_common_factor(expr)
 REDUCE_RATIONAL(expr,A) := lowest_terms(expr,A)
 TRIG_SIMPLIFY(expr,A) := apply_valid_trigonometric_identities(expr,A)
 LOG_SIMPLIFY(expr,A) := apply_valid_logarithmic_identities(expr,A)
 COST(expr) := simplification_complexity_measure(expr)
}

AXIOMS {
 A1 = "Simplification must preserve mathematical semantics under declared assumptions."
 A2 = "Syntactic brevity and mathematical simplicity are distinct."
 A3 = "No single simplest form exists for every expression and purpose."
 A4 = "Canonical forms depend on domain, ordering and simplification policy."
 A5 = "Cancellation can introduce excluded-value conditions."
 A6 = "Branch-sensitive functions require domain-aware simplification."
 A7 = "A simplification step may increase local expression size while reducing global complexity."
 A8 = "Expression-simplification results require explicit assumptions, rules, complexity criteria and verification semantics."
}

REASONING {
 R1_CONTEXT = identify(expression_type,domain,assumptions,target_form,usage_context_and_cost_metric)
 R2_PARSE = construct_expression_tree_or_DAG)
 R3_NORMALISE = standardise_operator_order_constants_signs_and_term_structure)
 R4_LOCAL = apply_safe_local_identity_zero_one_constant_and_like_term_rules)
 R5_ALGEBRA = apply_collection_factor_cancellation_rational_polynomial_or_function_specific_rules)
 R6_ASSUMPTIONS = apply_conditional_rules_only_when_side_conditions_are_satisfied)
 R7_CANDIDATES = generate_alternative_equivalent_forms_when_useful)
 R8_COST = compare_candidates_by_size_depth_operation_count_or_target_specific_cost)
 R9_VERIFY = confirm_equivalence_and_preserve_domain_restrictions)
 R10_REPRODUCE = document_assumptions_rule_set_cost_policy_CAS_and_versions)
}

CONSTRAINTS {
 C1 = "Cancelling a factor can lose excluded-domain information if conditions are not preserved."
 C2 = "Power simplification over complex values can be invalid without branch assumptions."
 C3 = "Logarithmic combination rules can require positivity or branch restrictions."
 C4 = "Radical simplification can require sign assumptions."
 C5 = "Factored form can be simpler for solving while expanded form can be simpler for coefficient extraction."
 C6 = "Trigonometric expressions can have many equivalent forms with no universal minimum."
 C7 = "Aggressive rewriting can create loops without a terminating strategy."
 C8 = "A shorter expression can be numerically less stable."
 C9 = "Expression complexity is task dependent."
 C10 = "Numeric agreement at sample points does not prove symbolic equivalence."
}

SEMANTIC_EQUIVALENCE {
 "ExpressionSimplification" <=> "SymbolicSimplification"
 "Canonicalisation" <=> "Canonicalization"
 "ComputerAlgebraSystem" <=> "CAS"
 "AbstractSyntaxTree" <=> "AST"
 "CombineLikeTerms" <=> "CollectLikeTerms"
}

VALIDATION {
 V1 = "Expression domain is documented."
 V2 = "Assumptions and excluded values are documented."
 V3 = "Each conditional rewrite records its side conditions."
 V4 = "Cancellation preserves denominator restrictions."
 V5 = "Canonicalisation policy is documented."
 V6 = "Simplified and original expressions are checked for exact equivalence where feasible."
 V7 = "Piecewise and branch-sensitive transformations preserve cases."
 V8 = "Numeric spot checks may supplement but not replace exact verification."
 V9 = "Task-specific simplification objectives are documented where relevant."
 V10 = "Results are reproducible under documented rule set, cost policy, CAS and algorithm versions."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 EXPRESSION_SIMPLIFICATION_DEFINITION = 0.99
 ALGEBRAIC_SIMPLIFICATION_REASONING = 0.99
 RATIONAL_SIMPLIFICATION_REASONING = 0.99
 TRIGONOMETRIC_SIMPLIFICATION_REASONING = 0.98
 LOGARITHMIC_SIMPLIFICATION_REASONING = 0.98
 BRANCH_REASONING = 0.98
 CANONICALISATION_REASONING = 0.99
 POLICY = "Reduce confidence when domain, assumptions, excluded values, branch conditions, target form or simplification cost policy are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,ExpressionSimplificationReasoning,
  CanonicalFormReasoning,RewriteRuleReasoning,
  AssumptionAwareSimplificationReasoning,
  CombineLikeTermsReasoning,CancellationReasoning,
  RationalSimplificationReasoning,PolynomialSimplificationReasoning,
  TrigonometricSimplificationReasoning,
  LogarithmicSimplificationReasoning,
  RadicalSimplificationReasoning,
  ComplexityMeasureReasoning,BranchConditionReasoning,
  SemanticPreservationReasoning,VerificationReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "expression simplification" -> ExpressionSimplification
  "symbolic simplification" -> ExpressionSimplification
  "canonicalization" -> Canonicalisation
  "CAS" -> ComputerAlgebraSystem
  "AST" -> AbstractSyntaxTree
 }
}

EXECUTION_RULES {
 E1 = "If a symbolic expression is transformed into an equivalent reduced or canonical form, activate ExpressionSimplificationOntology."
 E2 = "Determine domain and assumptions before applying conditional simplification rules."
 E3 = "Apply unconditional identities before assumption-dependent transformations."
 E4 = "Preserve excluded-value and branch conditions during cancellation and function simplification."
 E5 = "Use task-appropriate complexity criteria rather than assuming shortest syntax is always best."
 E6 = "Avoid nonterminating rewrite cycles through ordered or fixed-point strategies."
 E7 = "Preserve exact arithmetic unless approximation is explicitly requested."
 E8 = "Verify equivalence through exact identity checks or substitution where feasible."
 E9 = "Document assumptions, rule sets, cost policies and CAS versions for reproducibility."
}

RECURSION {
 ENTRY = ExpressionSimplification
 EXPAND(ExpressionSimplification) -> [
  Simplification,SymbolicSimplification,AlgebraicSimplification,
  RationalSimplification,PolynomialSimplification,
  TrigonometricSimplification,LogarithmicSimplification,
  RadicalSimplification,PowerSimplification,
  SymbolicExpression,ExpressionTree,AST,
  CanonicalForm,NormalForm,Canonicalisation,
  ReducedForm,ExpandedForm,FactoredForm,
  LikeTerm,CombineLikeTerms,CollectTerms,
  CommonFactorExtraction,Cancellation,FractionReduction,
  PolynomialGCD,SignNormalisation,PowerCombination,
  LogarithmIdentity,TrigonometricIdentity,RadicalIdentity,
  Assumption,NonzeroAssumption,PositiveAssumption,
  BranchCondition,RewriteRule,RewriteSystem,
  PatternMatching,ConditionalRewrite,FixedPointSimplification,
  ConstantFolding,IdentityElimination,CommonSubexpression,
  ExpressionSize,OperationCount,ComplexityMeasure,
  ExpressionSwell,SymbolicAlgebra,SymbolicMathematics,
  ComputerAlgebraSystem,CAS,Verification,IdentityCheck,
  Reproducibility,Provenance
 ]
 EXPAND(ExpressionSimplificationFamilies) -> [
  CanonicalisationAndNormalForms,
  AlgebraicTermReduction,
  RationalAndPolynomialSimplification,
  TrigonometricAndLogarithmicSimplification,
  PowerRadicalAndAbsoluteValueSimplification,
  AssumptionAndBranchAwareSimplification,
  RewriteStrategiesAndComplexityMeasures,
  VerificationAndReproducibility
 ]
 STOP_CONDITION = "Stop when domain, assumptions, transformation rules, target form, complexity objective and equivalence validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Symbolic Computation"
 RELATED_ONTOLOGIES = [
  "Symbolic Computation",
  "Symbolic Mathematics Ontology",
  "Symbolic Algebra Ontology",
  "Computer Algebra Systems Ontology 2",
  "Symbolic Differentiation Ontology",
  "Symbolic Integration Ontology",
  "Polynomial Ontology",
  "Rational Expression Ontology",
  "Factorisation Ontology",
  "Expansion Ontology",
  "Simplification Ontology",
  "Substitution Ontology",
  "Computational Complexity Ontology"
 ]
 ROUTE_RULES = [
  "Expression Simplification -> Symbolic Computation for parent execution semantics",
  "Expression Simplification -> Symbolic Mathematics for expression and equivalence semantics",
  "Expression Simplification -> Symbolic Algebra for algebraic transformations",
  "Expression Simplification -> Computer Algebra Systems for rule-engine implementation",
  "Expression Simplification -> Symbolic Differentiation and Integration for post-processing derivative and integral results",
  "Expression Simplification -> Polynomial and Rational Expression ontologies for structure-specific reduction",
  "Expression Simplification -> Factorisation, Expansion, Simplification and Substitution ontologies for transformation-specific semantics",
  "Expression Simplification -> Computational Complexity for expression-size and cost semantics"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible simplification rules, domains or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve syntactic-shortness-versus-semantic-simplicity distinction.",
  "Preserve unconditional-versus-assumption-dependent rewrite distinction.",
  "Preserve equivalence-versus-domain-equivalence distinction.",
  "Preserve canonical-form-versus-task-specific-form distinction.",
  "Preserve cancellation-versus-domain-restriction distinction.",
  "Preserve local-rule-versus-global-cost distinction.",
  "Preserve machine-readable expression-simplification semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Expression simplification transforms symbolic mathematical expressions into equivalent reduced or canonical forms under declared assumptions."
 ALGEBRA_SUMMARY = "Collection, cancellation, factor extraction and rational reduction provide core algebraic simplification."
 FUNCTION_SUMMARY = "Trigonometric, logarithmic, exponential, radical and power simplifications require identity and domain-aware reasoning."
 ASSUMPTION_SUMMARY = "Nonzero, positivity, real-domain and branch assumptions determine the validity of many transformations."
 COMPLEXITY_SUMMARY = "Simplification may optimise expression size, depth, operation count, evaluation cost or a task-specific objective."
 VALIDATION_SUMMARY = "Simplified expressions should be checked for exact equivalence, preserved exclusions, branch validity and reproducible rule settings."
}

FLOW {
 INPUT
 -> detect_expression_simplification_context
 -> identify_expression_type_domain_assumptions_target_form_usage_context_and_cost_metric
 -> parse_expression_into_tree_or_DAG
 -> normalise_operator_order_constants_signs_and_term_structure
 -> apply_safe_identity_zero_one_constant_and_like_term_rules
 -> apply_algebraic_rational_polynomial_trigonometric_logarithmic_radical_or_power_rules
 -> apply_conditional_rules_only_when_side_conditions_are_satisfied
 -> generate_candidate_equivalent_forms_if_needed
 -> evaluate_candidates_using_expression_size_depth_operation_count_or_target_specific_cost
 -> preserve_excluded_values_piecewise_cases_and_branch_conditions
 -> verify_equivalence_by_identity_substitution_or_exact_residual
 -> document_assumptions_rule_set_cost_policy_CAS_versions_and_provenance
 -> route_to_related_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

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

}

END_FLOW