Feasible Region Ontology

FLOW ALGEBRA
FEASIBLE REGION ONTOLOGY
Kireth Semantic Library | Computational Mathematical Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/computational-mathematical-entities/feasible-region-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Status: Proposed mathematical formalisation; source page text not independently verified.
Version: 1.0 | Date: 2026-10-14

1. PURPOSE
Represent the feasible region of a constrained mathematical or computational problem, preserving variable domains, constraint semantics, satisfaction witnesses, geometry, and provenance.

2. TYPED ENTITIES
DecisionVariable: {id, domain, unit?}
Assignment: map<DecisionVariable, Value>
Constraint: {id, expression, relation, scope, tolerance?}
ConstraintSet: set<Constraint>
FeasibleRegion: {id, variables, domains, constraints, membership_predicate}
FeasiblePoint: Assignment satisfying all constraints
ObjectiveFunction: optional function from assignments to ordered values
BoundaryPoint: point in closure(F) not in interior(F)
InfeasibilityCertificate: independently checkable proof of empty feasibility, where available

3. CORE SEMANTICS
Let X = D1 × ... × Dn be the decision-variable domain.
Let C = {c1,...,cm} be the constraint set.
F = {x in X : forall c in C, satisfies(c,x)}.
feasible(x,F) <=> x in X AND forall c in C: satisfies(c,x).
F = X intersection intersection_{i=1}^m S_i,
where S_i = {x in X : satisfies(c_i,x)}.
Empty constraint set: F = X (subject to domain restrictions).
Infeasible problem: F = empty set.

4. CONSTRAINT TYPES
Equality: g_i(x) = 0.
Non-strict inequality: h_j(x) <= 0.
Strict inequality: q_k(x) < 0.
Discrete-domain restriction: x_i in Z, {0,1}, or a specified finite set.
Logical constraint: Boolean formula evaluated under an assignment.
Tolerance-based numerical acceptance is distinct from exact mathematical feasibility.

5. GEOMETRY AND STRUCTURE
Linear equalities and non-strict linear inequalities over R^n yield a convex polyhedron, possibly empty or unbounded.
A bounded polyhedron is a polytope.
Convex constraint sets have convex intersections.
Nonlinear, discrete, or disjunctive constraints may yield nonconvex or disconnected regions.
Strict inequalities can produce open or relatively open portions; do not infer closedness universally.
The boundary, interior, closure, dimension, and connected components depend on the ambient topology and domains.

6. RELATIONSHIPS
FeasibleRegion --DEFINED_BY--> ConstraintSet
FeasibleRegion --SUBSET_OF--> VariableDomainProduct
FeasiblePoint --MEMBER_OF--> FeasibleRegion
Constraint --RESTRICTS--> DecisionVariable
ObjectiveFunction --OPTIMISED_OVER--> FeasibleRegion
BoundaryPoint --ON_BOUNDARY_OF--> FeasibleRegion
InfeasibilityCertificate --CERTIFIES_EMPTY--> FeasibleRegion

7. INFERENCE RULES
R1: If x satisfies every constraint and every domain restriction, infer feasible(x,F).
R2: If any mandatory constraint fails, infer not_feasible(x,F).
R3: If C2 contains all constraints in C1 on the same X, infer F(C2) subset_of F(C1).
R4: If a valid infeasibility certificate verifies, infer F = empty.
R5: If x in F and objective f(x) is known, infer x is a feasible candidate, NOT automatically optimal.
R6: If F is nonempty and compact and f is continuous, infer f attains a minimum and maximum on F.
R7: If F is convex and f is convex, every local minimum is global (under the appropriate relative topology).
R8: If a new constraint is added, the feasible region cannot expand (unchanged domain).

8. EXECUTABLE FLOW (PSEUDOCODE)
flow "FeasibleRegionMembership" v1.0
  input: variables, domains, constraints, candidate
  require: candidate assigns every required variable
  for variable in variables:
    if candidate[variable] not_in domains[variable]: return INFEASIBLE
  for constraint in constraints:
    result = evaluate(constraint, candidate)
    if result == FALSE: return INFEASIBLE
    if result == UNKNOWN: return UNDETERMINED
  return FEASIBLE
end

flow "FeasibleRegionRefinement" v1.0
  input: region F, added_constraint c
  output: F_new = {x in F : satisfies(c,x)}
  assert: F_new subset_of F
end

9. EXAMPLES
A: X=R^2; constraints x>=0, y>=0, x+y<=1.
   F is a closed, bounded convex triangle with vertices (0,0), (1,0), (0,1).
B: X=R; constraints x>0 and x<1.
   F=(0,1), a nonempty open feasible region.
C: X=R; constraints x>=2 and x<=1.
   F=empty set.
D: X=Z; constraints 0<=x<=2.
   F={0,1,2}; discrete feasibility must not be conflated with a real interval.

10. VALIDATION
- Every constraint has an explicit relation and variable scope.
- Every decision variable has a declared domain.
- Membership checks distinguish FALSE from UNKNOWN.
- Numerical tolerances, if used, are recorded with units and method.
- Feasible does not imply optimal; feasible region does not imply nonempty.
- Preserve exact versus approximate reasoning and any solver assumptions.
- Validate certificates with a trusted checker when claiming proven infeasibility.

11. SEMANTIC EQUIVALENCE AND DISTINCTIONS
feasible region ~= feasible set ~= admissible set (when constraints and domains coincide).
feasible region != objective function.
feasible region != optimal solution set (unless separately proved equal).
feasible region != search space: search space may contain infeasible points.
constraint satisfaction != statistical confidence.

12. CONFIDENCE AND PROVENANCE
CONFIDENCE:
  mathematical_definitions: high (standard definitions, with explicit assumptions)
  source_page_alignment: unverified
PROVENANCE:
  source_url: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/computational-mathematical-entities/feasible-region-ontology.html
  authorship: Mark Higgins — Sky (Recursive AI)
  generated_date: 2026-10-14

13. FLOW_HASH / UPDATE_MODEL
FLOW_HASH:
  algorithm: SHA-256
  input: canonical UTF-8 representation of ontology content excluding any embedded hash value
  value: computed by ingestion system; not precomputed here
UPDATE_MODEL:
  version: 1.0
  change_policy: preserve entity identifiers; record changed axioms, assumptions, and dependency impacts

14. AI_CONSUMPTION
- Parse typed entities and predicates into a constraint-aware knowledge graph.
- Require explicit domain and constraint context before declaring feasibility.
- Do not infer global optimality from membership alone.
- Return proof/certificate status separately from heuristic solver claims.
- Expose UNKNOWN where constraint evaluation is undecidable, unsupported, or numerically inconclusive.
- Support symbolic, numerical, and mixed-integer solver adapters with declared semantics.

END FLOW ALGEBRA