solvor 0.3.2__tar.gz → 0.3.3__tar.gz

{solvor-0.3.2 → solvor-0.3.3}/CONTRIBUTING.md

@@ -16,7 +16,7 @@ uv sync --extra dev
 uv run pytest
 
 # Run linter
-uv run ruff check src/
+uv run ruff check solvor/
 ```
 
 ## Code Style

{solvor-0.3.2 → solvor-0.3.3}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright [2025] [S.T. Grond]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{solvor-0.3.2 → solvor-0.3.3}/PKG-INFO

@@ -1,21 +1,21 @@
 Metadata-Version: 2.4
 Name: solvor
-Version: 0.3.2
+Version: 0.3.3
 Summary: Solvor your optimization needs.
 Project-URL: Repository, https://github.com/StevenBtw/solvor
 Author: Steven Bytheway
-License: MIT
+License: Apache-2.0
 License-File: LICENSE
 Keywords: linear-programming,metaheuristics,operations-research,optimization,sat,solver
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.14
 Provides-Extra: dev
 Requires-Dist: pytest>=9.0.2; extra == 'dev'
-Requires-Dist: ruff>=0.14.9; extra == 'dev'
+Requires-Dist: ruff>=0.14.10; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Solvor
@@ -30,12 +30,13 @@ Solvor your optimization needs..
 | Category | Solvers | Use Case |
 |----------|---------|----------|
 | **Linear/Integer** | `solve_lp`, `solve_milp` | Resource allocation, scheduling |
-| **Constraint** | `solve_sat`, `Model` | Sudoku, configuration, puzzles |
+| **Constraint** | `solve_sat` | Sudoku, configuration, puzzles |
 | **Local Search** | `anneal`, `tabu_search` | TSP, combinatorial optimization |
 | **Population** | `evolve` | When you want nature to do the work |
 | **Continuous** | `gradient_descent`, `momentum`, `adam` | ML, curve fitting |
 | **Black-box** | `bayesian_opt` | Hyperparameter tuning, expensive functions |
 | **Graph** | `max_flow`, `min_cost_flow`, `solve_assignment` | Matching, transportation |
+| **Exact Cover** | `solve_exact_cover` | Sudoku, N-Queens, tiling puzzles |
 
 ---
 
@@ -75,7 +76,7 @@ print(result.solution)  # {'x': 3, 'y': 7}
 <summary><strong>Linear & Integer Programming</strong></summary>
 
 ### solve_lp
-Two-phase simplex for linear programming.
+For resource allocation, blending, production planning. Finds the exact optimum for linear objectives with linear constraints.
 
 ```python
 # minimize 2x + 3y subject to x + y >= 4, x <= 3
@@ -87,7 +88,7 @@ result = solve_lp(
 ```
 
 ### solve_milp
-Branch and bound for mixed-integer problems.
+When some variables must be integers. Diet problems, scheduling with discrete slots, set covering.
 
 ```python
 # same as above, but x must be integer
@@ -100,7 +101,7 @@ result = solve_milp(c=[2, 3], A=[[-1, -1], [1, 0]], b=[-4, 3], integers=[0])
 <summary><strong>Constraint Programming</strong></summary>
 
 ### solve_sat
-DPLL with unit propagation and clause learning.
+For "is this configuration valid?" problems. Dependencies, exclusions, implications - anything that boils down to boolean constraints.
 
 ```python
 # (x1 OR x2) AND (NOT x1 OR x3) AND (NOT x2 OR NOT x3)
@@ -109,7 +110,7 @@ print(result.solution)  # {1: True, 2: False, 3: True}
 ```
 
 ### Model (CP-SAT)
-Constraint programming via SAT encoding.
+For puzzles and scheduling with "all different", arithmetic, and logical constraints. Sudoku, N-Queens, timetabling.
 
 ```python
 m = Model()
@@ -128,7 +129,7 @@ result = m.solve()
 <summary><strong>Metaheuristics</strong></summary>
 
 ### anneal
-Simulated annealing - accepts worse solutions probabilistically.
+Simulated annealing, accepts worse solutions probabilistically.
 
 ```python
 result = anneal(
@@ -141,7 +142,7 @@ result = anneal(
 ```
 
 ### tabu_search
-Maintains a "tabu list" of recent moves to escape local optima.
+Greedy local search with memory. Prevents cycling back to recent solutions, forcing exploration of new territory. More deterministic than anneal.
 
 ```python
 result = tabu_search(
@@ -153,7 +154,7 @@ result = tabu_search(
 ```
 
 ### evolve
-Genetic algorithm with selection, crossover, mutation.
+Population-based search. More overhead than anneal/tabu, but better diversity and parallelizable.
 
 ```python
 result = evolve(
@@ -171,7 +172,7 @@ result = evolve(
 <summary><strong>Continuous Optimization</strong></summary>
 
 ### gradient_descent / momentum / adam
-First-order methods for differentiable functions.
+Follow the slope downhill. Great for polishing solutions from other methods if your objective is differentiable. Adam adapts learning rates per parameter - usually the default choice.
 
 ```python
 def grad_fn(x):
@@ -182,7 +183,7 @@ print(result.solution)  # [~0, ~0]
 ```
 
 ### bayesian_opt
-Gaussian process surrogate for expensive black-box functions.
+When each evaluation is expensive (think hyperparameter tuning, simulations). Builds a surrogate model to guess where to sample next instead of brute-forcing.
 
 ```python
 def expensive_fn(x):
@@ -198,7 +199,7 @@ result = bayesian_opt(expensive_fn, bounds=[(0, 1), (0, 1)], max_iter=30)
 <summary><strong>Network Flow</strong></summary>
 
 ### max_flow
-Ford-Fulkerson with BFS (Edmonds-Karp).
+"How much can I push through this network?" Assigning workers to tasks, finding bottlenecks. The max-flow min-cut theorem gives you bottleneck analysis for free.
 
 ```python
 graph = {
@@ -213,7 +214,7 @@ print(result.solution)   # edge flows dict
 ```
 
 ### min_cost_flow / solve_assignment
-Successive shortest paths for minimum cost flow.
+"What's the cheapest way to route X units?" Transportation, logistics, matching with costs.
 
 ```python
 # Assignment problem: 3 workers, 3 tasks
@@ -229,6 +230,26 @@ result = solve_assignment(costs)
 
 </details>
 
+<details>
+<summary><strong>Exact Cover</strong></summary>
+
+### solve_exact_cover
+For "place these pieces without overlap" or "fill this grid with exactly one of each" problems. Sudoku, pentomino tiling, scheduling where every slot must be filled exactly once.
+
+```python
+# Tiling problem: cover all columns with non-overlapping rows
+matrix = [
+    [1, 1, 0, 0],  # row 0 covers columns 0, 1
+    [0, 1, 1, 0],  # row 1 covers columns 1, 2
+    [0, 0, 1, 1],  # row 2 covers columns 2, 3
+    [1, 0, 0, 1],  # row 3 covers columns 0, 3
+]
+result = solve_exact_cover(matrix)
+# result.solution = (0, 2) or (1, 3) - rows that cover all columns exactly once
+```
+
+</details>
+
 ---
 
 ## Result Format
@@ -260,6 +281,7 @@ Result(
 | Smooth, differentiable | `adam` |
 | Expensive black-box | `bayesian_opt` |
 | Assignment, matching, flow | `max_flow`, `solve_assignment` |
+| Exact cover, tiling, N-Queens | `solve_exact_cover` |
 
 ---
 

{solvor-0.3.2 → solvor-0.3.3}/README.md

@@ -10,12 +10,13 @@ Solvor your optimization needs..
 | Category | Solvers | Use Case |
 |----------|---------|----------|
 | **Linear/Integer** | `solve_lp`, `solve_milp` | Resource allocation, scheduling |
-| **Constraint** | `solve_sat`, `Model` | Sudoku, configuration, puzzles |
+| **Constraint** | `solve_sat` | Sudoku, configuration, puzzles |
 | **Local Search** | `anneal`, `tabu_search` | TSP, combinatorial optimization |
 | **Population** | `evolve` | When you want nature to do the work |
 | **Continuous** | `gradient_descent`, `momentum`, `adam` | ML, curve fitting |
 | **Black-box** | `bayesian_opt` | Hyperparameter tuning, expensive functions |
 | **Graph** | `max_flow`, `min_cost_flow`, `solve_assignment` | Matching, transportation |
+| **Exact Cover** | `solve_exact_cover` | Sudoku, N-Queens, tiling puzzles |
 
 ---
 
@@ -55,7 +56,7 @@ print(result.solution)  # {'x': 3, 'y': 7}
 <summary><strong>Linear & Integer Programming</strong></summary>
 
 ### solve_lp
-Two-phase simplex for linear programming.
+For resource allocation, blending, production planning. Finds the exact optimum for linear objectives with linear constraints.
 
 ```python
 # minimize 2x + 3y subject to x + y >= 4, x <= 3
@@ -67,7 +68,7 @@ result = solve_lp(
 ```
 
 ### solve_milp
-Branch and bound for mixed-integer problems.
+When some variables must be integers. Diet problems, scheduling with discrete slots, set covering.
 
 ```python
 # same as above, but x must be integer
@@ -80,7 +81,7 @@ result = solve_milp(c=[2, 3], A=[[-1, -1], [1, 0]], b=[-4, 3], integers=[0])
 <summary><strong>Constraint Programming</strong></summary>
 
 ### solve_sat
-DPLL with unit propagation and clause learning.
+For "is this configuration valid?" problems. Dependencies, exclusions, implications - anything that boils down to boolean constraints.
 
 ```python
 # (x1 OR x2) AND (NOT x1 OR x3) AND (NOT x2 OR NOT x3)
@@ -89,7 +90,7 @@ print(result.solution)  # {1: True, 2: False, 3: True}
 ```
 
 ### Model (CP-SAT)
-Constraint programming via SAT encoding.
+For puzzles and scheduling with "all different", arithmetic, and logical constraints. Sudoku, N-Queens, timetabling.
 
 ```python
 m = Model()
@@ -108,7 +109,7 @@ result = m.solve()
 <summary><strong>Metaheuristics</strong></summary>
 
 ### anneal
-Simulated annealing - accepts worse solutions probabilistically.
+Simulated annealing, accepts worse solutions probabilistically.
 
 ```python
 result = anneal(
@@ -121,7 +122,7 @@ result = anneal(
 ```
 
 ### tabu_search
-Maintains a "tabu list" of recent moves to escape local optima.
+Greedy local search with memory. Prevents cycling back to recent solutions, forcing exploration of new territory. More deterministic than anneal.
 
 ```python
 result = tabu_search(
@@ -133,7 +134,7 @@ result = tabu_search(
 ```
 
 ### evolve
-Genetic algorithm with selection, crossover, mutation.
+Population-based search. More overhead than anneal/tabu, but better diversity and parallelizable.
 
 ```python
 result = evolve(
@@ -151,7 +152,7 @@ result = evolve(
 <summary><strong>Continuous Optimization</strong></summary>
 
 ### gradient_descent / momentum / adam
-First-order methods for differentiable functions.
+Follow the slope downhill. Great for polishing solutions from other methods if your objective is differentiable. Adam adapts learning rates per parameter - usually the default choice.
 
 ```python
 def grad_fn(x):
@@ -162,7 +163,7 @@ print(result.solution)  # [~0, ~0]
 ```
 
 ### bayesian_opt
-Gaussian process surrogate for expensive black-box functions.
+When each evaluation is expensive (think hyperparameter tuning, simulations). Builds a surrogate model to guess where to sample next instead of brute-forcing.
 
 ```python
 def expensive_fn(x):
@@ -178,7 +179,7 @@ result = bayesian_opt(expensive_fn, bounds=[(0, 1), (0, 1)], max_iter=30)
 <summary><strong>Network Flow</strong></summary>
 
 ### max_flow
-Ford-Fulkerson with BFS (Edmonds-Karp).
+"How much can I push through this network?" Assigning workers to tasks, finding bottlenecks. The max-flow min-cut theorem gives you bottleneck analysis for free.
 
 ```python
 graph = {
@@ -193,7 +194,7 @@ print(result.solution)   # edge flows dict
 ```
 
 ### min_cost_flow / solve_assignment
-Successive shortest paths for minimum cost flow.
+"What's the cheapest way to route X units?" Transportation, logistics, matching with costs.
 
 ```python
 # Assignment problem: 3 workers, 3 tasks
@@ -209,6 +210,26 @@ result = solve_assignment(costs)
 
 </details>
 
+<details>
+<summary><strong>Exact Cover</strong></summary>
+
+### solve_exact_cover
+For "place these pieces without overlap" or "fill this grid with exactly one of each" problems. Sudoku, pentomino tiling, scheduling where every slot must be filled exactly once.
+
+```python
+# Tiling problem: cover all columns with non-overlapping rows
+matrix = [
+    [1, 1, 0, 0],  # row 0 covers columns 0, 1
+    [0, 1, 1, 0],  # row 1 covers columns 1, 2
+    [0, 0, 1, 1],  # row 2 covers columns 2, 3
+    [1, 0, 0, 1],  # row 3 covers columns 0, 3
+]
+result = solve_exact_cover(matrix)
+# result.solution = (0, 2) or (1, 3) - rows that cover all columns exactly once
+```
+
+</details>
+
 ---
 
 ## Result Format
@@ -240,6 +261,7 @@ Result(
 | Smooth, differentiable | `adam` |
 | Expensive black-box | `bayesian_opt` |
 | Assignment, matching, flow | `max_flow`, `solve_assignment` |
+| Exact cover, tiling, N-Queens | `solve_exact_cover` |
 
 ---
 

{solvor-0.3.2 → solvor-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solvor"
-version = "0.3.2"
+version = "0.3.3"
 description = "Solvor your optimization needs."
 readme = "README.md"
 requires-python = ">=3.14"
@@ -8,12 +8,12 @@ dependencies = []
 authors = [
     { name = "Steven Bytheway" }
 ]
-license = { text = "MIT" }
+license = { text = "Apache-2.0" }
 keywords = ["optimization", "solver", "linear-programming", "sat", "metaheuristics", "operations-research"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
+    "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Mathematics",
 ]
@@ -24,7 +24,7 @@ Repository = "https://github.com/StevenBtw/solvor"
 [project.optional-dependencies]
 dev = [
     "pytest>=9.0.2",
-    "ruff>=0.14.9",
+    "ruff>=0.14.10",
 ]
 
 [build-system]

{solvor-0.3.2 → solvor-0.3.3}/solvor/__init__.py

@@ -11,11 +11,13 @@ 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
+from solvor.dlx import solve_exact_cover
 
 __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",
+    "solve_exact_cover",
     "Status", "Result",
 ]

solvor-0.3.3/solvor/anneal.py

@@ -0,0 +1,75 @@
+"""
+Simulated Annealing, a black box optimization that handles local optima well.
+
+Use this when you have an objective function and can generate neighbors, but don't
+know much else about the problem structure. Fast to prototype, low constraints on
+problem formulation. Works well on landscapes with many local optima where gradient
+descent would get stuck.
+
+Don't use this for: problems where you need guarantees, or when you have constraints
+that are easier to encode in MILP/CP. If you need more control over the search,
+consider tabu (memory of visited states) or genetic (population-based exploration).
+
+    from solvor.anneal import anneal
+
+    result = anneal(start, cost_fn, neighbor_fn)
+    result = anneal(start, cost_fn, neighbor_fn, minimize=False)  # maximize
+
+The neighbor function is the key part, good neighbors make small moves, not random
+jumps. Think "swap two cities" for TSP, not "shuffle everything". Small perturbations
+let the algorithm actually explore the neighborhood instead of teleporting randomly.
+
+If it's getting stuck: try higher starting temperature or slower cooling. If it's
+taking forever: cool faster. For serious tuning, look into adaptive cooling schedules
+or reheating strategies, this implementation keeps it simple with geometric cooling.
+"""
+
+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:
+
+    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-0.3.2 → solvor-0.3.3}/solvor/bayesian.py

@@ -1,32 +1,22 @@
 """
-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
+Bayesian Optimization, for when each evaluation is expensive.
+
+Use this for hyperparameter tuning, A/B testing, simulation optimization, or any
+black-box problem where you can only afford 20-100 evaluations. Works well in
+low dimensions (5-15 parameters), builds a surrogate model to guess where to
+sample next instead of brute-forcing the space.
+
+Don't use this for: functions that are cheap to evaluate (just use anneal or genetic with
+more iterations), high-dimensional problems (>20 dims, the surrogate struggles),
+or discrete/categorical parameters without encoding tricks.
+
+    from solvor.bayesian import bayesian_opt
+
+    result = bayesian_opt(cost_fn, bounds=[(0, 1), (-5, 5)])
+    result = bayesian_opt(cost_fn, bounds, minimize=False)  # maximize
+
+If you're doing serious ML hyperparameter tuning, consider scikit-optimize or
+Optuna, they handle the edge cases and integrations this implementation doesn't.
 """
 
 from collections.abc import Callable, Sequence
@@ -45,7 +35,7 @@ def bayesian_opt(
     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)
@@ -146,4 +136,4 @@ 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)))
+    return 0.5 * (1 + erf(x / sqrt(2)))

{solvor-0.3.2 → solvor-0.3.3}/solvor/cp.py

@@ -1,32 +1,27 @@
 """
-CP-SAT Solver - Constraint Programming via SAT Encoding
+CP-SAT Solver, constraint programming with a SAT backend.
 
-Solves constraint satisfaction problems by encoding integer variables and
-constraints into SAT clauses, then solving with the SAT backend.
+Use this for puzzles and scheduling with "all different", arithmetic constraints,
+and logical combinations. Sudoku, N-Queens, nurse rostering, timetabling. The
+solver encodes your integer variables and constraints into SAT clauses, then
+hands it off to the SAT solver. You get the expressiveness of CP with the
+raw solving power of modern SAT.
+
+Don't use this for: optimization problems (use milp), pure linear problems
+(simplex is simpler and faster), or trivially small problems where the encoding
+overhead isn't worth it.
+
+    from solvor.cp import Model
 
-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)
+    result = m.solve()  # {'x': 3, 'y': 7} or similar
+
+For problems that need both satisfaction and optimization, or heavier constraint
+logic, z3 sits nicely between this CP approach and full MILP.
 """
 
 from itertools import combinations
@@ -78,7 +73,6 @@ class Model:
         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)
@@ -86,11 +80,9 @@ class Model:
         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):
@@ -247,19 +239,15 @@ class Model:
                 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()