solvor 0.3.1__py3-none-any.whl

solvor/__init__.py

@@ -0,0 +1,21 @@
+"""Solvor - Pure Python Optimization Solvers."""
+
+from solvor.types import Status, Result
+from solvor.simplex import solve_lp
+from solvor.tabu import tabu_search, solve_tsp
+from solvor.anneal import anneal
+from solvor.milp import solve_milp
+from solvor.sat import solve_sat
+from solvor.cp import Model
+from solvor.bayesian import bayesian_opt
+from solvor.genetic import evolve
+from solvor.flow import max_flow, min_cost_flow, solve_assignment
+from solvor.gradient import gradient_descent, momentum, adam
+
+__all__ = [
+    "solve_lp", "solve_milp", "tabu_search", "solve_tsp", "anneal",
+    "solve_sat", "Model", "bayesian_opt", "evolve",
+    "max_flow", "min_cost_flow", "solve_assignment",
+    "gradient_descent", "momentum", "adam",
+    "Status", "Result",
+]

solvor/anneal.py

@@ -0,0 +1,80 @@
+"""
+Simulated Annealing - Probabilistic Metaheuristic for Global Optimization
+
+Escapes local optima by accepting worse solutions with probability exp(-delta/T).
+Temperature T decreases over time following a cooling schedule, gradually shifting
+from exploration (high T) to exploitation (low T).
+
+Usage:
+    from solvor.anneal import anneal, Status
+    result = anneal(initial, objective_fn, neighbors)
+    result = anneal(initial, objective_fn, neighbors, minimize=False)
+
+Parameters:
+    initial       : Starting solution
+    objective_fn  : solution -> float (value to minimize)
+    neighbors     : solution -> new_solution (random neighbor generator)
+    minimize      : True for min, False for max (default: True)
+    temperature   : Starting temperature (default: 1000.0)
+    cooling       : Multiplicative cooling factor per iteration (default: 0.9995)
+    min_temp      : Stop when temperature falls below this (default: 1e-8)
+    max_iter      : Maximum iterations (default: 100,000)
+
+Returns Result(solution, objective, iterations, evaluations, status)
+
+Parameter impact:
+    temperature too low  -> trapped in local_optimum early
+    temperature too high -> random walk, slow convergence
+    cooling too fast     -> insufficient exploration
+    cooling too slow     -> wastes iterations at high temperature
+"""
+
+from collections.abc import Callable
+from math import exp
+from random import random
+from solvor.types import Status, Result
+
+__all__ = ["anneal", "Status", "Result"]
+
+def anneal[T](
+    initial: T,
+    objective_fn: Callable[[T], float],
+    neighbors: Callable[[T], T],
+    *,
+    minimize: bool = True,
+    temperature: float = 1000.0,
+    cooling: float = 0.9995,
+    min_temp: float = 1e-8,
+    max_iter: int = 100_000,
+) -> Result:
+    """(initial, objective_fn, neighbors, opts) -> Result with best_solution found."""
+    sign = 1 if minimize else -1
+    evals = 0
+
+    def evaluate(sol):
+        nonlocal evals
+        evals += 1
+        return sign * objective_fn(sol)
+
+    solution, obj = initial, evaluate(initial)
+    best_solution, best_obj = solution, obj
+
+    for iteration in range(1, max_iter + 1):
+        if temperature < min_temp:
+            break
+
+        neighbor = neighbors(solution)
+        neighbor_obj = evaluate(neighbor)
+        delta = neighbor_obj - obj
+
+        if delta < 0 or random() < exp(-delta / temperature):
+            solution, obj = neighbor, neighbor_obj
+
+            if obj < best_obj:
+                best_solution, best_obj = solution, obj
+
+        temperature *= cooling
+
+    final_obj = best_obj * sign
+    status = Status.MAX_ITER if iteration == max_iter else Status.FEASIBLE
+    return Result(best_solution, final_obj, iteration, evals, status)

solvor/bayesian.py

@@ -0,0 +1,149 @@
+"""
+Bayesian Optimization - Gaussian Process-based Global Optimization
+
+Optimizes expensive black-box functions using a Gaussian Process surrogate
+model and Expected Improvement acquisition function. Ideal for hyperparameter
+tuning where function evaluations are costly.
+
+Usage:
+    from solvor.bayesian import bayesian_opt, Status
+    result = bayesian_opt(objective_fn, bounds=[(0, 1), (0, 1)], max_iter=50)
+    result = bayesian_opt(f, bounds, minimize=False)  # maximize
+
+Parameters:
+    objective_fn  : x -> float (function to optimize, x is list of floats)
+    bounds        : List of (low, high) tuples for each dimension
+    minimize      : True for min, False for max (default: True)
+    max_iter      : Number of iterations (default: 50)
+    n_initial     : Random initial samples before GP (default: 5)
+    seed          : Random seed (default: None)
+
+Returns Result(solution, objective, iterations, evaluations, status)
+    solution = best input found (list of floats)
+    objective = best objective value
+
+How it works:
+    1. Sample n_initial random points
+    2. Fit Gaussian Process to observations
+    3. Find next point by maximizing Expected Improvement
+    4. Evaluate objective at new point, repeat from step 2
+"""
+
+from collections.abc import Callable, Sequence
+from math import sqrt, exp, pi, erf
+from random import Random
+from solvor.types import Status, Result
+
+__all__ = ["bayesian_opt", "Status", "Result"]
+
+def bayesian_opt(
+    objective_fn: Callable[[Sequence[float]], float],
+    bounds: Sequence[tuple[float, float]],
+    *,
+    minimize: bool = True,
+    max_iter: int = 50,
+    n_initial: int = 5,
+    seed: int | None = None,
+) -> Result:
+    """(objective_fn, bounds, opts) -> Result with best solution found."""
+    rng = Random(seed)
+    sign = 1 if minimize else -1
+    n_dims = len(bounds)
+    evals = 0
+
+    def evaluate(x):
+        nonlocal evals
+        evals += 1
+        return sign * objective_fn(x)
+
+    def random_point():
+        return [rng.uniform(lo, hi) for lo, hi in bounds]
+
+    xs = [random_point() for _ in range(n_initial)]
+    ys = [evaluate(x) for x in xs]
+
+    best_idx = min(range(len(ys)), key=lambda i: ys[i])
+    best_x, best_y = xs[best_idx], ys[best_idx]
+
+    length_scales = [(hi - lo) / 2 for lo, hi in bounds]
+
+    def kernel(x1, x2):
+        sq_dist = sum(((a - b) / ls) ** 2 for a, b, ls in zip(x1, x2, length_scales))
+        return exp(-0.5 * sq_dist)
+
+    def gp_predict(x_new, X, Y, noise=1e-6):
+        n = len(X)
+        if n == 0:
+            return 0.0, 1.0
+
+        K = [[kernel(X[i], X[j]) + (noise if i == j else 0) for j in range(n)] for i in range(n)]
+        k_star = [kernel(x_new, X[i]) for i in range(n)]
+
+        K_inv_y = _solve_linear(K, Y)
+        K_inv_k = _solve_linear(K, k_star)
+
+        mu = sum(k_star[i] * K_inv_y[i] for i in range(n))
+        var = kernel(x_new, x_new) - sum(k_star[i] * K_inv_k[i] for i in range(n))
+        var = max(var, 1e-10)
+
+        return mu, sqrt(var)
+
+    def expected_improvement(x, X, Y, best_y, xi=0.01):
+        mu, sigma = gp_predict(x, X, Y)
+        if sigma < 1e-10:
+            return 0.0
+
+        z = (best_y - mu - xi) / sigma
+        ei = (best_y - mu - xi) * _norm_cdf(z) + sigma * _norm_pdf(z)
+        return ei
+
+    for iteration in range(n_initial, max_iter):
+        best_ei, best_candidate = -float('inf'), None
+
+        for _ in range(100 * n_dims):
+            candidate = random_point()
+            ei = expected_improvement(candidate, xs, ys, best_y)
+            if ei > best_ei:
+                best_ei, best_candidate = ei, candidate
+
+        if best_candidate is None:
+            best_candidate = random_point()
+
+        y_new = evaluate(best_candidate)
+        xs.append(best_candidate)
+        ys.append(y_new)
+
+        if y_new < best_y:
+            best_x, best_y = best_candidate, y_new
+
+    final_obj = best_y * sign
+    return Result(best_x, final_obj, max_iter, evals, Status.FEASIBLE)
+
+def _solve_linear(A, b):
+    n = len(A)
+    aug = [row[:] + [b[i]] for i, row in enumerate(A)]
+
+    for col in range(n):
+        max_row = max(range(col, n), key=lambda r: abs(aug[r][col]))
+        aug[col], aug[max_row] = aug[max_row], aug[col]
+
+        pivot = aug[col][col]
+        if abs(pivot) < 1e-12:
+            continue
+
+        for j in range(col, n + 1):
+            aug[col][j] /= pivot
+
+        for row in range(n):
+            if row != col:
+                factor = aug[row][col]
+                for j in range(col, n + 1):
+                    aug[row][j] -= factor * aug[col][j]
+
+    return [aug[i][n] for i in range(n)]
+
+def _norm_pdf(x):
+    return exp(-0.5 * x * x) / sqrt(2 * pi)
+
+def _norm_cdf(x):
+    return 0.5 * (1 + erf(x / sqrt(2)))

solvor/cp.py

@@ -0,0 +1,289 @@
+"""
+CP-SAT Solver - Constraint Programming via SAT Encoding
+
+Solves constraint satisfaction problems by encoding integer variables and
+constraints into SAT clauses, then solving with the SAT backend.
+
+Usage:
+    from solvor.cp import Model, Status
+    m = Model()
+    x = m.int_var(0, 9, 'x')
+    y = m.int_var(0, 9, 'y')
+    m.add(m.all_different([x, y]))
+    m.add(x + y == 10)
+    result = m.solve()
+    print(result.solution)  # {'x': 3, 'y': 7} or similar
+
+Supported constraints:
+    all_different(vars)     - All variables take distinct values
+    sum(vars) == k          - Sum equals constant
+    sum(vars) <= k          - Sum at most constant
+    sum(vars) >= k          - Sum at least constant
+    var == k                - Variable equals constant
+    var != k                - Variable not equal constant
+    var1 == var2            - Variables equal
+    var1 != var2            - Variables different
+
+Returns Result(solution, objective, iterations, evaluations, status)
+    solution = dict mapping variable names to values
+    objective = 0 (satisfaction only, no optimization)
+"""
+
+from itertools import combinations
+from solvor.sat import solve_sat, Status as SATStatus
+from solvor.types import Status, Result
+
+__all__ = ["Model", "Status", "Result"]
+
+class IntVar:
+    def __init__(self, model, lb, ub, name):
+        self.model = model
+        self.lb = lb
+        self.ub = ub
+        self.name = name
+        self.bool_vars = {}
+        for v in range(lb, ub + 1):
+            self.bool_vars[v] = model._new_bool_var()
+
+    def __eq__(self, other):
+        if isinstance(other, int):
+            return ('eq_const', self, other)
+        if isinstance(other, IntVar):
+            return ('eq_var', self, other)
+        return NotImplemented
+
+    def __ne__(self, other):
+        if isinstance(other, int):
+            return ('ne_const', self, other)
+        if isinstance(other, IntVar):
+            return ('ne_var', self, other)
+        return NotImplemented
+
+    def __add__(self, other):
+        return ('add', self, other)
+
+    def __radd__(self, other):
+        return ('add', other, self)
+
+class Model:
+    def __init__(self):
+        self._next_bool = 1
+        self._vars = {}
+        self._constraints = []
+        self._clauses = []
+
+    def _new_bool_var(self):
+        v = self._next_bool
+        self._next_bool += 1
+        return v
+
+    def int_var(self, lb, ub, name=None):
+        """(lb, ub, name) -> IntVar with domain [lb, ub]."""
+        if name is None:
+            name = f"_v{len(self._vars)}"
+        var = IntVar(self, lb, ub, name)
+        self._vars[name] = var
+        return var
+
+    def all_different(self, variables):
+        """(vars) -> constraint that all variables take different values."""
+        return ('all_different', tuple(variables))
+
+    def add(self, constraint):
+        """(constraint) -> add constraint to model."""
+        self._constraints.append(constraint)
+
+    def _encode_exactly_one(self, lits):
+        if not lits:
+            return
+        self._clauses.append(lits)
+        for a, b in combinations(lits, 2):
+            self._clauses.append([-a, -b])
+
+    def _encode_at_most_one(self, lits):
+        for a, b in combinations(lits, 2):
+            self._clauses.append([-a, -b])
+
+    def _encode_vars(self):
+        for var in self._vars.values():
+            lits = [var.bool_vars[v] for v in range(var.lb, var.ub + 1)]
+            self._encode_exactly_one(lits)
+
+    def _encode_all_different(self, variables):
+        all_vals = set()
+        for var in variables:
+            all_vals.update(range(var.lb, var.ub + 1))
+
+        for val in all_vals:
+            lits = []
+            for var in variables:
+                if val in var.bool_vars:
+                    lits.append(var.bool_vars[val])
+            if len(lits) > 1:
+                self._encode_at_most_one(lits)
+
+    def _encode_eq_const(self, var, val):
+        if val in var.bool_vars:
+            self._clauses.append([var.bool_vars[val]])
+        else:
+            self._clauses.append([])
+
+    def _encode_ne_const(self, var, val):
+        if val in var.bool_vars:
+            self._clauses.append([-var.bool_vars[val]])
+
+    def _encode_eq_var(self, var1, var2):
+        common = set(var1.bool_vars.keys()) & set(var2.bool_vars.keys())
+        for val in common:
+            self._clauses.append([-var1.bool_vars[val], var2.bool_vars[val]])
+            self._clauses.append([var1.bool_vars[val], -var2.bool_vars[val]])
+
+        for val in set(var1.bool_vars.keys()) - common:
+            self._clauses.append([-var1.bool_vars[val]])
+        for val in set(var2.bool_vars.keys()) - common:
+            self._clauses.append([-var2.bool_vars[val]])
+
+    def _encode_ne_var(self, var1, var2):
+        common = set(var1.bool_vars.keys()) & set(var2.bool_vars.keys())
+        for val in common:
+            self._clauses.append([-var1.bool_vars[val], -var2.bool_vars[val]])
+
+    def _flatten_sum(self, expr):
+        terms = []
+        const = 0
+
+        def flatten(e):
+            nonlocal const
+            if isinstance(e, IntVar):
+                terms.append(e)
+            elif isinstance(e, int):
+                const += e
+            elif isinstance(e, tuple) and e[0] == 'add':
+                flatten(e[1])
+                flatten(e[2])
+
+        flatten(expr)
+        return terms, const
+
+    def _encode_sum_eq(self, variables, target):
+        n = len(variables)
+        if n == 0:
+            if target != 0:
+                self._clauses.append([])
+            return
+
+        min_sum = sum(v.lb for v in variables)
+        max_sum = sum(v.ub for v in variables)
+
+        if target < min_sum or target > max_sum:
+            self._clauses.append([])
+            return
+
+        if n == 1:
+            self._encode_eq_const(variables[0], target)
+            return
+
+        if n == 2:
+            v1, v2 = variables
+            for val1 in range(v1.lb, v1.ub + 1):
+                val2 = target - val1
+                if val2 < v2.lb or val2 > v2.ub:
+                    self._clauses.append([-v1.bool_vars[val1]])
+                else:
+                    self._clauses.append([-v1.bool_vars[val1], v2.bool_vars[val2]])
+            return
+
+        aux = self.int_var(variables[0].lb + variables[1].lb,
+                          variables[0].ub + variables[1].ub)
+
+        for v1 in range(variables[0].lb, variables[0].ub + 1):
+            for v2 in range(variables[1].lb, variables[1].ub + 1):
+                s = v1 + v2
+                if s in aux.bool_vars:
+                    self._clauses.append([-variables[0].bool_vars[v1],
+                                         -variables[1].bool_vars[v2],
+                                         aux.bool_vars[s]])
+
+        self._encode_sum_eq([aux] + list(variables[2:]), target)
+
+    def _encode_constraint(self, constraint):
+        if isinstance(constraint, tuple):
+            kind = constraint[0]
+
+            if kind == 'all_different':
+                self._encode_all_different(constraint[1])
+
+            elif kind == 'eq_const':
+                self._encode_eq_const(constraint[1], constraint[2])
+
+            elif kind == 'ne_const':
+                self._encode_ne_const(constraint[1], constraint[2])
+
+            elif kind == 'eq_var':
+                self._encode_eq_var(constraint[1], constraint[2])
+
+            elif kind == 'ne_var':
+                self._encode_ne_var(constraint[1], constraint[2])
+
+            elif kind == 'add':
+                terms, const = self._flatten_sum(constraint)
+                if len(terms) == 0:
+                    if const != 0:
+                        self._clauses.append([])
+                else:
+                    pass
+
+            elif kind == 'sum_eq':
+                self._encode_sum_eq(list(constraint[1]), constraint[2])
+
+            elif kind == 'sum_le':
+                terms, target = constraint[1], constraint[2]
+                aux = self.int_var(sum(v.lb for v in terms), min(sum(v.ub for v in terms), target))
+                self._encode_sum_eq(list(terms), aux)
+
+            elif kind == 'sum_ge':
+                terms, target = constraint[1], constraint[2]
+                aux = self.int_var(max(sum(v.lb for v in terms), target), sum(v.ub for v in terms))
+                self._encode_sum_eq(list(terms), aux)
+
+    def sum_eq(self, variables, target):
+        """(vars, k) -> constraint that sum of vars equals k."""
+        return ('sum_eq', tuple(variables), target)
+
+    def sum_le(self, variables, target):
+        """(vars, k) -> constraint that sum of vars <= k."""
+        return ('sum_le', tuple(variables), target)
+
+    def sum_ge(self, variables, target):
+        """(vars, k) -> constraint that sum of vars >= k."""
+        return ('sum_ge', tuple(variables), target)
+
+    def solve(self, **kwargs):
+        """() -> Result with solution or UNSAT."""
+        self._clauses = []
+        self._encode_vars()
+
+        for constraint in self._constraints:
+            self._encode_constraint(constraint)
+
+        if any(len(c) == 0 for c in self._clauses):
+            return Result(None, 0, 0, 0, Status.INFEASIBLE)
+
+        sat_result = solve_sat(self._clauses, **kwargs)
+
+        if sat_result.status == SATStatus.INFEASIBLE:
+            return Result(None, 0, sat_result.iterations, sat_result.evaluations, Status.INFEASIBLE)
+
+        if sat_result.status == SATStatus.MAX_ITER:
+            return Result(None, 0, sat_result.iterations, sat_result.evaluations, Status.MAX_ITER)
+
+        solution = {}
+        for name, var in self._vars.items():
+            if name.startswith('_'):
+                continue
+            for val, bool_var in var.bool_vars.items():
+                if sat_result.solution.get(bool_var, False):
+                    solution[name] = val
+                    break
+
+        return Result(solution, 0, sat_result.iterations, sat_result.evaluations, Status.OPTIMAL)