Constraint Reasoning Ontology

FLOW_ALGEBRA ConstraintReasoningOntology v1.0
TARGET_URL := "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/logical-reasoning/constraint-reasoning-ontology.html"
LANGUAGE := "en-GB"
DOMAIN := MathematicalOntologies > MathematicalLogicOntologies > LogicalReasoning > ConstraintReasoningOntology

BEGIN_FLOW

ENTITY ConstraintReasoning {
 TYPE := FormalReasoningFramework
 DEFINITION := "Reasoning over variables, domains and constraints to determine consistency, reduce domains, construct satisfying assignments, optimise solutions or prove that no admissible solution exists."
}
ENTITY Variable { TYPE := SymbolicDecisionEntity }
ENTITY Domain { TYPE := SetOfAdmissibleValues }
ENTITY Constraint { TYPE := RelationRestrictingAssignments }

RELATIONSHIP ConstraintReasoning --uses--> Variable
RELATIONSHIP Variable --has--> Domain
RELATIONSHIP Constraint --restricts--> Variable
RELATIONSHIP ConstraintReasoning --supports--> ConstraintSatisfaction
RELATIONSHIP ConstraintReasoning --supports--> ConstraintPropagation

CSP {
 COMPONENTS := {
  Variables X={X1,...,Xn},
  Domains D={D1,...,Dn},
  Constraints C={C1,...,Cm}
 }
 GOAL := find assignment satisfying every constraint
}
ASSIGNMENT {
 A := {X1=v1,...,Xn=vn}
 REQUIRE vi∈Di
}
SOLUTION {
 A solution IFF FOR_ALL Cj: Cj(A)=satisfied
}
CONSISTENCY {
 CSP consistent IFF EXISTS solution
}
UNARY_CONSTRAINT { SCOPE := {X} }
BINARY_CONSTRAINT { SCOPE := {X,Y} }
N_ARY_CONSTRAINT { SCOPE := {X1,...,Xk} }
HARD_CONSTRAINT { MUST be satisfied }
SOFT_CONSTRAINT { MAY incur cost_or_preference }
GLOBAL_CONSTRAINT {
 EXAMPLES := {AllDifferent,Cumulative,Element,Circuit}
}
ALL_DIFFERENT {
 REQUIRE Xi!=Xj FOR_ALL i!=j
}
REIFIED_CONSTRAINT {
 Boolean B represents truth_status_of_constraint C
}
CONSTRAINT_GRAPH {
 NODES := Variables
 EDGE(X,Y) IFF X,Y share binary_constraint
}
HYPERGRAPH {
 NODES := Variables
 HYPEREDGES := ConstraintScopes
}

CONSTRAINT_PROPAGATION {
 PURPOSE := remove values lacking required support
}
NODE_CONSISTENCY {
 remove v∈D(X) IF unary_constraint_false
}
ARC_CONSISTENCY {
 FOR every x∈D(X):
  EXISTS y∈D(Y) satisfying C(X,Y)
}
AC3 {
 INITIALISE queue_with_arcs
 WHILE queue_not_empty:
  SELECT (X,Y)
  IF REVISE(X,Y):
   IF D(X)=empty RETURN inconsistent
   ADD neighbouring_arcs
 RETURN arc_consistent_domains
}
REVISE(X,Y) {
 remove x with no support in D(Y)
 RETURN whether_domain_changed
}
GENERALISED_ARC_CONSISTENCY {
 ABBREVIATION := GAC
 REQUIRE every value has supporting_tuple in each relevant n_ary_constraint
}
BOUNDS_CONSISTENCY {
 reason_over_domain_bounds under selected definition
}
PROPAGATOR {
 INPUT := current_domains
 OUTPUT := reduced_domains
 REQUIRE sound_value_removal
}
PROPAGATION_FIXED_POINT {
 repeatedly_apply_propagators until no_change
}
DOMAIN_WIPEOUT {
 D(X)=empty -> current_branch_inconsistent
}

BACKTRACKING_SEARCH {
 IF all_assigned RETURN solution
 X := select_unassigned_variable
 FOR v IN ordered_values(D(X)):
  ASSIGN X=v
  PROPAGATE
  IF no_failure:
   recurse
  UNDO
 RETURN failure
}
FORWARD_CHECKING {
 after assignment remove inconsistent neighbour_values
}
MAC {
 ABBREVIATION := MaintainingArcConsistency
 enforce_arc_consistency_after_branch
}
MRV {
 SELECT variable with smallest current_domain
}
DEGREE_HEURISTIC {
 prefer variable constraining most remaining_variables
}
LEAST_CONSTRAINING_VALUE {
 prefer value eliminating fewest neighbour_choices
}
BACKJUMPING {
 jump_to_relevant_prior_decision_on_failure
}
NOGOOD {
 TYPE := PartialAssignmentKnownInconsistent
}
NOGOOD_LEARNING {
 failure -> derive_nogood -> prevent_repetition
}

CONSTRAINT_PROGRAMMING {
 ABBREVIATION := CP
 COMPONENTS := {Variables,Domains,Constraints,Propagators,Search}
}
FINITE_DOMAIN_CP {
 Domains := finite_discrete_sets
}
INTEGER_CP {
 Variables := integers
}
REAL_CONSTRAINT_REASONING {
 METHODS := {IntervalPropagation,LinearProgramming,NonlinearSolvers}
}
LINEAR_CONSTRAINT {
 FORM := a1X1+...+anXn <= b
}
SAT_RELATIONSHIP {
 BooleanVariables + propositional_constraints -> SAT
 finite_CSP MAY encode_to SAT
}
SMT_RELATIONSHIP {
 BooleanStructure + TheoryConstraints -> SMT
}
DPLL_T_RELATIONSHIP {
 SATCore + TheorySolver -> SMTReasoning
}
THEORY_PROPAGATION {
 TheorySolver derives implied_literals
}
THEORY_CONFLICT {
 theory_inconsistent_assignment -> conflict_explanation
}
UNIFICATION_AS_CONSTRAINT_SOLVING {
 equations_between_terms -> substitution_constraints -> MGU
}
TYPE_INFERENCE_RELATIONSHIP {
 TypeVariables + TypeConstraints -> inferred_types
}
CLP {
 ABBREVIATION := ConstraintLogicProgramming
}
CLP_FD {
 TYPE := ConstraintLogicProgrammingOverFiniteDomains
}

SCHEDULING {
 VARIABLES := {StartTimes,Durations,Resources}
 CONSTRAINTS := {Precedence,NonOverlap,Capacity,Deadlines}
}
CUMULATIVE_CONSTRAINT {
 PURPOSE := resource_capacity_reasoning
}
CONFIGURATION {
 component_selection + compatibility_constraints -> valid_configuration
}
PLANNING_RELATIONSHIP {
 actions_and_resources MAY encode_as constraint_problem
}
SUDOKU_ENCODING {
 Variables := Cells
 Domains := {1,...,9}
 Constraints := {RowAllDifferent,ColumnAllDifferent,BoxAllDifferent,GivenValues}
}
GRAPH_COLOURING {
 Variables := Vertices
 Domains := Colours
 EdgeConstraint(u,v) := Colour(u)!=Colour(v)
}

OPTIMISATION {
 CSP + ObjectiveFunction -> ConstraintOptimisationProblem
}
BRANCH_AND_BOUND {
 maintain incumbent
 prune branch if bound_cannot_improve_incumbent
}
WEIGHTED_CSP {
 constraints have costs
 optimise declared_aggregate_cost
}
MAX_CSP {
 maximise satisfied_constraint_weight_or_count
}
PARETO_OPTIMISATION {
 return nondominated_solutions for multiple_objectives
}

UNSAT_CORE {
 TYPE := SubsetOfConstraints
 PROPERTY := jointly_unsatisfiable
}
MINIMAL_UNSAT_CORE {
 removing_any_member_makes_subset_satisfiable
 under subset_minimal_definition
}
CONFLICT_SET {
 constraints_or_decisions_responsible_for_failure
}
PROVENANCE {
 DomainReduction -> Propagator -> Constraint -> PriorDomainState
}
CONSTRAINT_TRACE {
 RECORD := {
  VariableDomains,
  ConstraintApplied,
  ValuesRemoved,
  Reason,
  BranchDecision,
  Conflict,
  Backtrack
 }
}

CONSTRAINT_REASONING_VS_DEDUCTION {
 ConstraintReasoning := admissible_assignment_and_domain_reduction
 DeductiveReasoning := logical_consequence_derivation
}
CONSTRAINT_REASONING_VS_SEARCH {
 Propagation := infer_impossible_values
 Search := branch_among_remaining_alternatives
}
LOCAL_VS_GLOBAL {
 local_consistency generally does_not_guarantee_global_solution
}
PROPAGATION_SOUNDNESS {
 removed_value MUST_NOT belong_to any solution consistent_with_current_branch
 under propagator_claim
}
PROPAGATION_COMPLETENESS_WARNING {
 retained_value does_not_necessarily belong_to_global_solution
}
SYMMETRY_BREAKING {
 add constraints selecting representative_solutions
 REQUIRE preserve desired_solution_classes
}
REDUNDANT_CONSTRAINT {
 logically_implied_constraint MAY improve_propagation
}
DECOMPOSITION {
 global_constraint -> simpler_constraints
 WARNING := may_weaken_propagation
}
TREE_STRUCTURED_CSP {
 acyclic_binary_constraint_graph permits specialised efficient solving
 under standard finite assumptions
}
TREEWIDTH_RELATIONSHIP {
 lower structural width MAY enable efficient_dynamic_programming
}
COMPLEXITY {
 general finite-domain CSP includes NP-complete problems
 restricted_classes MAY be tractable
}

VALIDATE_CSP(P) {
 CHECK variables_defined
 CHECK domains_valid
 CHECK constraint_scopes
 CHECK type_compatibility
 CHECK propagator_soundness
 RETURN validation_result
}
VERIFY_SOLUTION(P,A) {
 FOR_EACH Xi: CHECK A(Xi)∈D(Xi)
 FOR_EACH Cj: CHECK Cj(A)=satisfied
 RETURN valid_or_failure
}

APPLICATION_RELATIONSHIPS {
 ConstraintReasoning --supports--> Scheduling
 ConstraintReasoning --supports--> Planning
 ConstraintReasoning --supports--> Configuration
 ConstraintReasoning --supports--> Optimisation
 ConstraintReasoning --supports--> ArtificialIntelligence
 ConstraintReasoning --supports--> FormalVerification
 ConstraintReasoning --supports--> TypeInference
 ConstraintReasoning --supports--> LogicProgramming
 ConstraintReasoning --supports--> ResourceAllocation
}

ONTOLOGY_LINKS {
 PARENT := LogicalReasoningOntology
 RELATED := {
  LogicalInferenceOntology,
  RuleBasedReasoningOntology,
  DeductiveReasoningOntology,
  SatisfiabilityOntology,
  SATOntology,
  SMTOntology,
  UnificationOntology,
  ConstraintProgrammingOntology,
  OptimisationOntology,
  LogicProgrammingOntology
 }
}

SEMANTIC_EQUIVALENCE {
 ConstraintReasoning ≈ ConstraintBasedReasoning
 CSP ≈ ConstraintSatisfactionProblem
 ConstraintPropagation ≈ DomainFiltering WHEN context=constraint_programming
 DomainWipeout ≈ EmptyDomainFailure
}

CONSTRAINTS {
 C1 := every variable MUST have a declared domain
 C2 := every constraint MUST identify its scope and semantics
 C3 := propagation MUST only remove values inconsistent under its declared correctness criterion
 C4 := local consistency MUST NOT automatically be interpreted as global satisfiability
 C5 := domain wipeout MUST be treated as branch inconsistency
 C6 := search heuristics MUST NOT change the valid solution set
 C7 := symmetry-breaking constraints MUST preserve required solution representatives
 C8 := soft and hard constraints MUST remain distinct
 C9 := optimisation MUST preserve hard-constraint feasibility
 C10 := SAT/SMT/CP encodings MUST preserve declared satisfiability semantics
 C11 := unsat-core claims MUST identify the actual inconsistent subset
 C12 := solver conclusions MUST remain scoped to domains, constraints and search assumptions
}

REASONING_CHAIN Query Q {
 IDENTIFY variables
 IDENTIFY domains
 IDENTIFY constraints
 IDENTIFY hard_vs_soft
 IDENTIFY objective_if_any
 IDENTIFY solver_semantics
 VALIDATE_CSP

 APPLY unary_propagation
 APPLY selected_arc_or_generalised_consistency
 REPEAT until propagation_fixed_point

 IF domain_wipeout {
  EXTRACT conflict_or_unsat_explanation
  RETURN inconsistent_branch
 }

 IF all_variables_assigned {
  VERIFY_SOLUTION
  RETURN solution
 }

 SELECT branching_variable
 ORDER candidate_values

 FOR_EACH branch {
  ASSIGN_or_split_domain
  PROPAGATE
  IF failure {
   LEARN nogood_if_supported
   BACKTRACK_or_BACKJUMP
  } ELSE {
   RECURSE
  }
 }

 IF optimisation {
  UPDATE incumbent
  APPLY bounds
  CONTINUE until optimality_proven_or_limit
 }

 BUILD constraint_trace
 VALIDATE constraints
 RETURN solution_status WITH derivation
}

CONFIDENCE {
 CORE_CSP_DEFINITION := 1.00
 ARC_CONSISTENCY := 1.00
 AC3_CORE := 1.00
 PROPAGATION_SEARCH_DISTINCTION := 1.00
 SAT_SMT_RELATIONSHIP := 1.00
 OPTIMISATION_RELATIONSHIP := 1.00
 SPECIFIC_RESULT :=
  IF variables_domains_constraints_complete THEN 1.00
  ELSE REQUIRE missing_information
}

UPDATE_MODEL {
 IMMUTABLE_CORE := {
  VariableDomainConstraintStructure,
  SatisfactionSemantics,
  PropagationSoundness,
  SearchBranching,
  SolutionVerification
 }
 EXTENSIBLE := {
  GlobalConstraints,
  Propagators,
  SearchHeuristics,
  NogoodLearning,
  SATSMTEncodings,
  OptimisationMethods,
  SchedulingModels,
  ApplicationDomains,
  RelatedOntologies
 }
 ON_NEW_KNOWLEDGE {
  IDENTIFY new_variable_or_constraint
  VALIDATE domain
  VALIDATE scope
  PROPAGATE
  CHECK conflicts
  UPDATE dependencies
  UPDATE confidence
 }
}

AI_CONSUMPTION {
 MACHINE_READABLE := TRUE
 HUMAN_INTERPRETABLE := TRUE
 RECURSIVE_REASONING := TRUE
 ENTITY_RESOLUTION := TRUE
 VARIABLE_RESOLUTION := TRUE
 DOMAIN_REASONING := TRUE
 CONSTRAINT_PROPAGATION := TRUE
 ARC_CONSISTENCY_REASONING := TRUE
 SEARCH_REASONING := TRUE
 NOGOOD_REASONING := TRUE
 SAT_SMT_REASONING := TRUE
 OPTIMISATION_REASONING := TRUE
 UNSAT_CORE_REASONING := TRUE
 CONSTRAINT_TRACE_GENERATION := TRUE
 VALIDATION_REQUIRED := TRUE
}

FLOW_HASH {
 TARGET := TARGET_URL
 SUBJECT := "Constraint Reasoning Ontology"
 VERSION := "1.0"
 CANONICAL_SIGNATURE := HASH(TARGET + SUBJECT + DOMAIN + VERSION)
}

OUTPUT {
 PRIMARY_ENTITY := ConstraintReasoning
 INTERPRETATION := "Constraint reasoning represents problems through variables, domains and relations restricting admissible assignments. Propagation removes unsupported values, search explores remaining alternatives, and specialised consistency, learning and optimisation techniques allow systems to find solutions, prove inconsistency or optimise feasible assignments."
}

END_FLOW