quprep 0.2.0__tar.gz → 0.3.0__tar.gz

quprep-0.3.0/.github/workflows/release.yml

@@ -0,0 +1,41 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  release:
+    name: Create GitHub Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Extract changelog for this version
+        id: changelog
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          BODY=$(python3 - <<EOF
+          import re, sys
+          content = open("CHANGELOG.md").read()
+          version = "$VERSION"
+          pattern = rf"## \[{re.escape(version)}\][^\n]*\n(.*?)(?=\n## \[|\Z)"
+          m = re.search(pattern, content, re.DOTALL)
+          print(m.group(1).strip() if m else "")
+          EOF
+          )
+          echo "body<<ENDOFBODY" >> $GITHUB_OUTPUT
+          echo "$BODY" >> $GITHUB_OUTPUT
+          echo "ENDOFBODY" >> $GITHUB_OUTPUT
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ github.ref_name }}
+          body: ${{ steps.changelog.outputs.body }}
+          draft: false
+          prerelease: false

{quprep-0.2.0 → quprep-0.3.0}/CHANGELOG.md

@@ -5,12 +5,61 @@ All notable changes to QuPrep will be documented in this file.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 QuPrep uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
 ---
 
 ## [Unreleased]
 
 ---
 
+## [0.3.0] — 2026-03-21
+
+### Added
+
+**QUBO / Ising conversion** (`quprep.qubo`)
+- `to_qubo(cost_matrix, constraints, penalty)` — converts any square cost matrix to upper-triangular QUBO form; supports equality and inequality constraints via Lagrangian penalty
+- `QUBOResult` — holds Q matrix, offset, variable map, n_original; `.to_ising()`, `.evaluate(x)`, `.to_dwave()`, `.to_dict()` / `.from_dict()` methods
+- `IsingResult` — holds h, J, offset; `.to_qubo()` round-trip conversion
+- `qubo_to_ising(qubo)` — QUBO → Ising transformation (s = 2x − 1); energy-consistent for all binary inputs
+- `ising_to_qubo(ising)` — Ising → QUBO inverse transformation; completes the bidirectional round-trip
+- `equality_penalty(A, b, penalty)` — encodes Ax = b as a QUBO penalty matrix
+- `inequality_penalty(A, b, penalty)` — encodes Ax ≤ b via binary slack variables; augments Q from (n,n) to (n+K,n+K)
+- `add_qubo(q1, q2, weight)` — combines two same-size QUBOs; useful for multi-objective problems
+
+**Problem library** (`quprep.qubo.problems`) — 7 NP-hard combinatorial problems
+- `max_cut(adjacency)` — Max-Cut graph partitioning
+- `knapsack(weights, values, capacity, penalty)` — 0/1 Knapsack
+- `tsp(distance_matrix, penalty)` — Travelling Salesman Problem (n² binary variables)
+- `portfolio(returns, covariance, budget, risk_penalty, budget_penalty)` — Markowitz portfolio optimization
+- `graph_color(adjacency, n_colors, penalty)` — Graph Colouring (n×K binary variables)
+- `scheduling(processing_times, n_machines, penalty)` — Job scheduling / load balancing
+- `number_partition(values, penalty)` — Number Partitioning
+
+**Solvers** (`quprep.qubo.solver`)
+- `solve_brute(qubo, max_n=20)` — exact exhaustive solver; evaluates all 2^n states; practical up to n=20
+- `solve_sa(qubo, n_steps, T_start, T_end, seed, restarts)` — simulated annealing heuristic; O(n) incremental energy update with geometric cooling; scales to n ~ 500+
+
+**QAOA circuit generator** (`quprep.qubo.qaoa`)
+- `qaoa_circuit(qubo, p, gamma, beta)` — generates a p-layer QAOA ansatz as OpenQASM 3.0; converts QUBO → Ising internally; compatible with Qiskit, Cirq, and any QASM backend
+
+**Visualization** (`quprep.qubo.visualize`) — requires `pip install quprep[viz]`
+- `draw_qubo(qubo, title, cmap, ax)` — heatmap of Q matrix with symmetric colour scale; annotates cells for n ≤ 10
+- `draw_ising(ising, title, ax)` — circular graph layout; node colour = h_i bias; edge colour/width = J_ij coupling strength
+
+**CLI** (`quprep qubo`)
+- `quprep qubo maxcut --adjacency ... [--solve]`
+- `quprep qubo knapsack --weights ... --values ... --capacity ... [--solve]`
+- `quprep qubo tsp --distances ... [--solve]`
+- `quprep qubo schedule --times ... --machines ... [--solve]`
+- `quprep qubo partition --values ... [--solve]`
+- `quprep qubo portfolio --returns ... --covariance ... --budget ... [--solve]`
+- `quprep qubo graphcolor --adjacency ... --colors ... [--solve]`
+- `quprep qubo qaoa <problem> ... [--p N] [--gamma ...] [--beta ...] [--output file]`
+- `quprep qubo export <problem> ... [--format json|npy] [--output file]`
+- `--solve` auto-switches from exact to simulated annealing for n > 20
+
+---
+
 ## [0.2.0] — 2026-03-21
 
 ### Added
@@ -49,6 +98,9 @@ QuPrep uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - `Pipeline` auto-normalizes IQP/re-upload → `minmax_pm_pi`, Hamiltonian → `zscore`
 - `prepare()` accepts `encoding='iqp'`, `'reupload'`, `'hamiltonian'` with matching kwargs
 
+### Fixed
+- `HamiltonianEncoder` via `prepare()` and `Pipeline` was broken — `_encoding_key()` returned `"zscore"` (a strategy name) instead of `"hamiltonian"`, causing `auto_normalizer()` to raise `ValueError`
+
 ---
 
 ## [0.1.0] — 2026-03-19
@@ -100,6 +152,7 @@ First public release. Covers the full ingest → clean → normalize → encode
 
 ---
 
-[Unreleased]: https://github.com/quprep/quprep/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/quprep/quprep/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/quprep/quprep/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/quprep/quprep/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/quprep/quprep/releases/tag/v0.1.0

{quprep-0.2.0 → quprep-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quprep
-Version: 0.2.0
+Version: 0.3.0
 Summary: Quantum data preparation — the missing preprocessing layer between classical datasets and quantum computing frameworks
 Project-URL: Homepage, https://quprep.org
 Project-URL: Documentation, https://quprep.readthedocs.io
@@ -282,6 +282,9 @@ CSV / DataFrame / NumPy  →  QuPrep  →  circuit-ready output for your framewo
 - Recommend the best encoding for your dataset and task
 - Export circuits to OpenQASM 3.0, Qiskit, PennyLane, Cirq, and TKET
 - Visualize circuits as ASCII diagrams or matplotlib figures
+- Formulate combinatorial optimization problems as QUBO / Ising models (Max-Cut, TSP, Knapsack, Portfolio, Graph Colouring, Scheduling, Number Partitioning)
+- Solve with exact brute-force (n ≤ 20) or simulated annealing (any n)
+- Generate QAOA circuits and export to D-Wave Ocean SDK format
 
 ## What QuPrep does NOT do
 
@@ -356,12 +359,38 @@ print(quprep.draw_ascii(result.encoded[0]))
 quprep.draw_matplotlib(result.encoded[0], filename="circuit.png")
 ```
 
+### QUBO / combinatorial optimization
+
+```python
+from quprep.qubo import max_cut, knapsack, solve_brute, solve_sa, qaoa_circuit
+import numpy as np
+
+# Max-Cut on a weighted graph
+adj = np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float)
+q = max_cut(adj)
+print(q.evaluate(np.array([0., 1., 1.])))  # -2.0
+
+# Brute-force (n ≤ 20) or simulated annealing (any n)
+sol = solve_brute(q)        # exact
+sol = solve_sa(q, seed=42)  # heuristic, scales to n ~ 500+
+
+# Generate a QAOA circuit
+qasm = qaoa_circuit(q, p=2)
+
+# D-Wave Ocean SDK export
+bqm_dict = q.to_dwave()   # {(i, j): coeff}
+```
+
 ### CLI
 
 ```bash
 quprep convert data.csv --encoding angle --framework qasm
 quprep convert data.csv --encoding iqp --framework pennylane
 quprep recommend data.csv --task classification --qubits 8
+
+quprep qubo maxcut --adjacency "0,1,1;1,0,1;1,1,0" --solve
+quprep qubo knapsack --weights "2,3,4" --values "3,4,5" --capacity 5
+quprep qubo qaoa maxcut --adjacency "0,1,1;1,0,1;1,1,0" --p 2 --output circuit.qasm
 ```
 
 ---
@@ -413,6 +442,7 @@ See the [`examples/`](examples/) directory:
 | 04 | Framework export — QASM, Qiskit, PennyLane, Cirq, TKET |
 | 05 | Encoding recommendation |
 | 06 | Circuit visualization |
+| 07 | QUBO / Ising — Max-Cut, Knapsack, solvers, D-Wave export, QAOA |
 
 ---
 

{quprep-0.2.0 → quprep-0.3.0}/README.md

@@ -28,6 +28,9 @@ CSV / DataFrame / NumPy  →  QuPrep  →  circuit-ready output for your framewo
 - Recommend the best encoding for your dataset and task
 - Export circuits to OpenQASM 3.0, Qiskit, PennyLane, Cirq, and TKET
 - Visualize circuits as ASCII diagrams or matplotlib figures
+- Formulate combinatorial optimization problems as QUBO / Ising models (Max-Cut, TSP, Knapsack, Portfolio, Graph Colouring, Scheduling, Number Partitioning)
+- Solve with exact brute-force (n ≤ 20) or simulated annealing (any n)
+- Generate QAOA circuits and export to D-Wave Ocean SDK format
 
 ## What QuPrep does NOT do
 
@@ -102,12 +105,38 @@ print(quprep.draw_ascii(result.encoded[0]))
 quprep.draw_matplotlib(result.encoded[0], filename="circuit.png")
 ```
 
+### QUBO / combinatorial optimization
+
+```python
+from quprep.qubo import max_cut, knapsack, solve_brute, solve_sa, qaoa_circuit
+import numpy as np
+
+# Max-Cut on a weighted graph
+adj = np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float)
+q = max_cut(adj)
+print(q.evaluate(np.array([0., 1., 1.])))  # -2.0
+
+# Brute-force (n ≤ 20) or simulated annealing (any n)
+sol = solve_brute(q)        # exact
+sol = solve_sa(q, seed=42)  # heuristic, scales to n ~ 500+
+
+# Generate a QAOA circuit
+qasm = qaoa_circuit(q, p=2)
+
+# D-Wave Ocean SDK export
+bqm_dict = q.to_dwave()   # {(i, j): coeff}
+```
+
 ### CLI
 
 ```bash
 quprep convert data.csv --encoding angle --framework qasm
 quprep convert data.csv --encoding iqp --framework pennylane
 quprep recommend data.csv --task classification --qubits 8
+
+quprep qubo maxcut --adjacency "0,1,1;1,0,1;1,1,0" --solve
+quprep qubo knapsack --weights "2,3,4" --values "3,4,5" --capacity 5
+quprep qubo qaoa maxcut --adjacency "0,1,1;1,0,1;1,1,0" --p 2 --output circuit.qasm
 ```
 
 ---
@@ -159,6 +188,7 @@ See the [`examples/`](examples/) directory:
 | 04 | Framework export — QASM, Qiskit, PennyLane, Cirq, TKET |
 | 05 | Encoding recommendation |
 | 06 | Circuit visualization |
+| 07 | QUBO / Ising — Max-Cut, Knapsack, solvers, D-Wave export, QAOA |
 
 ---
 

{quprep-0.2.0 → quprep-0.3.0}/docs/api/index.md

@@ -17,7 +17,7 @@ Everything else is accessed via submodules.
 ```python
 import quprep
 
-quprep.__version__   # "0.2.0"
+quprep.__version__   # "0.3.0"
 quprep.prepare(...)
 quprep.Pipeline(...)
 quprep.recommend(...)
@@ -54,6 +54,14 @@ quprep.draw_matplotlib(...)
 | `quprep.ingest.numpy_ingester` | `NumpyIngester` |
 | `quprep.ingest.profiler` | `profile`, `DatasetProfile` |
 | `quprep.core.dataset` | `Dataset` |
+| `quprep.qubo` | `to_qubo`, `QUBOResult`, `qubo_to_ising`, `ising_to_qubo`, `IsingResult` |
+| `quprep.qubo.problems` | `max_cut`, `knapsack`, `tsp`, `portfolio`, `graph_color`, `scheduling`, `number_partition` |
+| `quprep.qubo.solver` | `solve_brute`, `solve_sa`, `SolveResult` |
+| `quprep.qubo.qaoa` | `qaoa_circuit` |
+| `quprep.qubo.constraints` | `equality_penalty`, `inequality_penalty` |
+| `quprep.qubo.ising` | `qubo_to_ising`, `ising_to_qubo` |
+| `quprep.qubo.utils` | `add_qubo` |
+| `quprep.qubo.visualize` | `draw_qubo`, `draw_ising` |
 
 ---
 

quprep-0.3.0/docs/guides/qubo.md

@@ -0,0 +1,257 @@
+# QUBO / Ising
+
+QUBO (Quadratic Unconstrained Binary Optimization) is the standard input format for quantum annealers (D-Wave) and QAOA circuits. QuPrep handles the full pipeline: problem formulation → QUBO matrix → Ising model → QAOA circuit or annealer export.
+
+---
+
+## Quick example
+
+```python
+import numpy as np
+from quprep.qubo import max_cut, solve_brute, qaoa_circuit
+
+# Max-Cut on a triangle graph
+adj = np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float)
+q = max_cut(adj)
+
+print(q)             # QUBOResult(n_variables=3, offset=0.0)
+print(q.Q)           # 3×3 upper-triangular Q matrix
+
+# Brute-force solve (exact, n ≤ 20)
+sol = solve_brute(q)
+print(sol.energy)    # -2.0
+
+# Generate a QAOA circuit
+qasm = qaoa_circuit(q, p=2)
+print(qasm[:60])     # OPENQASM 3.0; ...
+```
+
+---
+
+## QUBOResult
+
+All problem functions return a `QUBOResult`:
+
+```python
+from quprep.qubo import max_cut
+import numpy as np
+
+q = max_cut(np.array([[0,1],[1,0]], dtype=float))
+
+q.Q              # np.ndarray (n, n) — upper-triangular Q matrix
+q.offset         # float — constant energy offset
+q.variable_map   # dict — name → index mapping
+q.n_original     # int — original variable count (before slack)
+
+# Evaluate a solution
+q.evaluate(np.array([0.0, 1.0]))   # x^T Q x + offset
+
+# Convert to Ising
+ising = q.to_ising()
+ising.h   # bias vector
+ising.J   # coupling matrix (upper-triangular)
+
+# Serialize
+d = q.to_dict()          # JSON-compatible dict
+q2 = QUBOResult.from_dict(d)
+
+# D-Wave Ocean SDK export
+bqm_dict = q.to_dwave()  # {(i, j): coeff}  i <= j
+```
+
+---
+
+## Problem library
+
+Seven NP-hard combinatorial problems, ready to formulate as QUBO:
+
+```python
+import numpy as np
+from quprep.qubo import (
+    max_cut, knapsack, tsp, portfolio,
+    graph_color, scheduling, number_partition,
+)
+
+# Max-Cut
+adj = np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float)
+q = max_cut(adj)
+
+# 0/1 Knapsack
+q = knapsack(
+    weights=np.array([2.0, 3.0, 4.0]),
+    values=np.array([3.0, 4.0, 5.0]),
+    capacity=5.0,
+)
+
+# Travelling Salesman Problem (n² variables)
+D = np.array([[0,1,2],[1,0,1],[2,1,0]], dtype=float)
+q = tsp(D)
+
+# Markowitz Portfolio Optimization
+mu = np.array([0.1, 0.2, 0.15, 0.05])
+Sigma = np.eye(4) * 0.01
+q = portfolio(mu, Sigma, budget=2)
+
+# Graph Colouring
+q = graph_color(adj, n_colors=3)
+
+# Job Scheduling (load balancing)
+q = scheduling(processing_times=np.array([3.0,1.0,4.0,2.0]), n_machines=2)
+
+# Number Partitioning
+q = number_partition(values=np.array([3.0,1.0,1.0,2.0,2.0,1.0]))
+```
+
+---
+
+## Solvers
+
+```python
+from quprep.qubo import solve_brute, solve_sa, max_cut
+import numpy as np
+
+adj = np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float)
+q = max_cut(adj)
+
+# Exact — exhaustive 2^n search (n ≤ 20)
+sol = solve_brute(q)
+print(sol.x)        # optimal binary vector
+print(sol.energy)   # optimal energy
+
+# Simulated annealing — scales to n ~ 500+
+sol = solve_sa(q, n_steps=10_000, restarts=3, seed=42)
+print(sol.energy)
+```
+
+---
+
+## Constraints
+
+```python
+from quprep.qubo import to_qubo
+from quprep.qubo.constraints import equality_penalty, inequality_penalty
+import numpy as np
+
+# Equality constraint: x0 + x1 + x2 = 1
+Q_pen, offset = equality_penalty(
+    A=np.array([[1.0, 1.0, 1.0]]),
+    b=np.array([1.0]),
+    penalty=10.0,
+)
+
+# Inequality constraint: x0 + x1 ≤ 1 (adds slack variables)
+Q_pen, offset, n_slack = inequality_penalty(
+    A=np.array([[1.0, 1.0]]),
+    b=np.array([1.0]),
+    penalty=10.0,
+)
+
+# Or pass constraints directly to to_qubo()
+cost = np.diag([-1.0, -2.0, -3.0])
+q = to_qubo(cost, constraints=[
+    {"type": "eq",   "A": np.ones((1, 3)), "b": np.array([1.0]), "penalty": 10.0},
+    {"type": "ineq", "A": np.array([[1.0, 1.0, 0.0]]), "b": np.array([1.0])},
+])
+```
+
+---
+
+## Ising conversion
+
+```python
+from quprep.qubo import qubo_to_ising, ising_to_qubo, max_cut
+import numpy as np
+
+q = max_cut(np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float))
+
+# QUBO → Ising
+ising = qubo_to_ising(q)   # or: q.to_ising()
+print(ising.h)             # bias vector h_i
+print(ising.J)             # coupling matrix J_ij
+
+# Ising → QUBO (round-trip)
+q2 = ising_to_qubo(ising)  # or: ising.to_qubo()
+```
+
+---
+
+## QAOA circuit generation
+
+```python
+from quprep.qubo import qaoa_circuit, max_cut
+import numpy as np
+
+adj = np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float)
+q = max_cut(adj)
+
+# Generate p-layer QAOA circuit (OpenQASM 3.0)
+qasm = qaoa_circuit(q, p=2)
+
+# Custom parameters
+qasm = qaoa_circuit(q, p=2, gamma=[0.5, 0.3], beta=[0.2, 0.1])
+
+# Write to file
+from pathlib import Path
+Path("qaoa_maxcut.qasm").write_text(qasm)
+```
+
+---
+
+## Combining QUBOs
+
+```python
+from quprep.qubo import add_qubo, max_cut
+from quprep.qubo.constraints import equality_penalty
+from quprep.qubo.converter import QUBOResult
+import numpy as np
+
+q_obj = max_cut(np.array([[0,1],[1,0]], dtype=float))
+Q_pen, off = equality_penalty(np.array([[1.0, 1.0]]), np.array([1.0]), 5.0)
+q_pen = QUBOResult(Q=Q_pen, offset=off)
+
+q_combined = add_qubo(q_obj, q_pen, weight=2.0)
+```
+
+---
+
+## Visualization
+
+Requires `pip install quprep[viz]`.
+
+```python
+from quprep.qubo import draw_qubo, draw_ising, max_cut
+import numpy as np
+
+adj = np.array([[0,1,1],[1,0,1],[1,1,0]], dtype=float)
+q = max_cut(adj)
+
+# Heatmap of Q matrix
+ax = draw_qubo(q, title="Max-Cut QUBO")
+
+# Circular Ising graph
+ax = draw_ising(q.to_ising(), title="Max-Cut Ising")
+```
+
+---
+
+## CLI
+
+```bash
+# Problem formulation
+quprep qubo maxcut --adjacency "0,1,1;1,0,1;1,1,0" --solve
+quprep qubo knapsack --weights "2,3,4" --values "3,4,5" --capacity 5 --solve
+quprep qubo tsp --distances "0,1,2;1,0,1;2,1,0"
+quprep qubo schedule --times "3,1,4,2" --machines 2
+quprep qubo partition --values "3,1,1,2,2,1" --solve
+quprep qubo portfolio --returns "0.5,0.3,0.2" --covariance "0.1,0.02,0.01;0.02,0.05,0.01;0.01,0.01,0.08" --budget 2
+quprep qubo graphcolor --adjacency "0,1,1;1,0,1;1,1,0" --colors 3
+
+# QAOA circuit
+quprep qubo qaoa maxcut --adjacency "0,1,1;1,0,1;1,1,0" --p 2 --output circuit.qasm
+
+# Export Q matrix
+quprep qubo export maxcut --adjacency "0,1,1;1,0,1;1,1,0" --format json --output q.json
+quprep qubo export knapsack --weights "2,3,4" --values "3,4,5" --capacity 5 --format npy
+```
+
+`--solve` automatically uses exact brute-force for n ≤ 20 and simulated annealing for larger problems.

{quprep-0.2.0 → quprep-0.3.0}/docs/index.md

@@ -75,7 +75,7 @@ qnode = result.circuit   # callable qml.QNode
 | **Encode+** | ✅ v0.2.0 | IQP, Entangled Angle, Data re-uploading, Hamiltonian |
 | **Export+** | ✅ v0.2.0 | PennyLane, Cirq, TKET, ASCII + matplotlib visualization |
 | **Recommend** | ✅ v0.2.0 | Automatic encoding selection for your dataset and task |
-| **QUBO** | 🔲 v0.3.0 | QUBO/Ising conversion, problem library |
+| **QUBO** | ✅ v0.3.0 | QUBO/Ising conversion, 7 problem formulations, solvers, QAOA, D-Wave export |
 
 ---
 
@@ -100,4 +100,8 @@ quprep convert data.csv --encoding angle --framework qasm
 quprep convert data.csv --encoding iqp --framework pennylane
 quprep convert data.csv --encoding basis --samples 10 --output circuits.qasm
 quprep recommend data.csv --task classification --qubits 8
+
+quprep qubo maxcut --adjacency "0,1,1;1,0,1;1,1,0" --solve
+quprep qubo knapsack --weights "2,3,4" --values "3,4,5" --capacity 5
+quprep qubo qaoa maxcut --adjacency "0,1,1;1,0,1;1,1,0" --p 2 --output circuit.qasm
 ```

{quprep-0.2.0 → quprep-0.3.0}/examples/05_recommend.py

@@ -67,4 +67,4 @@ print("=" * 55)
 
 rec2 = quprep.recommend(X, task="classification", qubits=8)
 for i, alt in enumerate(rec2.alternatives):
-    print(f"  #{i + 1}: {alt['method']:20s}  score={alt['score']:.1f}")
+    print(f"  #{i + 1}: {alt.method:20s}  score={alt.score:.1f}")

{quprep-0.2.0 → quprep-0.3.0}/examples/06_visualization.py

@@ -74,7 +74,7 @@ else:
     ]
 
     for name, enc in encodings:
-        path = f"circuit_{name}.png"
+        path = f"/tmp/circuit_{name}.png"
         draw_matplotlib(enc, filename=path)
         print(f"  Saved: {path}")
 

quprep-0.3.0/examples/07_qubo.py

@@ -0,0 +1,94 @@
+"""
+Example 07 — QUBO / Ising
+
+Demonstrates:
+  - Problem formulation (Max-Cut, Knapsack)
+  - Brute-force and simulated-annealing solvers
+  - QUBO ↔ Ising round-trip
+  - D-Wave export
+  - QAOA circuit generation
+"""
+
+import numpy as np
+
+from quprep.qubo import (
+    ising_to_qubo,
+    knapsack,
+    max_cut,
+    qaoa_circuit,
+    qubo_to_ising,
+    solve_brute,
+    solve_sa,
+)
+
+# ── Max-Cut ───────────────────────────────────────────────────────────────────
+print("── Max-Cut ──────────────────────────────────────────────────────────────")
+
+adj = np.array([[0, 1, 1, 0],
+                [1, 0, 1, 1],
+                [1, 1, 0, 1],
+                [0, 1, 1, 0]], dtype=float)
+
+q = max_cut(adj)
+print(f"Variables : {q.Q.shape[0]}")
+print(f"Offset    : {q.offset}")
+
+sol = solve_brute(q)
+bits = "".join(str(int(b)) for b in sol.x)
+print(f"Exact solution : x={bits}  energy={sol.energy:.4f}")
+
+# Evaluate a specific assignment manually
+x_test = np.array([0.0, 1.0, 0.0, 1.0])
+print(f"evaluate([0,1,0,1]) = {q.evaluate(x_test):.4f}")
+
+# ── Ising round-trip ──────────────────────────────────────────────────────────
+print("\n── Ising round-trip ─────────────────────────────────────────────────────")
+
+ising = q.to_ising()
+print(f"Ising h : {ising.h}")
+print(f"Ising J matrix:\n{ising.J}")
+
+q2 = ising.to_qubo()
+print(f"Round-trip Q matches: {np.allclose(q.Q, q2.Q)}")
+
+# ── D-Wave export ─────────────────────────────────────────────────────────────
+print("\n── D-Wave export ────────────────────────────────────────────────────────")
+
+dwave = q.to_dwave()
+print(f"D-Wave BQM dict ({len(dwave)} entries):")
+for (i, j), v in list(dwave.items())[:5]:
+    print(f"  ({i},{j}): {v:.4f}")
+
+# Standalone ising_to_qubo
+q3 = ising_to_qubo(qubo_to_ising(q))
+print(f"ising_to_qubo() round-trip matches: {np.allclose(q.Q, q3.Q)}")
+
+# ── Knapsack with simulated annealing ─────────────────────────────────────────
+print("\n── Knapsack (SA solver) ─────────────────────────────────────────────────")
+
+weights = np.array([2.0, 3.0, 4.0, 5.0, 6.0])
+values  = np.array([3.0, 4.0, 5.0, 6.0, 7.0])
+kq = knapsack(weights, values, capacity=10.0)
+print(f"Variables : {kq.Q.shape[0]}")
+
+sol_sa = solve_sa(kq, n_steps=20_000, restarts=3, seed=42)
+bits_sa = "".join(str(int(b)) for b in sol_sa.x[:len(weights)])
+print(f"SA solution : x={bits_sa}  energy={sol_sa.energy:.4f}")
+
+sol_exact = solve_brute(kq)
+bits_exact = "".join(str(int(b)) for b in sol_exact.x[:len(weights)])
+print(f"Exact       : x={bits_exact}  energy={sol_exact.energy:.4f}")
+
+# ── QAOA circuit ─────────────────────────────────────────────────────────────
+print("\n── QAOA circuit ─────────────────────────────────────────────────────────")
+
+small_adj = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]], dtype=float)
+qsmall = max_cut(small_adj)
+qasm = qaoa_circuit(qsmall, p=2)
+lines = qasm.strip().splitlines()
+print(f"QAOA circuit ({len(lines)} lines):")
+for line in lines[:6]:
+    print(f"  {line}")
+print("  ...")
+
+print("\nDone.")

{quprep-0.2.0 → quprep-0.3.0}/examples/README.md

@@ -10,6 +10,7 @@ Each example is a runnable Python script.
 | 04 | Framework export — QASM, Qiskit, PennyLane, Cirq, TKET | `04_export.py` |
 | 05 | Encoding recommendation — `recommend()` | `05_recommend.py` |
 | 06 | Circuit visualization — ASCII + matplotlib | `06_visualization.py` |
+| 07 | QUBO / Ising — Max-Cut, Knapsack, solvers, D-Wave export, QAOA | `07_qubo.py` |
 
 ## Run a script
 

{quprep-0.2.0 → quprep-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quprep"
-version = "0.2.0"
+version = "0.3.0"
 description = "Quantum data preparation — the missing preprocessing layer between classical datasets and quantum computing frameworks"
 readme = "README.md"
 license = { file = "LICENSE" }

{quprep-0.2.0 → quprep-0.3.0}/quprep/__init__.py

@@ -20,7 +20,7 @@ The missing preprocessing layer between classical datasets and quantum computing
     rec = quprep.recommend(df, task="classification", qubits=8)
 """
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __author__ = "Hasarindu Perera"
 __license__ = "Apache-2.0"