2nd/10_Wiki/Topics/AI_and_ML/Constraint Satisfaction Problems (CSP).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-csp	Constraint Satisfaction Problems (CSP)	10_Wiki/Topics	verified	self	CSP 제약 충족 문제 AC-3 backtracking MIP OR-Tools scheduling	none	A	0.93	applied	csp constraint-programming optimization scheduling sat smt ortools backtracking		2026-05-10	pending	language framework Python / C++ 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)

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)

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)

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)

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

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)

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)

% 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)

# 매 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 · Graph_Theory
• 변형: MIP
• 응용: Scheduling · Routing
• Tool: OR-Tools
• 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