Antigravity Agent
311 lines
9.2 KiB
Markdown
311 lines
9.2 KiB
Markdown
---
|
||
id: wiki-2026-0508-csp
|
||
title: Constraint Satisfaction Problems (CSP)
|
||
category: 10_Wiki/Topics
|
||
status: verified
|
||
canonical_id: self
|
||
aliases: [CSP, 제약 충족 문제, AC-3, backtracking, MIP, OR-Tools, scheduling]
|
||
duplicate_of: none
|
||
source_trust_level: A
|
||
confidence_score: 0.93
|
||
verification_status: applied
|
||
tags: [csp, constraint-programming, optimization, scheduling, sat, smt, ortools, backtracking]
|
||
raw_sources: []
|
||
last_reinforced: 2026-05-10
|
||
github_commit: pending
|
||
tech_stack:
|
||
language: Python / C++
|
||
framework: OR-Tools / Z3 / MiniZinc / Choco
|
||
---
|
||
|
||
# Constraint Satisfaction Problems (CSP)
|
||
|
||
## 매 한 줄
|
||
> **"매 rule 의 break X + 매 fill"**. 매 (Variables, Domains, Constraints) 의 triple. 매 backtracking + 매 propagation. 매 modern: OR-Tools, Z3 SMT, MiniZinc. 매 scheduling, 매 routing, 매 puzzle 의 NP-hard 의 practical 접근.
|
||
|
||
## 매 핵심
|
||
|
||
### 매 components
|
||
- **Variables** (X): 매 assignable.
|
||
- **Domains** (D): 매 possible values.
|
||
- **Constraints** (C): 매 relations.
|
||
|
||
### 매 type
|
||
- **Boolean**: SAT.
|
||
- **Integer / discrete**: pure CSP.
|
||
- **Continuous**: linear / convex / nonlinear programming.
|
||
- **Mixed Integer**: MIP.
|
||
- **SMT**: 매 first-order theory.
|
||
|
||
### 매 algorithm
|
||
|
||
#### Backtracking
|
||
- 매 DFS + 매 backtrack on constraint violation.
|
||
- 매 baseline.
|
||
|
||
#### Constraint Propagation
|
||
- **AC-3** (Arc Consistency): 매 inconsistent value 의 prune.
|
||
- **Forward Checking**: 매 variable assignment 시 의 future variable 의 prune.
|
||
|
||
#### Heuristic
|
||
- **MRV** (Minimum Remaining Values): 매 가장 constrained variable first.
|
||
- **Degree heuristic**: 매 매 connected variable.
|
||
- **LCV** (Least Constraining Value): 매 future flexibility maximize.
|
||
|
||
#### Local search
|
||
- **Min-conflicts**: 매 random init + 매 conflict reduce.
|
||
- **Simulated annealing**.
|
||
- **Tabu search**.
|
||
|
||
### 매 SAT (special case)
|
||
- 매 boolean only.
|
||
- 매 CNF form.
|
||
- 매 modern solver: Glucose, MiniSat, Kissat.
|
||
- 매 reduction: 매 다른 NP-complete 의 SAT.
|
||
|
||
### SMT (extended)
|
||
- 매 first-order theory + decision procedure.
|
||
- 매 theory: arithmetic, arrays, bitvectors, strings.
|
||
- 매 Z3, CVC5, Yices.
|
||
|
||
### 매 MIP (Mixed Integer Programming)
|
||
- 매 LP relaxation + branch & bound.
|
||
- 매 Gurobi, CPLEX, OR-Tools.
|
||
|
||
### CP-SAT (modern)
|
||
- 매 OR-Tools 의 hybrid.
|
||
- 매 CP + SAT.
|
||
- 매 매 fastest 의 industrial scheduling.
|
||
|
||
### 매 응용
|
||
1. **Scheduling**: 매 work, 매 sport, 매 exam.
|
||
2. **Routing** (VRP).
|
||
3. **Resource allocation**.
|
||
4. **Configuration** (car options).
|
||
5. **Puzzle** (Sudoku, N-Queens, Zebra).
|
||
6. **Verification** (SMT).
|
||
7. **Compiler** (register allocation).
|
||
|
||
## 💻 패턴
|
||
|
||
### N-Queens (backtracking)
|
||
```python
|
||
def solve_n_queens(n):
|
||
queens = [-1] * n
|
||
|
||
def backtrack(row):
|
||
if row == n: return [queens[:]]
|
||
solutions = []
|
||
for col in range(n):
|
||
if all(queens[r] != col and abs(queens[r] - col) != row - r
|
||
for r in range(row)):
|
||
queens[row] = col
|
||
solutions.extend(backtrack(row + 1))
|
||
return solutions
|
||
|
||
return backtrack(0)
|
||
|
||
print(len(solve_n_queens(8))) # 92
|
||
```
|
||
|
||
### AC-3 (constraint propagation)
|
||
```python
|
||
def ac3(domains, constraints):
|
||
"""매 arc consistency."""
|
||
queue = [(x, y) for (x, y) in constraints]
|
||
while queue:
|
||
(x, y) = queue.pop(0)
|
||
if revise(domains, x, y, constraints):
|
||
if not domains[x]: return False
|
||
for z in neighbors(x):
|
||
if z != y: queue.append((z, x))
|
||
return True
|
||
|
||
def revise(domains, x, y, constraints):
|
||
revised = False
|
||
for vx in list(domains[x]):
|
||
if not any(constraint_holds(x, vx, y, vy, constraints) for vy in domains[y]):
|
||
domains[x].remove(vx)
|
||
revised = True
|
||
return revised
|
||
```
|
||
|
||
### Sudoku (OR-Tools CP-SAT)
|
||
```python
|
||
from ortools.sat.python import cp_model
|
||
|
||
def solve_sudoku(grid):
|
||
model = cp_model.CpModel()
|
||
|
||
# 매 9×9 variable
|
||
cells = [[model.NewIntVar(1, 9, f'c{r}{c}') for c in range(9)] for r in range(9)]
|
||
|
||
# 매 given clues
|
||
for r in range(9):
|
||
for c in range(9):
|
||
if grid[r][c] != 0:
|
||
model.Add(cells[r][c] == grid[r][c])
|
||
|
||
# 매 row / col / box uniqueness
|
||
for r in range(9):
|
||
model.AddAllDifferent(cells[r])
|
||
for c in range(9):
|
||
model.AddAllDifferent([cells[r][c] for r in range(9)])
|
||
for br in range(3):
|
||
for bc in range(3):
|
||
model.AddAllDifferent([cells[3*br + i][3*bc + j] for i in range(3) for j in range(3)])
|
||
|
||
solver = cp_model.CpSolver()
|
||
if solver.Solve(model) == cp_model.OPTIMAL:
|
||
return [[solver.Value(cells[r][c]) for c in range(9)] for r in range(9)]
|
||
return None
|
||
```
|
||
|
||
### Job Shop Scheduling (OR-Tools)
|
||
```python
|
||
from ortools.sat.python import cp_model
|
||
|
||
def schedule_jobs(jobs):
|
||
model = cp_model.CpModel()
|
||
horizon = sum(t for job in jobs for _, t in job)
|
||
|
||
all_tasks = {}
|
||
machine_to_intervals = collections.defaultdict(list)
|
||
|
||
for j_id, job in enumerate(jobs):
|
||
for t_id, (machine, duration) in enumerate(job):
|
||
start = model.NewIntVar(0, horizon, f'start_{j_id}_{t_id}')
|
||
end = model.NewIntVar(0, horizon, f'end_{j_id}_{t_id}')
|
||
interval = model.NewIntervalVar(start, duration, end, f'interval_{j_id}_{t_id}')
|
||
all_tasks[(j_id, t_id)] = (start, end, interval)
|
||
machine_to_intervals[machine].append(interval)
|
||
|
||
# 매 매 machine 의 1 task 만 의 동시.
|
||
for intervals in machine_to_intervals.values():
|
||
model.AddNoOverlap(intervals)
|
||
|
||
# 매 매 job 의 sequence (precedence).
|
||
for j_id, job in enumerate(jobs):
|
||
for t_id in range(len(job) - 1):
|
||
model.Add(all_tasks[(j_id, t_id+1)][0] >= all_tasks[(j_id, t_id)][1])
|
||
|
||
# 매 minimize makespan
|
||
makespan = model.NewIntVar(0, horizon, 'makespan')
|
||
model.AddMaxEquality(makespan, [all_tasks[(j_id, len(job)-1)][1] for j_id, job in enumerate(jobs)])
|
||
model.Minimize(makespan)
|
||
|
||
solver = cp_model.CpSolver()
|
||
solver.Solve(model)
|
||
return solver.ObjectiveValue()
|
||
```
|
||
|
||
### Z3 SMT
|
||
```python
|
||
from z3 import *
|
||
|
||
# 매 example: 매 8-puzzle solvability check
|
||
s = Solver()
|
||
x = [Int(f'x_{i}') for i in range(9)]
|
||
s.add([0 <= xi for xi in x])
|
||
s.add([xi <= 8 for xi in x])
|
||
s.add(Distinct(x))
|
||
|
||
s.add(x[0] == 1)
|
||
s.add(x[1] == 2)
|
||
# ...
|
||
|
||
if s.check() == sat:
|
||
print(s.model())
|
||
```
|
||
|
||
### Vehicle Routing (VRP)
|
||
```python
|
||
from ortools.constraint_solver import routing_enums_pb2, pywrapcp
|
||
|
||
manager = pywrapcp.RoutingIndexManager(num_nodes, num_vehicles, depot)
|
||
routing = pywrapcp.RoutingModel(manager)
|
||
|
||
def distance_callback(from_index, to_index):
|
||
return distance_matrix[manager.IndexToNode(from_index)][manager.IndexToNode(to_index)]
|
||
|
||
transit_idx = routing.RegisterTransitCallback(distance_callback)
|
||
routing.SetArcCostEvaluatorOfAllVehicles(transit_idx)
|
||
|
||
params = pywrapcp.DefaultRoutingSearchParameters()
|
||
params.first_solution_strategy = routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
|
||
|
||
solution = routing.SolveWithParameters(params)
|
||
```
|
||
|
||
### MiniZinc (declarative)
|
||
```minizinc
|
||
% n-queens.mzn
|
||
int: n = 8;
|
||
array[1..n] of var 1..n: q;
|
||
|
||
constraint forall(i, j in 1..n where i < j) (
|
||
q[i] != q[j] /\
|
||
q[i] - q[j] != i - j /\
|
||
q[i] - q[j] != j - i
|
||
);
|
||
|
||
solve satisfy;
|
||
```
|
||
|
||
### ML-aided heuristic (RL for branching)
|
||
```python
|
||
# 매 modern: RL 의 branching variable selection
|
||
class LearnedHeuristic:
|
||
def __init__(self, model):
|
||
self.model = model
|
||
|
||
def select_variable(self, state):
|
||
"""매 state 의 features → 매 best variable to branch."""
|
||
features = encode_state(state)
|
||
return self.model.predict(features)
|
||
```
|
||
|
||
## 🤔 결정 기준
|
||
| 문제 | Tool |
|
||
|---|---|
|
||
| Boolean SAT | Glucose, Kissat |
|
||
| SMT (math) | Z3, CVC5 |
|
||
| Discrete CSP | OR-Tools CP-SAT |
|
||
| MIP (large) | Gurobi, CPLEX |
|
||
| Scheduling | OR-Tools CP-SAT |
|
||
| Routing | OR-Tools |
|
||
| Continuous | scipy.optimize |
|
||
| Declarative | MiniZinc |
|
||
|
||
**기본값**: OR-Tools CP-SAT 의 baseline (free + fast).
|
||
|
||
## 🔗 Graph
|
||
- 부모: [[Combinatorial-Optimization]] · [[AI-Search]] · [[Graph-Theory]]
|
||
- 변형: [[SAT]] · [[SMT]] · [[MIP]] · [[CP]]
|
||
- 응용: [[Scheduling]] · [[Routing]] · [[Verification]]
|
||
- Tool: [[OR-Tools]] · [[Z3]] · [[Gurobi]] · [[MiniZinc]]
|
||
- Adjacent: [[Black-Box-Optimization]] · [[Automated-Theorem-Proving]] · [[Bayesian-Statistics]]
|
||
|
||
## 🤖 LLM 활용
|
||
**언제**: 매 scheduling, 매 routing, 매 configuration. 매 verification. 매 puzzle.
|
||
**언제 X**: 매 differentiable problem (gradient descent). 매 black-box (BO).
|
||
|
||
## ❌ 안티패턴
|
||
- **No propagation**: 매 backtracking 만.
|
||
- **MRV / LCV 무시**: 매 inefficient.
|
||
- **Wrong solver for problem class**: 매 SAT for continuous.
|
||
- **No problem decomposition**: 매 huge instance 의 fail.
|
||
- **Constraint 의 redundant 의 add**: 매 solver 의 hint.
|
||
- **Single solution mode**: 매 enumerate 의 expensive.
|
||
|
||
## 🧪 검증 / 중복
|
||
- Verified (Russell-Norvig AI book, OR-Tools docs, Handbook of CP).
|
||
- 신뢰도 A.
|
||
- Related: [[Black-Box-Optimization]] · [[Automated-Theorem-Proving]] · [[Bayesian-Statistics]] · [[Causal-Inference]].
|
||
|
||
## 🕓 Changelog
|
||
| 날짜 | 변경 |
|
||
|---|---|
|
||
| 2026-05-08 | Phase 1 |
|
||
| 2026-05-10 | Manual cleanup — type + algorithm + 매 N-Queens / AC-3 / Sudoku / JSP / VRP code |
|