Rewrite README with quickstart and examples

Rename project branding to "pymzm" and replace the old python-minizinc-maker README with a full quickstart and examples guide. Adds a top-level usage example, step-by-step quickstart (build model, add variables, constraints, set solve criteria, solve and read results), code snippets, enum/constant/parameter docs, global constraint and expression APIs, exporting to .mzn, and a table of example scripts. Updates install instruction to "pip install pymzm" and notes that MiniZinc must be installed. Removes several older example walkthroughs and reorganizes compatibility/migration links into a dedicated section.

Author: Arthod

README.md

@@ -1,114 +1,181 @@
-# python-minizinc-maker
+# pymzm
 
-Create pure Minizinc .mzn files from Python using [python-minizinc-maker](https://github.com/Arthod/python-minizinc-maker/).
+Model and solve [MiniZinc](https://www.minizinc.org/) constraint problems in Python - no `.mzn` files required.
 
-## Compatibility and Migration
+```python
+import pymzm
+import minizinc
+
+model = pymzm.Model()
+x = model.add_variable("x", val_min=1, val_max=100)
+y = model.add_variable("y", val_min=1, val_max=100)
+
+model.add_constraint(x * y == 7829 * 6907)
+model.add_constraint(x > y)
+
+model.set_solve_criteria(pymzm.SOLVE_SATISFY)
 
-- Compatibility policy: [docs/compatibility_policy.md](docs/compatibility_policy.md)
-- Migration notes: [docs/migration_notes.md](docs/migration_notes.md)
-- Test matrix: [docs/test_matrix.md](docs/test_matrix.md)
+gecode = minizinc.Solver.lookup("gecode")
+result = model.solve(solver=gecode)
+print(result.x, result.y)  # 7829 6907
+```
 
 ## Install
-Installed with pip from [pypi](https://pypi.org/project/pymzm/0.0.1/)
+
 ```
-pip3 install pymzm
+pip install pymzm
 ```
 
-## Model
-Model: `model = pymzm.Model()` \
-Variable: `x = model.add_variable(name, vtype, val_min, val_max)` \
-Variables: `xs = model.add_variables(name, indicies, vtype, val_min, val_max)` \
-Constraint: `model.add_constraint(expr)`\
-Solve: `model.set_solve_criteria(solve_criteria, expr)`
+Requires [MiniZinc](https://www.minizinc.org/software.html) to be installed and on `PATH`.
 
-### Global constraints
-alldifferent, among, all_equal, count, increasing, decreasing, ..(more to be added later)..
+## Quickstart
 
-### Solve
-* model.set_solve_criteria(pymzm.SOLVE_MAXIMIZE, pymzm.Expression.sum(xs))
-* model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+### 1. Build a model
 
-## Examples
-### intfact.py - Integer Factorization example
-intfact.py
 ```python
-import pymzm
 model = pymzm.Model()
+```
+
+**Add a single variable:**
+```python
+x = model.add_variable("x", val_min=0, val_max=10)
+# float variable
+f = model.add_variable("f", vtype=pymzm.Variable.VTYPE_FLOAT, val_min=0.0, val_max=1.0)
+# bool variable
+b = model.add_variable("b", vtype=pymzm.Variable.VTYPE_BOOL)
+```
 
-x = model.add_variable("x", val_min=1, val_max=99999999)
-y = model.add_variable("y", val_min=1, val_max=99999999)
+**Add indexed variables (returns a `ValueDict`):**
+```python
+xs = model.add_variables("x", indices=range(5), val_min=0, val_max=10)
+grid = model.add_variables("cell", indices=[(i, j) for i in range(3) for j in range(3)], val_min=1, val_max=9)
 
-model.add_constraint(x * y == 7829 * 6907)
-model.add_constraint(y > 1)
+xs[0]          # Variable "x_0"
+grid[1, 2]     # Variable "cell_1_2"
+```
+
+### 2. Add constraints
+
+```python
+model.add_constraint(x + y == 10)
 model.add_constraint(x > y)
+model.add_constraint(pymzm.Constraint.alldifferent(xs))
+```
+
+**Multiple constraints at once:**
+```python
+model.add_constraints([
+    xs[i] + xs[i + 1] <= 5
+    for i in range(len(xs) - 1)
+])
+```
 
+### 3. Set solve criteria
+
+```python
 model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+model.set_solve_criteria(pymzm.SOLVE_MAXIMIZE, expr=pymzm.Expression.sum(xs))
+model.set_solve_criteria(pymzm.SOLVE_MINIMIZE, expr=x)
+```
+
+### 4. Solve
+
+```python
 gecode = minizinc.Solver.lookup("gecode")
+
+result = model.solve(solver=gecode)
 result = model.solve(solver=gecode, all_solutions=True)
-print(f"x = {result[0].x}")  # x = 7829
-print(f"y = {result[0].y}")  # y = 6907
+result = model.solve(solver=gecode, timeout=datetime.timedelta(seconds=10))
+result = model.solve(solver=gecode, threads=4, free_search=True)
 ```
 
-Optional debug/export workflow:
+**Shortcuts:**
 ```python
-model.generate(debug=True)
-model.write("model.mzn")
+result = model.optimize(solver=gecode)           # requires maximize/minimize criteria
+is_sat = model.check_satisfiable(solver=gecode)  # returns bool
 ```
 
-### bibd.py - Balanced Incomplete Block Design
-https://www.csplib.org/Problems/prob028/
+### 5. Read results
+
 ```python
-v = 7; b = 7; r = 3; k = 3; l = 1
+# Single solution
+result.x          # by variable name (attribute style)
+result["x"]       # dict style
+result["x_0"]     # indexed variable
+
+# Multiple solutions (all_solutions=True)
+result[0].x
+result[0, "x_0"]  # index + variable name
+len(result)
+```
 
-model = pymzm.Model()
+**Status:**
+```python
+result.status       # minizinc.Status
+result.statistics   # solver statistics dict
+```
 
-indicies = [(i, j) for i in range(v) for j in range(b)]
-# bool if object v is in block b
-xs = model.add_variables("x", indices=indicies, vtype=pymzm.Variable.VTYPE_BOOL)
+## Global constraints
 
-for i in range(b):
-    model.add_constraint(pymzm.Expression.sum(xs[i, j] for j in range(v)) == r)
-for i in range(v):
-    model.add_constraint(pymzm.Expression.sum(xs[j, i] for j in range(b)) == k)
+```python
+pymzm.Constraint.alldifferent(vars)
+pymzm.Constraint.among(vars, value, count)
+pymzm.Constraint.all_equal(vars)
+pymzm.Constraint.count(vars, value, count)
+pymzm.Constraint.increasing(vars)
+pymzm.Constraint.decreasing(vars)
+```
 
-for i in range(b):
-    for j in range(i):
-        model.add_constraint(pymzm.Expression.sum(xs[i, k] * xs[j, k] for k in range(v)) == l)
+## Expressions
 
-model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+```python
+pymzm.Expression.sum(xs)
+pymzm.Expression.AND([e1, e2, e3])
+pymzm.Expression.OR([e1, e2, e3])
+pymzm.Expression.forall(xs, lambda x: x > 0)
+pymzm.Expression.exists(xs, lambda x: x == 5)
+```
 
-gecode = minizinc.Solver.lookup("gecode")
-result = model.solve(solver=gecode, all_solutions=False)
+## Constants and parameters
 
-for i in range(v):
-    print(" ".join([str(int(result[f"x_{i}_{j}"])) for j in range(b)]))
+```python
+model.add_constant("N", 9)
+p = model.add_parameter("capacity", value=100)
 ```
-outputs
+
+## Enum domains
+
+```python
+color = model.add_enum("Color", ["red", "green", "blue"])
+x = model.add_variable("x", domain=color)
 ```
-0 0 1 0 0 1 1
-0 1 0 0 1 1 0
-1 0 0 1 0 1 0
-0 0 1 1 1 0 0
-0 1 0 1 0 0 1
-1 1 1 0 0 0 0
-1 0 0 0 1 0 1
+
+## Export to .mzn (optional)
+
+```python
+model.generate()           # renders the model internally
+model.write("model.mzn")   # writes to file for inspection or external use
 ```
 
-### sat.py - Satisfiability
+Generate with debug output:
 ```python
-model = pymzm.Model()
+model.generate(debug=True)
+```
 
-xs = model.add_variables("x", indices=range(4), vtype=pymzm.Variable.VTYPE_BOOL)
-model.add_constraint(pymzm.Expression.AND([
-    xs[0] | xs[1] | ~xs[2],
-    xs[1] | xs[2] | ~xs[3],
-    xs[0] | ~xs[1] | xs[3],
-]))
-model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+## Examples
 
-gecode = minizinc.Solver.lookup("gecode")
-result = model.solve(solver=gecode, all_solutions=False)
+| File | Problem |
+|------|---------|
+| [examples/intfact.py](examples/intfact.py) | Integer factorization |
+| [examples/nqueens.py](examples/nqueens.py) | N-Queens |
+| [examples/sudoku.py](examples/sudoku.py) | Sudoku |
+| [examples/magicsquare.py](examples/magicsquare.py) | Magic square |
+| [examples/bibd.py](examples/bibd.py) | Balanced Incomplete Block Design |
+| [examples/sat.py](examples/sat.py) | Boolean satisfiability |
+
+## Compatibility and migration
+
+- [Compatibility policy](docs/compatibility_policy.md)
+- [Migration notes](docs/migration_notes.md)
+- [Test matrix](docs/test_matrix.md)
 
-for i in range(4):
-    print(f"x_{i} = {result[f'x_{i}']}")
-```