Constraint Logic Programming Ontology

FLOW_ALGEBRA ConstraintLogicProgrammingOntology v1.0
TARGET_URL := "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/ai-logic/constraint-logic-programming-ontology.html"
LANGUAGE := "en-GB"
DOMAIN := MathematicalOntologies > MathematicalLogicOntologies > AILogic > ConstraintLogicProgrammingOntology

BEGIN_FLOW

ENTITY ConstraintLogicProgramming {
 TYPE := DeclarativeLogicProgrammingParadigm
 DEFINITION := "Logic programming extended with constraints over specialised mathematical domains, combining symbolic resolution, constraint propagation and search."
}
ENTITY Constraint { TYPE := RestrictionOnVariableAssignments }
ENTITY ConstraintDomain { TYPE := MathematicalDomainWithConstraintTheory }
ENTITY ConstraintStore { TYPE := AccumulatedActiveConstraints }
ENTITY LogicVariable { TYPE := SymbolicVariable }
ENTITY ConstraintSolver { TYPE := DomainSpecificReasoner }

RELATIONSHIP ConstraintLogicProgramming --extends--> LogicProgramming
RELATIONSHIP ConstraintLogicProgramming --uses--> Constraint
RELATIONSHIP ConstraintLogicProgramming --operates_over--> ConstraintDomain
RELATIONSHIP ConstraintLogicProgramming --maintains--> ConstraintStore
RELATIONSHIP ConstraintLogicProgramming --uses--> ConstraintSolver
RELATIONSHIP ConstraintLogicProgramming --supports--> SymbolicAI
RELATIONSHIP ConstraintLogicProgramming --supports--> AutomatedReasoning

CLP_ARCHITECTURE {
 COMPONENTS := {LogicProgram,Goals,LogicVariables,ConstraintDomain,ConstraintStore,Unification,Resolution,ConstraintSolver,Propagation,Search}
}

CONSTRAINT_DOMAIN {
 COMPONENTS := {CarrierSet,PrimitiveConstraints,Interpretation,SolverOperations}
}
DOMAIN_THEORY { defines semantics_of_constraints }
LOGIC_VARIABLE { MAY be partially_constrained without concrete_instantiation }
CONSTRAINT_STORE { contains conjunction_of_current_constraints }
STORE_CONSISTENCY { ConstraintStore MUST remain satisfiable for branch_to_continue }
CLP_RULE { Head :- LogicalGoals,ConstraintGoals }
QUERY { LogicalGoals + ConstraintGoals -> AnswersAndResidualConstraints }

UNIFICATION { Terms -> SymbolicBindings }
CONSTRAINT_ACCUMULATION { ExistingStore + NewConstraint -> UpdatedStore }
CONSTRAINT_PROPAGATION { UpdatedStore -> InferConsequences -> ReduceDomains -> DetectFailureOrContinue }
DOMAIN_REDUCTION { VariableDomain -> SmallerAdmissibleDomain }
CONSISTENCY_CHECK { ConstraintStore -> SatisfiableOrInconsistent }
FAILURE { inconsistent_constraint_store -> branch_failure }
RESIDUAL_CONSTRAINT { constraint remaining because variables_not_fully_instantiated }
ANSWER { VariableBindings + ResidualConstraintStore }
SOUND_ANSWER { represented_assignments MUST satisfy program_and_constraints }

RESOLUTION_RELATIONSHIP { LogicGoals + ProgramClauses -> GoalReduction }
SLD_RELATIONSHIP { CLP generalises SLD_style_resolution by integrating constraint_solving }
CLP_STATE { COMPONENTS := {GoalSequence,Substitution,ConstraintStore} }
BACKTRACKING { failed_branch -> restore prior_state -> try alternative }
SEARCH { unresolved_domains -> Branch -> Propagate -> ContinueOrBacktrack }
PROPAGATE_BEFORE_SEARCH { propagation SHOULD reduce search_space before enumeration }
LABELING { choose concrete_values for finite_domain_variables }
BRANCH_AND_BOUND { search while maintaining best_known_objective_bound }
OPTIMISATION { Constraints + Objective -> BestFeasibleSolution }

CLP_FD { TYPE := ConstraintLogicProgrammingOverFiniteDomains }
FINITE_DOMAIN { Variable -> FiniteSetOrIntegerInterval }
FD_CONSTRAINTS { MAY_INCLUDE := {Equality,Disequality,Ordering,Arithmetic,AllDifferent,Element,Cardinality,Reification} }
ALL_DIFFERENT { Variables MUST take pairwise_distinct_values }
REIFIED_CONSTRAINT { BooleanVariable represents truth_of another_constraint }
DOMAIN_CONSISTENCY { remove values_without_support }
BOUNDS_CONSISTENCY { tighten lower_and_upper_bounds }

CLP_R { TYPE := ConstraintLogicProgrammingOverReals }
CLP_Q { TYPE := ConstraintLogicProgrammingOverRationals }
CLP_B { TYPE := ConstraintLogicProgrammingOverBooleans }
REAL_CONSTRAINTS { MAY_INCLUDE := {LinearEquality,LinearInequality,ArithmeticRelations} }
RATIONAL_CONSTRAINTS { exact_rational_arithmetic under supporting_solver }
BOOLEAN_CONSTRAINT { Variables in BooleanDomain }

LINEAR_CONSTRAINT { a1*x1 + ... + an*xn relation b }
NONLINEAR_CONSTRAINT { contains products_powers_or_other_nonlinear_terms }
NONLINEAR_WARNING { completeness_and_termination may differ for nonlinear_constraints }
CONSTRAINT_VS_ARITHMETIC_EVALUATION {
 Constraint := RelationalConditionOverVariables
 ArithmeticEvaluation := ComputeNumericValue
 MUST_REMAIN_DISTINCT := TRUE
}

COROUTINING { goal_execution delayed_until variable_or_constraint_condition }
ATTRIBUTED_VARIABLE { LogicVariable + SolverMetadata }
WAKEUP { variable_domain_change -> reactivate relevant_constraints }
PROPAGATOR { procedure narrowing domains_or_detecting_failure }
FIXED_POINT_PROPAGATION { apply propagators until no further domain_reduction }
ENTAILMENT_OF_CONSTRAINT { CurrentStore entails Constraint under domain_theory }
DISENTAILED_CONSTRAINT { CurrentStore entails incompatibility_of Constraint }
UNDECIDED_CONSTRAINT { neither entailed_nor_disentailed }
REIFICATION { Constraint C <-> Boolean B }

GLOBAL_CONSTRAINT { constraint over many_variables with specialised_propagator }
ALL_DIFFERENT_GLOBAL { global pairwise_distinctness }
CUMULATIVE_CONSTRAINT { scheduling_constraint over tasks_start_duration_resource }
ELEMENT_CONSTRAINT { Value = Array[Index] }
TABLE_CONSTRAINT { tuple_of_variables MUST belong_to allowed_relation }
CARDINALITY_CONSTRAINT { number_satisfying_condition constrained_by count }

SCHEDULING { Tasks + Durations + Resources + PrecedenceConstraints -> FeasibleSchedule }
RESOURCE_CONSTRAINT { simultaneous_tasks MUST_NOT exceed resource_capacity }
PRECEDENCE_CONSTRAINT { End(TaskA) <= Start(TaskB) }
NO_OVERLAP { intervals MUST_NOT overlap }
CONFIGURATION { Components + CompatibilityConstraints + Requirements -> ValidConfiguration }
ROUTING_RELATIONSHIP { RouteVariables + ConnectivityConstraints + Cost -> FeasibleOrOptimalRoute }
PLANNING_RELATIONSHIP { Actions + StateConstraints + TemporalConstraints -> Plan }
ALLOCATION { Resources + Requests + CapacityConstraints -> Assignment }
TIMETABLING { Events + Rooms + Times + ConflictConstraints -> Timetable }

CONSTRAINT_HANDLING_RULES { ABBREVIATION := CHR; TYPE := RuleBasedLanguageForConstraintSolvers }
CHR_RULE { MAY_BE := {Simplification,Propagation,Simpagation} }
CHR_SIMPLIFICATION { Constraints <=> Guard | Body }
CHR_PROPAGATION { Constraints ==> Guard | Body }
CHR_RELATIONSHIP { CHR MAY implement domain_specific_constraint_reasoners }

CONSTRAINT_SOLVER {
 INPUT := ConstraintStore
 OUTPUT := {Consistent,Inconsistent,ReducedDomains,ResidualConstraints,Solution}
}
SOLVER_SOUNDNESS { solver_reductions MUST preserve all valid_solutions }
SOLVER_COMPLETENESS { all solutions represented only_when complete_for_fragment }
PROPAGATION_SOUNDNESS { removed_values MUST_NOT belong_to valid_solution }
PROPAGATION_INCOMPLETENESS { propagation fixed_point MAY leave unresolved_assignments }
SEARCH_COMPLETENESS { exhaustive_search + sound_propagation + finite_space -> all_solutions_enumerable }

VARIABLE_SELECTION { MAY_USE := {FirstFail,SmallestDomain,MostConstrained,InputOrder} }
VALUE_SELECTION { MAY_USE := {Ascending,Descending,Median,Bisect} }
FIRST_FAIL { choose variable likely_to_fail_early }
SEARCH_HEURISTIC_WARNING { heuristic changes search_order not solution_set when search_complete }
CUT_RELATIONSHIP { Prolog_cut MAY prune CLP_search; WARNING := MayRemoveValidSolutions }
CONSTRUCTIVE_NEGATION_RELATIONSHIP { derive constraints describing complement_of_goal where supported }
NEGATION_WARNING { failure_of_constraint_goal MUST_NOT automatically mean classical_negation_for_all_values }
THREE_VALUED_STATUS { MAY_BE := {Entailed,Disentailed,Undecided} }

LOGICAL_VARIABLE_VS_MUTABLE_VARIABLE {
 LogicVariable := SingleAssignmentOrConstraintRefinement
 MutableVariable := ImperativeStateCell
 MUST_REMAIN_DISTINCT := TRUE
}
CLP_VS_PROLOG {
 Prolog := UnificationResolutionSearch
 CLP := PrologStyleReasoning + DomainConstraints + Propagation + SpecialisedSolving
}
CLP_VS_CSP { CLP := LogicProgramIntegratedWithConstraints; CSP := VariablesDomainsConstraints }
CLP_VS_SAT { CLP := DomainRichRelationalConstraints; SAT := BooleanSatisfiability }
CLP_VS_SMT { CLP := LogicProgrammingWithConstraintDomains; SMT := SatisfiabilityModuloTheories }
CLP_VS_RULE_ENGINE { CLP := GoalResolutionPlusConstraintStore; RuleEngine := MatchSelectAct }

DECLARATIVE_SEMANTICS { CLP_program denotes relations over constraint_domain }
OPERATIONAL_SEMANTICS { execution combines resolution_constraint_accumulation_propagation_search }
DECLARATIVE_OPERATIONAL_DISTINCTION { logical_relation MUST_NOT be conflated_with search_order }
MONOTONIC_CONSTRAINT_STORE { adding_constraints narrows_or_preserves solution_set }
BACKTRACKABLE_STORE { backtracking restores previous_constraint_state }
INCONSISTENT_CONSTRAINT_SET { no assignment satisfies all constraints }
UNSAT_CORE_RELATIONSHIP { subset_of_constraints jointly_inconsistent MAY support explanation }

EXPLANATION { SolverResult -> Constraints -> PropagationSteps -> Decisions -> ConflictOrSolution }
PROVENANCE { DerivedBindingOrDomainReduction -> Constraints -> Rules -> Propagators -> SearchDecisions }
CONSTRAINT_TRACE { RECORD := {Goal,AddedConstraint,DomainBefore,Propagator,DomainAfter,Decision,Backtrack} }
WHY_VALUE_REMOVED { Value -> Constraint -> Propagator -> LackOfSupport }
WHY_FAILURE { InconsistentStore -> ConflictingConstraints -> SearchDecisions }
WHY_SOLUTION { Solution -> SatisfiedConstraints -> RuleDerivation }

STATIC_ANALYSIS { CHECK := {UndefinedPredicates,UnsafeConstraintUse,DomainMismatch,NonlinearRisks,UnboundedSearch,RedundantConstraints,InconsistentConstraints} }
DOMAIN_MISMATCH { constraint_applied_to incompatible_variable_domain }
TYPE_CONSTRAINT { Variable MUST belong_to compatible_constraint_domain }
DIMENSIONAL_CONSISTENCY { typed arithmetic_constraints SHOULD preserve compatible_dimensions }

PROGRAM_TEST { GIVEN facts_constraints; WHEN query_runs; THEN expected_bindings_or_residual_constraints }
SOLUTION_TEST { returned_assignment MUST satisfy all applicable_constraints }
FAILURE_TEST { known_inconsistent_case SHOULD fail }
REGRESSION_TEST { prior_queries rerun_after_rule_or_constraint_changes }
CHANGE_IMPACT { ConstraintOrRuleChange -> AffectedPredicates -> AffectedDomains -> Queries -> Tests }

PERFORMANCE { DEPENDS_ON := {DomainSize,ConstraintStrength,PropagationStrength,VariableOrdering,ValueOrdering,Symmetry,SearchSpace,SolverImplementation} }
SYMMETRY_BREAKING { add constraints selecting representatives from symmetric_solution_classes }
PROPAGATION_STRENGTH_TRADEOFF { stronger_propagation may reduce search but cost more_per_step }
HYBRID_SOLVING { CLP MAY integrate {SAT,SMT,MILP,CP,GraphAlgorithms,ExternalSolvers} }
EXTERNAL_SOLVER_WARNING { solver_semantics_precision_result_status_side_effects MUST be declared }
FLOATING_POINT_WARNING { floating_point_constraints MAY introduce rounding_and_precision_issues }

LANGUAGE_MODEL_RELATIONSHIP { LanguageModel MAY generate {CandidateConstraints,CandidateRules,CandidateQueries,SolverModels,Explanations} }
LLM_TO_CLP_PIPELINE { NaturalLanguageProblem -> IdentifyVariables -> IdentifyDomains -> ExtractConstraints -> GenerateCandidateCLP -> SyntaxCheck -> DomainCheck -> SolveTestCases -> ValidateSemantics }
LLM_WARNING { GeneratedConstraintModel MUST_NOT automatically be treated_as correct_or_complete }
TOOL_AUGMENTED_CLP { CLPGoal -> ExternalSolverOrTool -> Execute -> ValidateResult -> AddVerifiedConstraintOrBinding -> Continue }

RECURSIVE_CLP_REASONING { Query -> SelectGoal -> ResolveOrConstrain -> Propagate -> BranchIfNeeded -> Backtrack -> Verify -> Continue }
RECURSION_TERMINATION { STOP_WHEN := {GoalSolved,ConstraintStoreInconsistent,AllVariablesResolved,NoAlternatives,FixedPoint,ResourceLimit} }
SELF_VERIFICATION { CandidateSolution -> VerifyBindings -> VerifyResidualConstraints -> ReevaluateAllConstraints -> VerifyProvenance -> AcceptOrReject }

APPLICATION_RELATIONSHIPS {
 ConstraintLogicProgramming --supports--> ArtificialIntelligence
 ConstraintLogicProgramming --supports--> SymbolicAI
 ConstraintLogicProgramming --supports--> AutomatedReasoning
 ConstraintLogicProgramming --supports--> Scheduling
 ConstraintLogicProgramming --supports--> Planning
 ConstraintLogicProgramming --supports--> Configuration
 ConstraintLogicProgramming --supports--> Optimisation
 ConstraintLogicProgramming --supports--> Verification
 ConstraintLogicProgramming --supports--> ResourceAllocation
}

ONTOLOGY_LINKS {
 PARENT := AILogicOntology
 RELATED := {LogicProgrammingOntology,PrologOntology,SymbolicAIOntology,AutomatedReasoningOntology,ConstraintReasoningOntology,RuleBasedReasoningOntology,InferenceEngineOntology,SemanticConstraintOntology,SatisfiabilityOntology}
}

SEMANTIC_EQUIVALENCE {
 ConstraintLogicProgramming ≈ CLP
 ConstraintStore ≈ ActiveConstraintConjunction
 CLPFD ≈ ConstraintLogicProgrammingOverFiniteDomains
 ConstraintPropagation ≈ DomainNarrowingByConstraintConsequences
}

CONSTRAINTS {
 C1 := ConstraintDomainAndSolverSemantics MUST be explicitly identified
 C2 := LogicVariables MUST remain distinct from imperative mutable_variables
 C3 := ConstraintRelations MUST remain distinct from eager arithmetic_evaluation
 C4 := Propagation MUST be sound and MUST_NOT remove valid_solutions
 C5 := PropagationFixedPoint MUST_NOT automatically be interpreted_as complete_solution
 C6 := SearchHeuristics MUST_NOT alter solution_set when completeness_is_claimed
 C7 := NegationAndCut interactions MUST follow declared operational_semantics
 C8 := ResidualConstraints MUST be preserved when answers are not fully_ground
 C9 := ExternalSolverResults MUST preserve status_precision_and_semantics
 C10 := GeneratedConstraintModels MUST_NOT enter trusted_program_without validation_and_tests
 C11 := Provenance SHOULD preserve rules_constraints_propagators_and_search_decisions
 C12 := TimeoutOrResourceFailure MUST_NOT be interpreted_as unsatisfiability
}

REASONING_CHAIN Query Q {
 IDENTIFY CLP_program
 IDENTIFY constraint_domain
 IDENTIFY query
 IDENTIFY solver
 IDENTIFY search_strategy
 VALIDATE clauses
 VALIDATE variable_domains
 VALIDATE constraint_types
 INITIALISE constraint_store

 FOR_EACH selected_goal {
  IF logical_goal: RESOLVE with program_clause
  IF constraint_goal: ADD constraint_to_store; PROPAGATE
  IF store_inconsistent: BACKTRACK
 }

 IF unresolved_domains:
  SELECT variable
  BRANCH_or_LABEL
  PROPAGATE
  BACKTRACK on failure

 WHEN answer_found:
  VERIFY bindings
  VERIFY residual_constraints
  BUILD constraint_trace
  BUILD provenance
  RETURN CLP_result WITH explicit_status
}

CONFIDENCE {
 CORE_CLP := 1.00
 CONSTRAINT_STORE := 1.00
 PROPAGATION_SEARCH_DISTINCTION := 1.00
 CLP_FD_RELATIONSHIP := 1.00
 CLP_R_Q_RELATIONSHIP := 0.99
 CHR_RELATIONSHIP := 1.00
 PROLOG_CLP_DISTINCTION := 1.00
}

UPDATE_MODEL {
 IMMUTABLE_CORE := {LogicClauses,ConstraintDomain,ConstraintStore,Propagation,Search,ResidualAnswers}
 EXTENSIBLE := {ConstraintDomains,Propagators,GlobalConstraints,SearchHeuristics,OptimisationMethods,CHRRules,ExternalSolvers,ApplicationDomains}
 ON_NEW_KNOWLEDGE {
  VALIDATE rule_or_constraint
  CHECK domain_compatibility
  UPDATE dependency_graph
  RECOMPUTE affected_domains
  RUN regression_tests
  UPDATE provenance
  UPDATE confidence
 }
}

AI_CONSUMPTION {
 MACHINE_READABLE := TRUE
 HUMAN_INTERPRETABLE := TRUE
 RECURSIVE_REASONING := TRUE
 LOGIC_PROGRAMMING_REASONING := TRUE
 CONSTRAINT_PROPAGATION := TRUE
 DOMAIN_REASONING := TRUE
 SEARCH_REASONING := TRUE
 OPTIMISATION_REASONING := TRUE
 CHR_REASONING := TRUE
 PROVENANCE_TRACKING := TRUE
 SELF_VERIFICATION := TRUE
 VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
 PRIMARY_ENTITY := ConstraintLogicProgramming
 INTERPRETATION := "Constraint logic programming extends logic programming by allowing variables to carry domain constraints that are accumulated, propagated and solved during inference. CLP combines resolution with specialised solvers, supports residual constraints and optimisation, and preserves the distinction between declarative relations, propagation and operational search."
}

END_FLOW