Algebraic Optimisation Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the mathematical ontology of algebraic optimisation. Algebraic optimisation concerns improving algebraic expressions, formulations, solution procedures, or symbolic representations according to a defined objective while preserving mathematical validity. It connects symbolic manipulation, simplification, canonicalisation, computational algebra, constraint reasoning and algorithm selection. This record is designed for semantic retrieval, recursive mathematical reasoning, ontology linking, knowledge-graph construction and AI consumption within the Kireth Research Semantic Library.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = AlgebraicOptimisation
 SYMBOLIC_FORMS = ["OPTIMISE(E)", "minimise(cost(E))", "E -> E_opt"]
 ENTITY_CLASS = GoalDirectedAlgebraicTransformation
 PRIMARY_CONTEXT = Algebra
 SECONDARY_CONTEXTS = [SymbolicComputation, ComputationalAlgebra, MathematicalOptimisation]
 DEFINITION = "Algebraic optimisation is the process of transforming or selecting algebraic representations and procedures to improve a defined objective while preserving the required mathematical semantics."
 SEMANTIC_ROLE = "Chooses among mathematically valid alternatives according to criteria such as simplicity, computational cost, sparsity, stability, canonicality or reasoning efficiency."
}

SCOPE {
 INCLUDE = [
  AlgebraicOptimisation,
  ExpressionOptimisation,
  SymbolicOptimisation,
  SimplificationStrategy,
  Canonicalisation,
  CostFunction,
  ConstraintPreservation,
  RewriteStrategy,
  ComputationalCost,
  ExpressionSize,
  OperationCount,
  Sparsity,
  CommonSubexpressionElimination,
  FactorisationChoice,
  ExpansionChoice,
  AlgorithmSelection,
  SearchSpace,
  ObjectiveFunction
 ]

 EXCLUDE_AS_PRIMARY = [
  GeneralContinuousOptimisation,
  LinearProgrammingWithoutSymbolicContext,
  NumericalOptimisationOnly,
  BusinessOptimisation,
  HeuristicCompressionWithoutMathematicalEquivalence
 ]

 DISAMBIGUATION_RULE =
  "When optimisation occurs with algebraic expressions, symbolic rewriting, simplification, factorisation, expansion, computational cost, operation count or canonicalisation, interpret it as algebraic or symbolic optimisation."
}

CORE_CONCEPTS {

 AlgebraicOptimisation {
  definition = "Selection or transformation of a mathematically valid algebraic representation according to an explicit optimisation objective."
  requirements = [
   SemanticValidity,
   ObjectiveFunction,
   Constraints,
   CandidateTransformations
  ]
 }

 ObjectiveFunction {
  definition = "A measurable criterion used to compare candidate algebraic forms or procedures."
  examples = [
   MinimiseExpressionSize,
   MinimiseOperationCount,
   MinimiseDepth,
   MaximiseSparsity,
   MaximiseCanonicality,
   MinimiseEvaluationCost,
   ImproveReasoningClarity
  ]
 }

 CostFunction {
  definition = "A function assigning a cost to an algebraic expression, derivation or algorithmic representation."
  form = "cost(E)"
 }

 ConstraintPreservation {
  definition = "Requirement that optimisation does not violate algebraic equivalence, logical relation, domain restrictions or side conditions."
 }

 RewriteStrategy {
  definition = "A policy governing which valid symbolic transformations are applied and in what order."
 }

 CommonSubexpressionElimination {
  definition = "Identification and reuse of repeated algebraic subexpressions to reduce duplicated computation."
 }

 ExpressionSize {
  definition = "Measure of syntactic complexity, such as node count, token count or operator count."
 }

 ComputationalCost {
  definition = "Estimated resources required to evaluate or manipulate an algebraic form."
 }

 Sparsity {
  definition = "Degree to which a representation contains relatively few nonzero or active terms."
 }
}

RELATIONS {
 AlgebraicOptimisation --uses--> ObjectiveFunction
 AlgebraicOptimisation --uses--> CostFunction
 AlgebraicOptimisation --requires--> ConstraintPreservation
 AlgebraicOptimisation --searches_over--> EquivalentRepresentations
 AlgebraicOptimisation --can_use--> Simplification
 AlgebraicOptimisation --can_use--> Expansion
 AlgebraicOptimisation --can_use--> Factorisation
 AlgebraicOptimisation --can_use--> Substitution
 AlgebraicOptimisation --can_use--> Canonicalisation
 AlgebraicOptimisation --can_use--> CommonSubexpressionElimination
 AlgebraicOptimisation --can_select--> AlgebraicAlgorithm
 RewriteStrategy --controls--> TransformationOrder
 CostFunction --evaluates--> CandidateRepresentation
 ComputationalCost --can_depend_on--> OperationCount
 Sparsity --can_influence--> ComputationalCost
}

OPERATORS {
 OPTIMISE(E,OBJECTIVE,CONSTRAINTS) :=
  argmin_or_argmax_over_valid_equivalent_representations(E)

 COST(E,METRIC) :=
  evaluate_metric(E)

 IS_VALID_CANDIDATE(E,E',CONSTRAINTS) :=
  semantic_relation_preserved(E,E')
  AND constraints_preserved(E,E',CONSTRAINTS)

 COMMON_SUBEXPRESSION_ELIMINATION(E) :=
  identify_repeated_subexpressions_and_reuse_them

 MINIMISE_OPERATION_COUNT(E) :=
  search_valid_rewrites_for_lowest_estimated_operation_count

 MAXIMISE_SPARSITY(E) :=
  select_equivalent_representation_with_more_zero_or_absent_terms

 CHOOSE_REWRITE(E,RULESET,OBJECTIVE) :=
  valid_rule_with_best_predicted_objective_improvement

 CHOOSE_ALGORITHM(PROBLEM,CANDIDATES,OBJECTIVE) :=
  candidate_algorithm_with_best_cost_under_constraints
}

DEFINITIONS {
 D1 = "Algebraic optimisation is goal-directed rather than merely simplification."
 D2 = "The best representation depends on the chosen objective."
 D3 = "Equivalent expressions may have different computational costs."
 D4 = "Factorisation can reduce multiplication count or expose structure."
 D5 = "Expansion can improve coefficient access or enable collection of like terms."
 D6 = "Common subexpression elimination can reduce repeated evaluation."
 D7 = "Canonical forms support comparison but are not always computationally cheapest."
 D8 = "Optimisation must preserve mathematical semantics and domain restrictions."
 D9 = "Multiple objectives may conflict and require prioritisation or trade-offs."
 D10 = "An algebraically simpler expression is not necessarily computationally optimal."
}

AXIOMS {
 A1_VALIDITY_FIRST:
  IF candidate representation violates required mathematical semantics
  THEN candidate is inadmissible regardless of cost

 A2_OBJECTIVE_DEPENDENCE:
  Optimality is defined only relative to an objective or ordered set of objectives

 A3_EQUIVALENT_SEARCH:
  Algebraic optimisation searches among admissible representations related by valid transformations

 A4_CONSTRAINT_PRESERVATION:
  All domain restrictions and side conditions must be retained or explicitly updated

 A5_MULTI_OBJECTIVE:
  If multiple objectives are used
  THEN optimisation requires a priority, weighting, Pareto rule or equivalent selection policy

 A6_COST_RELATIVITY:
  Cost estimates may depend on evaluation model, hardware abstraction, symbolic engine or downstream task
}

REASONING {

 R1_EXPRESSION_OPTIMISATION {
  INPUT = expression E
  IDENTIFY = optimisation_objective
  IDENTIFY = constraints
  GENERATE = valid_candidate_rewrites
  SCORE = candidates
  SELECT = best_candidate
  VERIFY = semantic_validity
  RETURN = optimised_expression
 }

 R2_FACTOR_VS_EXPAND {
  INPUT = expression E and objective
  CANDIDATE_1 = factor(E)
  CANDIDATE_2 = expand(E)
  SCORE = [cost(CANDIDATE_1),cost(CANDIDATE_2)]
  SELECT = lower_or_preferred_cost
  RETURN = selected_form
 }

 R3_COMMON_SUBEXPRESSION {
  INPUT = expression graph
  DETECT = repeated_subtrees
  INTRODUCE = shared_intermediate_symbols
  REWRITE = expression_using_shared_nodes
  VERIFY = equivalence
  RETURN = reduced_computation_form
 }

 R4_OPERATION_COUNT {
  INPUT = candidate expressions
  COUNT = arithmetic_operations
  WEIGHT = operation_types_if_required
  RETURN = ranked_candidates
 }

 R5_MULTI_OBJECTIVE {
  INPUT = candidates and objectives
  APPLY = priority_or_weighting_policy
  FILTER = invalid_candidates
  RETURN = selected_or_Pareto_optimal_candidates
 }

 R6_ALGORITHM_SELECTION {
  INPUT = algebraic_problem
  CANDIDATES = applicable_algorithms
  ESTIMATE = symbolic_cost_and_constraints
  SELECT = best_algorithm_under_objective
  RETURN = algorithm_choice
 }

 R7_VERIFY_OPTIMISATION {
  INPUT = [original E, optimised E_opt]
  VERIFY = declared_semantic_relation
  VERIFY = domain_constraints
  COMPARE = objective_value
  RETURN = OptimisationValidity
 }
}

CONSTRAINTS {
 C1 = "Optimisation must not sacrifice mathematical correctness."
 C2 = "A candidate is only comparable under a defined objective."
 C3 = "Expression-size minimisation and operation-count minimisation are not equivalent objectives."
 C4 = "Factorisation may reduce operation count but increase structural depth."
 C5 = "Expansion may increase size while improving canonicality or coefficient visibility."
 C6 = "Common subexpression elimination may introduce intermediate symbols and change surface syntax."
 C7 = "Domain restrictions must survive all transformations."
 C8 = "Heuristic optimisation should be labelled heuristic when global optimality is not proved."
 C9 = "Algorithmic optimality may depend on input size and algebraic domain."
 C10 = "Do not confuse algebraic optimisation with unrelated business or numerical optimisation contexts."
}

SEMANTIC_EQUIVALENCE {
 "AlgebraicOptimisation" <=> "GoalDirectedSymbolicOptimisation"
 "ExpressionOptimisation" <=> "SearchForBestEquivalentRepresentation"
 "CommonSubexpressionElimination" <=> "ReuseOfRepeatedEquivalentSubexpressions"
 "CostFunction" <=> "ObjectiveEvaluationMetric"
 "RewriteStrategy" <=> "RuleSelectionPolicy"
}

VALIDATION {
 V1 = "Optimised output is mathematically valid."
 V2 = "Objective value improves or satisfies the stated optimisation criterion."
 V3 = "Domain restrictions remain preserved."
 V4 = "Common subexpression elimination preserves expression value."
 V5 = "Factorised and expanded candidates are compared under the same cost model."
 V6 = "Multi-objective optimisation states its selection policy."
 V7 = "Heuristic results are not mislabelled as globally optimal without proof."
 V8 = "Algorithm selection respects algebraic domain and problem structure."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.98
 ALGEBRAIC_OPTIMISATION_DEFINITION = 0.99
 OBJECTIVE_DEPENDENCE = 0.99
 CONSTRAINT_PRESERVATION = 0.99
 REWRITE_STRATEGY_ROLE = 0.99
 COMMON_SUBEXPRESSION_RELATION = 0.99
 MULTI_OBJECTIVE_RELATION = 0.98
 GLOBAL_OPTIMALITY = 0.80

 POLICY =
  "Reduce confidence when the objective function, cost model, algebraic domain or admissible transformation set is underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  SymbolicOptimisation,
  RewriteStrategySelection,
  ComputationalAlgebraReasoning,
  ExpressionCostReasoning,
  AlgorithmSelection,
  Canonicalisation,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "algebraic optimisation" -> AlgebraicOptimisation
  "symbolic optimisation" -> AlgebraicOptimisation
  "optimise expression" -> ExpressionOptimisation
  "reduce operation count" -> OperationCountOptimisation
  "common subexpression elimination" -> CommonSubexpressionElimination
  "rewrite strategy" -> RewriteStrategy
  "cost function" -> CostFunction
 }

 INTERPRETATION_ORDER = [
  identify_algebraic_object,
  identify_objective,
  identify_constraints,
  identify_cost_model,
  generate_valid_candidate_representations,
  eliminate_invalid_candidates,
  estimate_candidate_costs,
  select_best_candidate_under_policy,
  verify_semantics,
  verify_constraint_preservation,
  return_optimised_representation_and_rationale
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("algebraic optimisation")
  OR query_mentions("symbolic optimisation")
  THEN activate(AlgebraicOptimisationOntology)

 E2:
  IF objective_not_specified
  THEN infer_from_context_if_unambiguous
  ELSE mark_objective_as_unspecified

 E3:
  IF request=="minimise operations"
  THEN activate(operation_count_cost_model)

 E4:
  IF repeated_subexpressions_detected
  THEN consider(CommonSubexpressionElimination)

 E5:
  IF factorised_and_expanded_forms_are_both_valid
  THEN compare_under_current_objective

 E6:
  IF multiple_objectives_present
  THEN require_selection_policy

 E7:
  IF candidate_changes_domain_or_semantics
  THEN reject_candidate

 E8:
  IF global_optimum_not_proven
  THEN classify_result_as(HeuristicOrLocallyOptimal)
}

RECURSION {
 ENTRY = AlgebraicOptimisation

 EXPAND(AlgebraicOptimisation) -> [
  SymbolicManipulation,
  Simplification,
  Expansion,
  Factorisation,
  Substitution,
  Canonicalisation,
  CostFunction,
  ObjectiveFunction,
  RewriteStrategy,
  ComputationalAlgebra
 ]

 EXPAND(CostFunction) -> [
  ExpressionSize,
  OperationCount,
  TreeDepth,
  Sparsity,
  EvaluationCost
 ]

 EXPAND(RewriteStrategy) -> [
  RewriteRule,
  RulePriority,
  SearchSpace,
  Heuristic,
  Termination
 ]

 EXPAND(AlgorithmSelection) -> [
  ComputationalAlgebra,
  Complexity,
  InputStructure,
  AlgebraicDomain
 ]

 STOP_CONDITION =
  "Stop when a valid candidate satisfying the optimisation objective is selected, constraints are verified, and optimality status is appropriately characterised."
}

ROUTING {
 PARENT_ONTOLOGY = "Algebra Ontology"

 IMMEDIATE_CONTEXTS = [
  "Symbolic Manipulation Ontology",
  "Simplification Ontology",
  "Computational Algebra Ontology"
 ]

 RELATED_ONTOLOGIES = [
  "Symbolic Manipulation Ontology",
  "Simplification Ontology",
  "Expansion Ontology",
  "Factorisation Ontology",
  "Substitution Ontology",
  "Computational Algebra Ontology",
  "Computer Algebra Systems Ontology",
  "Algebraic Proof Ontology",
  "Polynomial Ontology",
  "Matrix Ontology"
 ]

 ROUTE_RULES = [
  "Algebraic Optimisation -> Symbolic Manipulation for candidate rewrites",
  "Algebraic Optimisation -> Simplification for reduced-form objectives",
  "Algebraic Optimisation -> Expansion or Factorisation for representation choice",
  "Algebraic Optimisation -> Computational Algebra for algorithm selection",
  "Algebraic Optimisation -> CAS for executable optimisation strategies",
  "Algebraic Optimisation -> Algebraic Proof for correctness verification"
 ]
}

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

 RULES = [
  "Preserve goal-directed optimisation semantics.",
  "Preserve mathematical validity as a hard constraint.",
  "Preserve explicit objective dependence.",
  "Preserve domain and side-condition tracking.",
  "Preserve distinction between heuristic and proven global optimality.",
  "Preserve multi-objective policy requirements.",
  "Preserve compatibility with symbolic manipulation and computational algebra."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Algebraic optimisation selects or transforms algebraic representations to improve a defined objective while preserving mathematical validity."

 SYMBOLIC_SUMMARY =
  "E -> E_opt subject to semantic constraints and objective optimisation"

 COST_SUMMARY =
  "cost(E_opt) <= cost(E) under the selected cost model when minimisation is the objective."

 VALIDITY_SUMMARY =
  "No optimisation is admissible if algebraic semantics or required domain constraints are violated."

 STRATEGY_SUMMARY =
  "Candidate rewrites may include simplification, factorisation, expansion, substitution, canonicalisation and common subexpression elimination."

 OPTIMALITY_SUMMARY =
  "Optimality is relative to an explicit objective and may be global, local or heuristic."
}

FLOW {
 INPUT
 -> detect_algebraic_optimisation_context
 -> identify_algebraic_object
 -> identify_objective_function
 -> identify_constraints
 -> identify_cost_model
 -> generate_valid_symbolic_candidates
 -> include_simplification_factorisation_expansion_and_substitution_candidates
 -> consider_common_subexpression_elimination
 -> score_candidates
 -> reject_semantically_invalid_candidates
 -> select_best_candidate_under_policy
 -> verify_domain_and_side_conditions
 -> classify_optimality_status
 -> link_related_ontologies
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "Algebraic optimisation is goal-directed symbolic transformation. It searches among mathematically valid algebraic forms and procedures to improve criteria such as expression size, operation count, sparsity, canonicality or computational cost. Correct optimisation requires an explicit objective, preservation of algebraic semantics and domains, and clear distinction between heuristic improvement and proven optimality."
}

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

}

END_FLOW