diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..406eb48
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
diff --git a/MVC/QGMVC.py b/MVC/QGMVC.py
deleted file mode 100644
index dd3a3a9..0000000
--- a/MVC/QGMVC.py
+++ /dev/null
@@ -1,330 +0,0 @@
-from __future__ import annotations
-import random
-import networkx as nx
-import numpy as np
-import matplotlib.pyplot as plt
-# Optional rustworkx support
-try:
-    import rustworkx as rx
-    RxGraph = rx.PyGraph
-except ImportError:
-    rx = None
-    RxGraph = tuple()
-import sys
-# CPLEX import
-from docplex.mp.model import Model
-from quantum_greedy_util import mixer_from_graph, expectation_value_cost_shifted, greedy_optimize, greedy_optimize_seq,greedy_optimize_seq_rev,node_order_by_cost_degree,mean_field_cost_degree_order_init
-#from classical_heuristics_util import is_vertex_cover, local_search_vertex_cover, ga_vertex_cover
-from classical_runtime_guarantee_util import mvc_exact_cplex, mvc_lp_relaxation, greedy_degree_vertex_cover, greedy_edge_vertex_cover,mvc_primal_dual_weighted
-
-
-
-# ---------------- Experiment & plotting ----------------
-def run_experiment_stats_weighted(
-    n_values,
-    N_graphs=10,
-    n_stat=1,
-    shots=None,
-    case="weighted",
-    graph_type="regular",
-    degree=3,
-    seed=0
-):
-    methods = [
-        "worst_case",
-        "optimal",
-        "LP",
-        "Dual-Primal",
-        "Greedy vertex degree",
-        "Greedy random edge",
-        "Quantum greedy bias",
-        "Quantum greedy seq bias",
-        "Quantum greedy seq rev bias",
-        "Quantum greedy unbias",
-        "Quantum greedy seq unbias",
-        "Quantum greedy seq rev unbias",
-        "Quantum greedy mean field",
-        "Quantum greedy seq mean field",
-        "Quantum greedy seq rev mean field",
-    ]
-
-    results = {n: {m: [] for m in methods} for n in n_values}
-    rng = np.random.default_rng(seed)
-
-    for n in n_values:
-
-        print(f"\n===== n = {n} =====")
-        for g in range(N_graphs):
-            print(g)
-            graph_seed = rng.integers(1e9)
-
-            if graph_type == "regular":
-                G = nx.random_regular_graph(
-                    degree if n % 2 == 0 else degree + 1,
-                    n,
-                    seed=int(graph_seed)
-                )
-            elif graph_type == "erdos":
-                while True:
-                    G = nx.erdos_renyi_graph(n=n, p=degree)
-                    if nx.is_connected(G):
-                        break
-
-            else:
-                raise ValueError("Unknown graph type")
-            
-            if case == "unweighted":
-                c = {i: 1.0 for i in G.nodes()}
-            else:
-                c = {i: random.uniform(0.40, 0.70) for i in G.nodes()}
-
-            C_opt = mvc_exact_cplex(G, c)
-            opt_cost = sum(c[i] for i in C_opt)
-            results[n]["optimal"].append(opt_cost)  # by definition
-
-            results[n]["worst_case"].append(sum(c[i] for i in G.nodes())/opt_cost)
-
-            C_lp = mvc_lp_relaxation(G, c)
-            results[n]["LP"].append((sum(c[i] for i in C_lp) )/ opt_cost)
-
-            C_pd = mvc_primal_dual_weighted(G,  c)
-            results[n]["Dual-Primal"].append(sum(c[i] for i in C_pd) / opt_cost)
-
-            C_gd = greedy_degree_vertex_cover(G,c)
-            results[n]["Greedy vertex degree"].append(sum(c[i] for i in C_gd) / opt_cost)
-            qc, betas, Gn = mixer_from_graph(G,c)
-            C_cost = {i: c[i] for i in Gn.nodes()}   
-            order = node_order_by_cost_degree(G, C_cost)
-            beta_mean = mean_field_cost_degree_order_init(G, order, C_cost, alpha=1,beta=1.0, gamma=1.0, delta=0.7, n_iter=50)
-            beta_bias={i: 0.8*np.pi/2 for i in C_cost}
-            beta_unbias={i: 0.5*np.pi/2 for i in C_cost}
-
-            C_ge=[]     
-            E_unbias=[]   
-            E_bias=[] 
-            E_mean=[]                              
-            for _ in range(n_stat):
-
-                c_ge = greedy_edge_vertex_cover(G,c)
-                C_ge.append(sum(c[i] for i in c_ge))
-                
-                sol_unbias = greedy_optimize(qc, betas, C_cost, beta_unbias, shots=shots)
-                E= expectation_value_cost_shifted(qc, betas, C_cost, sol_unbias, shots=shots)
-                E_unbias.append(E)
-
-                sol_bias = greedy_optimize(qc, betas, C_cost, beta_bias, shots=shots)
-                E= expectation_value_cost_shifted(qc, betas, C_cost, sol_bias, shots=shots)
-                E_bias.append(E)
-                
-                sol_mean = greedy_optimize(qc, betas, C_cost, beta_mean, shots=shots)
-                E= expectation_value_cost_shifted(qc, betas, C_cost, sol_mean, shots=shots)
-                E_mean.append(E)
-
-            results[n]["Greedy random edge"].append(np.mean(np.array(C_ge))/opt_cost)
-            results[n]["Quantum greedy bias"].append(np.mean(np.array(E_bias))/ opt_cost)
-            results[n]["Quantum greedy unbias"].append(np.mean(np.array(E_unbias))/ opt_cost)
-            results[n]["Quantum greedy mean field"].append(np.mean(np.array(E_mean))/ opt_cost)
-
-            
-            
-
-            sol_bias = greedy_optimize_seq(qc, betas, C_cost, beta_bias, shots=shots)
-            E = expectation_value_cost_shifted(qc, betas, C_cost, sol_bias, shots=shots)
-            results[n]["Quantum greedy seq bias"].append(E / opt_cost)
-
-            sol_unbias = greedy_optimize_seq(qc, betas, C_cost, beta_unbias, shots=shots)
-            E = expectation_value_cost_shifted(qc, betas, C_cost, sol_unbias, shots=shots)
-            results[n]["Quantum greedy seq unbias"].append(E / opt_cost)
-
-            sol_mean = greedy_optimize_seq(qc, betas, C_cost, beta_mean, shots=shots)
-            E = expectation_value_cost_shifted(qc, betas, C_cost, sol_mean, shots=shots)
-            results[n]["Quantum greedy seq mean field"].append(E / opt_cost)
-
-
-            sol_bias = greedy_optimize_seq_rev(qc, betas, C_cost, beta_bias, shots=shots)
-            E = expectation_value_cost_shifted(qc, betas, C_cost, sol_bias, shots=shots)
-            results[n]["Quantum greedy seq rev bias"].append(E / opt_cost)
-
-            sol_unbias = greedy_optimize_seq_rev(qc, betas, C_cost, beta_unbias, shots=shots)
-            E = expectation_value_cost_shifted(qc, betas, C_cost, sol_unbias, shots=shots)
-            results[n]["Quantum greedy seq rev unbias"].append(E / opt_cost)
-
-            sol_mean = greedy_optimize_seq_rev(qc, betas, C_cost, beta_mean, shots=shots)
-            E = expectation_value_cost_shifted(qc, betas, C_cost, sol_mean, shots=shots)
-            results[n]["Quantum greedy seq rev mean field"].append(E / opt_cost)
-
-
-
-        print(f"n={n} done")
-
-    return results
-import os
-import numpy as np
-from datetime import datetime
-
-def save_results(
-    results,
-    n_values,
-    N_graphs,
-    n_stat,
-    case,
-    graph_type,
-    degree,
-    shots,
-    seed,
-    prefix="mvc_results"
-):
-    """
-    Save experiment results with a filename encoding all key parameters.
-    """
-
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-
-    fname = (
-        f"{prefix}_"
-        f"{case}_"
-        f"{graph_type}_deg{degree}_"
-        f"nG{N_graphs}_"
-        f"nStat{n_stat}_"
-        f"shots{shots}_"
-        f"seed{seed}_"
-        f"{timestamp}.npz"
-    )
-
-    # Save in same directory as script
-    out_dir = os.path.dirname(os.path.abspath(__file__))
-    out_path = os.path.join(out_dir, fname)
-
-    np.savez_compressed(
-        out_path,
-        results=results,
-        n_values=np.array(n_values),
-        N_graphs=N_graphs,
-        n_stat=n_stat,
-        case=case,
-        graph_type=graph_type,
-        degree=degree,
-        shots=shots,
-        seed=seed,
-    )
-
-    print(f"Results saved to:\n{out_path}")
-   
-def summarize_results(results, n_values):
-    means = {}
-    stds = {}
-
-    for method in next(iter(results.values())).keys():
-        means[method] = []
-        stds[method] = []
-        for n in n_values:
-            vals = np.array(results[n][method])
-            means[method].append(vals.mean())
-            stds[method].append(vals.std())
-
-    return means, stds
-
-from datetime import datetime
-
-def plot_with_error_bars(n_values, means, stds, prefix="vertex_cover_performance"):
-    plt.figure(figsize=(9, 6))
-
-    # Filter methods (exclude optimal)
-    methods = [m for m in means if m.lower() != "optimal"]
-
-    # Choose a colormap with enough distinct colors
-    cmap = plt.get_cmap("tab20")
-    colors = cmap.colors
-
-    for i, method in enumerate(methods):
-        plt.errorbar(
-            n_values,
-            means[method],
-            yerr=stds[method],
-            marker="o",
-            capsize=4,
-            color=colors[i % len(colors)],
-            label=method
-        )
-
-    plt.xlabel("Graph size (n)")
-    plt.ylabel(r"Performance $|C| / |C^*|$")
-    plt.title("Vertex Cover Performance vs Graph Size")
-    plt.legend()
-    plt.grid(True)
-    plt.tight_layout()
-
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"{prefix}_{timestamp}.png"
-    plt.savefig(filename)
-    plt.close()
-
-    print(f"Figure saved as: {filename}")
-
-# ---------------- Main ----------------
-def main(n_values, N_graphs, n_stat, case, graph_type, degree, shots, seed=None):
-
-    results = run_experiment_stats_weighted(
-        n_values,
-        N_graphs=N_graphs,
-        n_stat=n_stat,
-        case=case,
-        graph_type=graph_type,
-        degree=degree,
-        shots=shots,
-        seed=None
-    )
-    save_results(
-    results,
-    n_values,
-    N_graphs,
-    n_stat,
-    case,
-    graph_type,
-    degree,
-    shots,
-    seed
-    )
-    means, stds = summarize_results(results, n_values)
-    plot_with_error_bars(n_values, means, stds)
-
-if __name__ == "__main__":
-    # Expected usage:
-    # python run_experiment.py N_graphs n_stat case graph_type degree shots
-    N_graphs = int(sys.argv[1])
-    n_stat = int(sys.argv[2])
-    case = str(sys.argv[3])              # "weighted" or "unweighted"
-    graph_type = str(sys.argv[4])        # "regular" or "erdos"
-    degree = float(sys.argv[5])          # degree or p
-    shots = int(sys.argv[6])
-    # Conditional typing for degree
-    if graph_type == "regular":
-        degree = int(degree)
-    elif graph_type == "erdos":
-        degree = float(degree)
-        if not (0.0 <= degree <= 1.0):
-            raise ValueError("For erdos graphs, degree must be a probability in [0,1]")
-    else:
-        raise ValueError("graph_type must be 'regular' or 'erdos'")
-    # Fixed values (edit if needed)
-    n_values = [6,8,10,12,14,16,18,20]
-    seed = None
-
-    print("N_graphs =", N_graphs)
-    print("n_stat =", n_stat)
-    print("case =", case)
-    print("graph_type =", graph_type)
-    print("degree =", degree)
-    print("shots =", shots)
-
-    main(
-        n_values=n_values,
-        N_graphs=N_graphs,
-        n_stat=n_stat,
-        case=case,
-        graph_type=graph_type,
-        degree=degree,
-        shots=shots,
-        seed=seed
-    )
-
diff --git a/MVC/QGMVC_experiments copy 2.ipynb b/MVC/QGMVC_experiments copy 2.ipynb
deleted file mode 100644
index 0065080..0000000
--- a/MVC/QGMVC_experiments copy 2.ipynb	
+++ /dev/null
@@ -1,959 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 114,
-   "id": "44dddc40",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from __future__ import annotations\n",
-    "from typing import Union\n",
-    "import random\n",
-    "import math\n",
-    "\n",
-    "import networkx as nx\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Optional rustworkx support\n",
-    "try:\n",
-    "    import rustworkx as rx\n",
-    "    RxGraph = rx.PyGraph\n",
-    "except ImportError:\n",
-    "    rx = None\n",
-    "    RxGraph = tuple()\n",
-    "\n",
-    "# Qiskit imports\n",
-    "from qiskit import QuantumCircuit\n",
-    "from qiskit.circuit import Parameter\n",
-    "from qiskit.circuit.library import RXGate\n",
-    "from qiskit.quantum_info import Statevector, SparsePauliOp\n",
-    "from qiskit_aer import Aer\n",
-    "from qiskit import transpile\n",
-    "\n",
-    "# CPLEX import\n",
-    "from docplex.mp.model import Model\n",
-    "from quantum_greedy_util import mixer_from_graph,expectation_value_cost_shifted_with_bitstring,greedy_optimize,greedy_optimize_seq\n",
-    "#from classical_heuristics_util import is_vertex_cover, local_search_vertex_cover, ga_vertex_cover\n",
-    "from classical_runtime_guarantee_util import mvc_exact_cplex, mvc_lp_relaxation, greedy_degree_vertex_cover, greedy_edge_vertex_cover,mvc_primal_dual_weighted\n",
-    "import os\n",
-    "import pickle"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 115,
-   "id": "3c5e478d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " You are running without reading from qaoa_settings.txt - you should never see this message on solstorm!\n",
-      "[INFO] graph pickle counts per requested size:\n",
-      "  n8: 1\n",
-      "  n10: 1\n",
-      "  n12: 1\n",
-      "  n14: 1\n",
-      "  n16: 0\n",
-      "  n18: 0\n",
-      "  n20: 1\n"
-     ]
-    }
-   ],
-   "source": [
-    "local = True\n",
-    "\n",
-    "# Configuration: change these constants in this file to control runs\n",
-    "# LIMIT: number of graphs to process (None -> all)\n",
-    "# REPS: number of repetitions per parameter set\n",
-    "LIMIT = 20\n",
-    "\n",
-    "# If True, treat `LIMIT` as a per-size limit when the script iterates over\n",
-    "# multiple graph sizes (useful when you want N graphs per size). If False,\n",
-    "# LIMIT caps the total number of graphs across all sizes.\n",
-    "LIMIT_PER_SIZE = False\n",
-    "\n",
-    "if local:\n",
-    "    # depths 1..4\n",
-    "    settings = [\n",
-    "        {'backend_mode': 'statevector',\n",
-    "         'problem_type': 'minvertexcover',\n",
-    "         'qaoa_variant': 'multiangle_cpm_no_cost_custom',\n",
-    "         'param_initialization': 'uniform',\n",
-    "         'optimizer': 'BFGS',\n",
-    "         'depth': d,\n",
-    "         'warm_start': False}\n",
-    "        for d in range(1, 5)\n",
-    "    ]\n",
-    "    print(' You are running without reading from qaoa_settings.txt - you should never see this message on solstorm!')\n",
-    "#/p/fm/FinleyQuinton/QAOA/QAOA_copy/QAOA_copy/run_my_qaoa/results/graphs/paper_graphs/3_regular/rdr3_20_paper_graphs_n8.pkl\n",
-    "# -------------------- LOAD GRAPHS -------------------- #\n",
-    "#erdos_20_paper_graphs_05P_n20.pkl\n",
-    "#rdr3_20_paper_graphs_n20.pkl\n",
-    "graph_dir = os.path.join(os.path.dirname('erdos_20_paper_graphs_05P_n8.pkl'), \"graphs\", \"erdos\")\n",
-    "from glob import glob\n",
-    "\n",
-    "# include sizes 8,10,...,14\n",
-    "sizes = [8, 10, 12, 14,16,18,20]\n",
-    "graph_files = []\n",
-    "per_size_counts = {}\n",
-    "for s in sizes:\n",
-    "    pattern = os.path.join(graph_dir, f\"*n{s}.pkl\")\n",
-    "    found = sorted(glob(pattern))\n",
-    "    if not found:\n",
-    "        # also accept files that contain the size number elsewhere\n",
-    "        found = sorted(glob(os.path.join(graph_dir, f\"*{s}*.pkl\")))\n",
-    "    # Optionally limit per-size if requested\n",
-    "    if LIMIT is not None and LIMIT_PER_SIZE and found:\n",
-    "        found = found[:LIMIT]\n",
-    "    # record how many pickle files were found for this size (after optional per-size LIMIT)\n",
-    "    per_size_counts[s] = len(found)\n",
-    "    graph_files.extend(found)\n",
-    "\n",
-    "if not graph_files:\n",
-    "    raise RuntimeError(f\"No graph files found in {graph_dir} for sizes {sizes}\")\n",
-    "\n",
-    "# Print per-size summary so user can verify how many pickles were found per size\n",
-    "print(\"[INFO] graph pickle counts per requested size:\")\n",
-    "for s in sizes:\n",
-    "    print(f\"  n{s}: {per_size_counts.get(s, 0)}\")\n",
-    "\n",
-    "graph_data = []\n",
-    "for gf in graph_files:\n",
-    "    with open(gf, \"rb\") as f:\n",
-    "        try:\n",
-    "            data = pickle.load(f)\n",
-    "            if isinstance(data, list):\n",
-    "                graph_data.extend(data)\n",
-    "        except Exception as e:\n",
-    "            print(f\"Failed to load {gf}: {e}\")\n",
-    "\n",
-    "graphs = [g[\"graph\"] if isinstance(g, dict) and \"graph\" in g else g for g in graph_data]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 116,
-   "id": "03b21468",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def rx_to_nx(rx_graph):\n",
-    "\n",
-    "    G = nx.Graph()\n",
-    "\n",
-    "     # Nodes: indices + data\n",
-    "    for i in rx_graph.node_indices():\n",
-    "        data = rx_graph[i]          # node payload\n",
-    "        G.add_node(i, data=data)\n",
-    "\n",
-    "    # Edges: indices + weight/data\n",
-    "    for u, v, w in rx_graph.weighted_edge_list():\n",
-    "        if isinstance(w, dict):\n",
-    "            G.add_edge(u, v, **w)\n",
-    "        else:\n",
-    "            G.add_edge(u, v, weight=w)\n",
-    "\n",
-    "    return G"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "485de73e",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 117,
-   "id": "0840f18f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "k=-2\n",
-    "G=rx_to_nx(graphs[k]) if rx and isinstance(graphs[k], RxGraph) else graphs[k]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9cb1e380",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 118,
-   "id": "fae1eff9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "case=\"weighted\"\n",
-    "graph_type=\"regular\"\n",
-    "degree=3\n",
-    "shots=None\n",
-    "seed=None\n",
-    "rng = np.random.default_rng(seed)\n",
-    "graph_seed = rng.integers(1e9)\n",
-    "n=14\n",
-    "n_stat=1\n",
-    "results = {\"LP\": [], \"Dual-Primal\": [], \"Greedy random edge\": [], \"Greedy vertex degree\": [], \"Quantum greedy bias\": [], \"Quantum greedy seq bias\": []}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 119,
-   "id": "41b2eab9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if graph_type == \"erdos\":\n",
-    "    p = degree\n",
-    "    G = nx.erdos_renyi_graph(n, p)\n",
-    "elif graph_type == \"regular\":\n",
-    "    G = nx.random_regular_graph(degree, n)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 120,
-   "id": "541867e8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "\n",
-    "def plot_graph(G):\n",
-    "    \"\"\"Plot a NetworkX graph with labels.\"\"\"\n",
-    "    plt.figure(figsize=(4,4))\n",
-    "    pos = nx.spring_layout(G, seed=42)  # nice-looking layout\n",
-    "\n",
-    "    nx.draw(\n",
-    "        G, pos,\n",
-    "        with_labels=True,\n",
-    "        node_size=800,\n",
-    "        node_color=\"lightblue\",\n",
-    "        font_size=12,\n",
-    "        font_weight=\"bold\",\n",
-    "        edge_color=\"gray\"\n",
-    "    )\n",
-    "\n",
-    "    plt.title(\"Graph G\")\n",
-    "    plt.axis(\"off\")\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 121,
-   "id": "cec59568",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_graph(G)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 122,
-   "id": "3f00e0f2",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'\"QGMVC_experiments copy.ipynb\"\\ndef node_order_by_cost_degree1(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (G.degree(i), -C[i]),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph1(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree1(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\n\\ndef node_order_by_cost_degree2(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (G.degree(i), C[i]),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph2(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree2(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\n\\ndef node_order_by_cost_degree3(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        #key=lambda i: (G.degree(i), -C[i]),\\n        key=lambda i: (G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph3(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree3(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\n\\ndef node_order_by_cost_degree4(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        key=lambda i: (i)\\n        #key=lambda i: (G.degree(i), -C[i]),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph4(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree4(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\ndef node_order_by_cost_degree5(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (C[i],G.degree(i)),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph5(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree5(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\ndef node_order_by_cost_degree6(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (-C[i],G.degree(i)),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph6(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree6(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n    '"
-      ]
-     },
-     "execution_count": 122,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'''\"QGMVC_experiments copy.ipynb\"\n",
-    "def node_order_by_cost_degree1(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (G.degree(i), -C[i]),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph1(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree1(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "\n",
-    "def node_order_by_cost_degree2(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (G.degree(i), C[i]),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph2(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree2(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "\n",
-    "def node_order_by_cost_degree3(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        #key=lambda i: (G.degree(i), -C[i]),\n",
-    "        key=lambda i: (G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph3(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree3(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "\n",
-    "def node_order_by_cost_degree4(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        key=lambda i: (i)\n",
-    "        #key=lambda i: (G.degree(i), -C[i]),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph4(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree4(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "def node_order_by_cost_degree5(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (C[i],G.degree(i)),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph5(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree5(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "def node_order_by_cost_degree6(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (-C[i],G.degree(i)),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph6(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree6(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "    '''\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 123,
-   "id": "940b7c79",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def mean_field_cost_degree_order_init(G, C_cost, order, alpha=1, beta=1, gamma=1,delta=0.2, n_iter=30):\n",
-    "    n = len(G)\n",
-    "    rank = {j: k / n for k, j in enumerate(order)}\n",
-    "    p = {j: 0.5 for j in G.nodes()}\n",
-    "    maxcost= max(C_cost)\n",
-    "    for _ in range(n_iter):\n",
-    "        p_new = {}\n",
-    "        for j in G.nodes():\n",
-    "            dj = max(1, G.degree(j))\n",
-    "            neigh_pressure = sum(p[k] for k in G.neighbors(j)) / dj\n",
-    "            field = (\n",
-    "                alpha * C_cost[j]\n",
-    "                - beta * neigh_pressure\n",
-    "                - gamma * rank[j]\n",
-    "            )\n",
-    "            p_new[j] = 1.0 / (1.0 + np.exp(-delta*field))\n",
-    "        p = p_new\n",
-    "\n",
-    "    return {j: np.arcsin(np.sqrt(p[j])) for j in p}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 124,
-   "id": "86791a06",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "\n",
-    "def is_vertex_cover(F: nx.Graph, bitstring: str):\n",
-    "    \"\"\"\n",
-    "    Check if a bitstring represents a feasible vertex cover.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    F : nx.Graph\n",
-    "        Input graph\n",
-    "    bitstring : str\n",
-    "        Binary string, one bit per node (ordered as F.nodes())\n",
-    "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    feasible : bool\n",
-    "        True if bitstring is a vertex cover\n",
-    "    uncovered_edges : list\n",
-    "        List of edges not covered (empty if feasible)\n",
-    "    \"\"\"\n",
-    "    nodes = list(F.nodes())\n",
-    "\n",
-    "    if len(bitstring) != len(nodes):\n",
-    "        raise ValueError(\"Bitstring length does not match number of nodes\")\n",
-    "\n",
-    "    cover = {\n",
-    "        nodes[i]\n",
-    "        for i, b in enumerate(bitstring)\n",
-    "        if b == \"1\"\n",
-    "    }\n",
-    "\n",
-    "    uncovered_edges = [\n",
-    "        (u, v)\n",
-    "        for u, v in F.edges()\n",
-    "        if u not in cover and v not in cover\n",
-    "    ]\n",
-    "\n",
-    "    return len(uncovered_edges) == 0, uncovered_edges\n",
-    "import networkx as nx\n",
-    "\n",
-    "def vertex_cover_cost(\n",
-    "    G: nx.Graph,\n",
-    "    bitstring: str,\n",
-    "    c: dict,\n",
-    "    check_feasible: bool = True\n",
-    "):\n",
-    "    \"\"\"\n",
-    "    Compute the cost of a vertex cover encoded by a bitstring.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    G : nx.Graph\n",
-    "        Input graph\n",
-    "    bitstring : str\n",
-    "        Binary string, one bit per node (ordered as G.nodes())\n",
-    "    c : dict\n",
-    "        Cost dictionary {node: cost}\n",
-    "    check_feasible : bool\n",
-    "        If True, raise an error if bitstring is not a vertex cover\n",
-    "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    cost : float\n",
-    "        Total cost of the vertex cover\n",
-    "    \"\"\"\n",
-    "    nodes = list(G.nodes())\n",
-    "\n",
-    "    if len(bitstring) != len(nodes):\n",
-    "        raise ValueError(\"Bitstring length does not match number of nodes\")\n",
-    "\n",
-    "    cover = {\n",
-    "        nodes[i]\n",
-    "        for i, b in enumerate(bitstring)\n",
-    "        if b == \"1\"\n",
-    "    }\n",
-    "\n",
-    "    if check_feasible:\n",
-    "        for u, v in G.edges():\n",
-    "            if u not in cover and v not in cover:\n",
-    "                raise ValueError(\n",
-    "                    f\"Bitstring is not a vertex cover: edge ({u}, {v}) uncovered\"\n",
-    "                )\n",
-    "\n",
-    "    cost = sum(c[node] for node in cover)\n",
-    "\n",
-    "    return cost\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "843094fb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{0, 2, 3, 4, 5, 7, 8, 11}\n",
-      "Optimal cost: 4.220931534246878\n",
-      "{0, 2, 3, 4, 5, 7, 8, 11}\n",
-      "Optimal cost: 4.220931534246878\n",
-      "4.619493701651056\n",
-      "4.220931534246878\n",
-      "10111101100100 4.220931534246878\n",
-      "True\n",
-      "4.220931534246878\n",
-      "10111101100100 4.220931534246878\n",
-      "True\n",
-      "4.220931534246878\n",
-      "10111101100100 4.220931534246878\n",
-      "True\n"
-     ]
-    }
-   ],
-   "source": [
-    "from classical_heuristics_util import SimulatedAnnealingWeighted\n",
-    "#G = nx.erdos_renyi_graph(n=n, p=degree, seed=int(graph_seed))\n",
-    "\n",
-    "\n",
-    "if case == \"unweighted\":\n",
-    "    c = {i: 1.0 for i in G.nodes()}\n",
-    "else:\n",
-    "    c = {i: random.uniform(0.40, 0.70) for i in G.nodes()}\n",
-    "\n",
-    "#C_opt = mvc_exact_cplex(G, c)\n",
-    "\n",
-    "C_opt = mvc_exact_cplex(G, c)\n",
-    "opt_cost = sum(c[i] for i in C_opt)\n",
-    "\n",
-    "print(C_opt)\n",
-    "print(\"Optimal cost:\", opt_cost)\n",
-    "\n",
-    "C_opt=SimulatedAnnealingWeighted(G,c,T=100,alpha=0.95,max_iter=1000).run()\n",
-    "opt_cost = sum(c[i] for i in C_opt) \n",
-    "print(C_opt)\n",
-    "print(\"Optimal cost:\", opt_cost)\n",
-    "\n",
-    "\n",
-    "\n",
-    "C_lp = mvc_lp_relaxation(G, c)\n",
-    "results[\"LP\"].append(sum(c[i] for i in C_lp) / opt_cost)\n",
-    "\n",
-    "C_pd = mvc_primal_dual_weighted(G,  c)\n",
-    "results[\"Dual-Primal\"].append(sum(c[i] for i in C_pd) / opt_cost)\n",
-    "\n",
-    "C_gd = greedy_degree_vertex_cover(G,c)\n",
-    "results[\"Greedy vertex degree\"].append(sum(c[i] for i in C_gd) / opt_cost)\n",
-    "print(sum(c[i] for i in C_gd) )\n",
-    "                                   \n",
-    "for s in range(n_stat):\n",
-    "    run_seed = rng.integers(1e9)\n",
-    "    random.seed(int(run_seed))\n",
-    "    np.random.seed(int(run_seed))\n",
-    "\n",
-    "    C_ge = greedy_edge_vertex_cover(G,c)\n",
-    "    results[\"Greedy random edge\"].append(sum(c[i] for i in C_ge) / opt_cost)\n",
-    "\n",
-    "qc, betas, Gn = mixer_from_graph(G,c)\n",
-    "\n",
-    "C_cost = c\n",
-    "\n",
-    "beta_bias1={i: 0.8*np.pi/2 for i in C_cost} #bias\n",
-    "#beta_bias2={i: ((i+1)/len(C_cost)*np.pi/2) for i in C_cost} #depth dependent \n",
-    "beta_bias2={i: np.pi/4+((i+1)/len(C_cost)*np.pi/2) for i in C_cost} #depth dependent \n",
-    "beta_bias3={i: np.random.uniform(np.pi/4,np.pi/2) for i in C_cost} # random \n",
-    "beta_bias4={i: np.pi/4 for i in C_cost} # equal \n",
-    "# warm started\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "sol_weighted= greedy_optimize_seq(qc, betas, C_cost, beta_bias1, shots=shots)\n",
-    "E_weighted1,sol1= expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted1)\n",
-    "print(sol1[::-1],vertex_cover_cost(G,sol1[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol1[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted= greedy_optimize_seq(qc, betas, C_cost, beta_bias2, shots=shots)\n",
-    "E_weighted2,sol2 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted2)\n",
-    "print(sol2[::-1],vertex_cover_cost(G,sol2[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol2[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted= greedy_optimize_seq(qc, betas, C_cost, beta_bias3, shots=shots)\n",
-    "E_weighted3,sol3 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted3)\n",
-    "print(sol3[::-1],vertex_cover_cost(G,sol3[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol3[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted= greedy_optimize(qc, betas, C_cost, beta_bias1, shots=shots)\n",
-    "E_weighted4 ,sol4= expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted4)\n",
-    "print(sol4[::-1],vertex_cover_cost(G,sol4[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol4[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted = greedy_optimize(qc, betas, C_cost, beta_bias2, shots=shots)\n",
-    "E_weighted5,sol5 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted5)\n",
-    "print(sol5[::-1],vertex_cover_cost(G,sol5[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol5[::-1])\n",
-    "print(Feas)\n",
-    "results[\"Quantum greedy bias\"].append(E_weighted3 / opt_cost)\n",
-    "sol_weighted= greedy_optimize(qc, betas, C_cost, beta_bias3, shots=shots)\n",
-    "E_weighted6,sol6 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted6)\n",
-    "Feas,uncover=is_vertex_cover(G, sol6[::-1])\n",
-    "print(sol6[::-1],vertex_cover_cost(G,sol6[::-1],c))\n",
-    "print(Feas)\n",
-    "\n",
-    "results[\"Quantum greedy seq bias\"].append(E_weighted6 / opt_cost)\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "25c9d5cc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "25.0"
-      ]
-     },
-     "execution_count": 112,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "15*100/60"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9415309e",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'en1' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[113]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;66;03m# Convert to NumPy array\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m data1 = np.array(\u001b[43men1\u001b[49m)\n\u001b[32m      3\u001b[39m data2 = np.array(en2)\n\u001b[32m      4\u001b[39m data3 = np.array(en3)\n",
-      "\u001b[31mNameError\u001b[39m: name 'en1' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "# Convert to NumPy array\n",
-    "data1 = np.array(en1)\n",
-    "data2 = np.array(en2)\n",
-    "data3 = np.array(en3)\n",
-    "data4 = np.array(en4)\n",
-    "data5 = np.array(en5)\n",
-    "data6 = np.array(en6)\n",
-    "# Rearrange each row: [max, min]\n",
-    "rearranged_data1 = np.column_stack((\n",
-    "    np.max(data1, axis=1),\n",
-    "    np.min(data1, axis=1)\n",
-    "))\n",
-    "rearranged_data2 = np.column_stack((\n",
-    "    np.max(data2, axis=1),\n",
-    "    np.min(data2, axis=1)\n",
-    "))\n",
-    "rearranged_data3 = np.column_stack((\n",
-    "    np.max(data3, axis=1),\n",
-    "    np.min(data3, axis=1)\n",
-    "))\n",
-    "rearranged_data4 = np.column_stack((\n",
-    "    np.max(data4, axis=1),\n",
-    "    np.min(data4, axis=1)\n",
-    "))\n",
-    "rearranged_data5 = np.column_stack((\n",
-    "    np.max(data5, axis=1),\n",
-    "    np.min(data5, axis=1)\n",
-    "))\n",
-    "rearranged_data6 = np.column_stack((\n",
-    "    np.max(data6, axis=1),\n",
-    "    np.min(data6, axis=1)\n",
-    "))\n",
-    "# X axis (index)\n",
-    "x = np.arange(len(data1))\n",
-    "\n",
-    "\n",
-    "# Plot\n",
-    "plt.figure()\n",
-    "#plt.plot(x, rearranged_data1[:, 0]/opt_cost, label=\"big 1\")\n",
-    "plt.plot(x, rearranged_data1[:, 1]/opt_cost, label=\"small 1\")\n",
-    "#plt.plot(x, rearranged_data2[:, 0]/opt_cost, label=\"big 2\")\n",
-    "plt.plot(x, rearranged_data2[:, 1]/opt_cost, label=\"small 2\")\n",
-    "#plt.plot(x, rearranged_data3[:, 0]/opt_cost, label=\"big 3\")\n",
-    "plt.plot(x, rearranged_data3[:, 1]/opt_cost, label=\"small 3\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, rearranged_data4[:, 1]/opt_cost, label=\"small 4\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, rearranged_data5[:, 1]/opt_cost, label=\"small 5\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, rearranged_data6[:, 1]/opt_cost, label=\"small 6\")\n",
-    "plt.axhline(y=results[\"Greedy vertex degree\"][0], linestyle='--', linewidth=2)\n",
-    "plt.xlabel(\"Index\")\n",
-    "plt.ylabel(\"Value\")\n",
-    "plt.title(\"First and Second Column\")\n",
-    "plt.legend()\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "174cbe09",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Plot\n",
-    "plt.figure()\n",
-    "#plt.plot(x, rearranged_data1[:, 0]/opt_cost, label=\"big 1\")\n",
-    "plt.plot(x, -rearranged_data1[:, 1]+rearranged_data1[:, 0], label=\"small 1\")\n",
-    "#plt.plot(x, rearranged_data2[:, 0]/opt_cost, label=\"big 2\")\n",
-    "plt.plot(x, -rearranged_data2[:, 1]+rearranged_data2[:, 0], label=\"small 2\")\n",
-    "#plt.plot(x, rearranged_data3[:, 0]/opt_cost, label=\"big 3\")\n",
-    "plt.plot(x, -rearranged_data3[:, 1]+rearranged_data3[:, 0], label=\"small 3\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, -rearranged_data4[:, 1]+rearranged_data4[:, 0], label=\"small 4\")\n",
-    "plt.plot(x, -rearranged_data5[:, 1]+rearranged_data5[:, 0], label=\"small 5\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, -rearranged_data6[:, 1]+rearranged_data6[:, 0], label=\"small 6\")\n",
-    "\n",
-    "#plt.axhline(y=results[\"Greedy vertex degree\"][0], linestyle='--', linewidth=2)\n",
-    "plt.xlabel(\"Index\")\n",
-    "plt.ylabel(\"Value\")\n",
-    "plt.title(\"First and Second Column\")\n",
-    "plt.legend()\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b6397471",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'LP': [1.6739977579524865],\n",
-       " 'Dual-Primal': [1.2405251777891808],\n",
-       " 'Greedy random edge': [1.0],\n",
-       " 'Greedy vertex degree': [1.0118899007402822],\n",
-       " 'Quantum greedy bias': [np.float64(0.9836417454870796)],\n",
-       " 'Quantum greedy seq bias': [np.float64(0.9836417454870793)]}"
-      ]
-     },
-     "execution_count": 318,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3a35d529",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d2eca4a3",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv (3.11.5)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/MVC/QGMVC_experiments copy.ipynb b/MVC/QGMVC_experiments copy.ipynb
deleted file mode 100644
index 529526c..0000000
--- a/MVC/QGMVC_experiments copy.ipynb	
+++ /dev/null
@@ -1,788 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 279,
-   "id": "44dddc40",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from __future__ import annotations\n",
-    "from typing import Union\n",
-    "import random\n",
-    "import math\n",
-    "\n",
-    "import networkx as nx\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Optional rustworkx support\n",
-    "try:\n",
-    "    import rustworkx as rx\n",
-    "    RxGraph = rx.PyGraph\n",
-    "except ImportError:\n",
-    "    rx = None\n",
-    "    RxGraph = tuple()\n",
-    "\n",
-    "# Qiskit imports\n",
-    "from qiskit import QuantumCircuit\n",
-    "from qiskit.circuit import Parameter\n",
-    "from qiskit.circuit.library import RXGate\n",
-    "from qiskit.quantum_info import Statevector, SparsePauliOp\n",
-    "from qiskit_aer import Aer\n",
-    "from qiskit import transpile\n",
-    "\n",
-    "# CPLEX import\n",
-    "from docplex.mp.model import Model\n",
-    "from quantum_greedy_util import mixer_from_graph,expectation_value_cost_shifted_with_bitstring,greedy_optimize,greedy_optimize_seq\n",
-    "#from classical_heuristics_util import is_vertex_cover, local_search_vertex_cover, ga_vertex_cover\n",
-    "from classical_runtime_guarantee_util import mvc_exact_cplex, mvc_lp_relaxation, greedy_degree_vertex_cover, greedy_edge_vertex_cover,mvc_primal_dual_weighted\n",
-    "import os\n",
-    "import pickle"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 280,
-   "id": "3c5e478d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " You are running without reading from qaoa_settings.txt - you should never see this message on solstorm!\n",
-      "[INFO] graph pickle counts per requested size:\n",
-      "  n8: 1\n",
-      "  n10: 1\n",
-      "  n12: 1\n",
-      "  n14: 1\n",
-      "  n16: 0\n",
-      "  n18: 0\n",
-      "  n20: 1\n"
-     ]
-    }
-   ],
-   "source": [
-    "local = True\n",
-    "\n",
-    "# Configuration: change these constants in this file to control runs\n",
-    "# LIMIT: number of graphs to process (None -> all)\n",
-    "# REPS: number of repetitions per parameter set\n",
-    "LIMIT = 20\n",
-    "\n",
-    "# If True, treat `LIMIT` as a per-size limit when the script iterates over\n",
-    "# multiple graph sizes (useful when you want N graphs per size). If False,\n",
-    "# LIMIT caps the total number of graphs across all sizes.\n",
-    "LIMIT_PER_SIZE = False\n",
-    "\n",
-    "if local:\n",
-    "    # depths 1..4\n",
-    "    settings = [\n",
-    "        {'backend_mode': 'statevector',\n",
-    "         'problem_type': 'minvertexcover',\n",
-    "         'qaoa_variant': 'multiangle_cpm_no_cost_custom',\n",
-    "         'param_initialization': 'uniform',\n",
-    "         'optimizer': 'BFGS',\n",
-    "         'depth': d,\n",
-    "         'warm_start': False}\n",
-    "        for d in range(1, 5)\n",
-    "    ]\n",
-    "    print(' You are running without reading from qaoa_settings.txt - you should never see this message on solstorm!')\n",
-    "#/p/fm/FinleyQuinton/QAOA/QAOA_copy/QAOA_copy/run_my_qaoa/results/graphs/paper_graphs/3_regular/rdr3_20_paper_graphs_n8.pkl\n",
-    "# -------------------- LOAD GRAPHS -------------------- #\n",
-    "#erdos_20_paper_graphs_05P_n20.pkl\n",
-    "#rdr3_20_paper_graphs_n20.pkl\n",
-    "graph_dir = os.path.join(os.path.dirname('erdos_20_paper_graphs_05P_n8.pkl'), \"graphs\", \"erdos\")\n",
-    "from glob import glob\n",
-    "\n",
-    "# include sizes 8,10,...,14\n",
-    "sizes = [8, 10, 12, 14,16,18,20]\n",
-    "graph_files = []\n",
-    "per_size_counts = {}\n",
-    "for s in sizes:\n",
-    "    pattern = os.path.join(graph_dir, f\"*n{s}.pkl\")\n",
-    "    found = sorted(glob(pattern))\n",
-    "    if not found:\n",
-    "        # also accept files that contain the size number elsewhere\n",
-    "        found = sorted(glob(os.path.join(graph_dir, f\"*{s}*.pkl\")))\n",
-    "    # Optionally limit per-size if requested\n",
-    "    if LIMIT is not None and LIMIT_PER_SIZE and found:\n",
-    "        found = found[:LIMIT]\n",
-    "    # record how many pickle files were found for this size (after optional per-size LIMIT)\n",
-    "    per_size_counts[s] = len(found)\n",
-    "    graph_files.extend(found)\n",
-    "\n",
-    "if not graph_files:\n",
-    "    raise RuntimeError(f\"No graph files found in {graph_dir} for sizes {sizes}\")\n",
-    "\n",
-    "# Print per-size summary so user can verify how many pickles were found per size\n",
-    "print(\"[INFO] graph pickle counts per requested size:\")\n",
-    "for s in sizes:\n",
-    "    print(f\"  n{s}: {per_size_counts.get(s, 0)}\")\n",
-    "\n",
-    "graph_data = []\n",
-    "for gf in graph_files:\n",
-    "    with open(gf, \"rb\") as f:\n",
-    "        try:\n",
-    "            data = pickle.load(f)\n",
-    "            if isinstance(data, list):\n",
-    "                graph_data.extend(data)\n",
-    "        except Exception as e:\n",
-    "            print(f\"Failed to load {gf}: {e}\")\n",
-    "\n",
-    "graphs = [g[\"graph\"] if isinstance(g, dict) and \"graph\" in g else g for g in graph_data]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 281,
-   "id": "03b21468",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def rx_to_nx(rx_graph):\n",
-    "\n",
-    "    G = nx.Graph()\n",
-    "\n",
-    "     # Nodes: indices + data\n",
-    "    for i in rx_graph.node_indices():\n",
-    "        data = rx_graph[i]          # node payload\n",
-    "        G.add_node(i, data=data)\n",
-    "\n",
-    "    # Edges: indices + weight/data\n",
-    "    for u, v, w in rx_graph.weighted_edge_list():\n",
-    "        if isinstance(w, dict):\n",
-    "            G.add_edge(u, v, **w)\n",
-    "        else:\n",
-    "            G.add_edge(u, v, weight=w)\n",
-    "\n",
-    "    return G"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "485de73e",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 282,
-   "id": "0840f18f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "k=-2\n",
-    "G=rx_to_nx(graphs[k]) if rx and isinstance(graphs[k], RxGraph) else graphs[k]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9cb1e380",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 283,
-   "id": "fae1eff9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "case=\"weighted\"\n",
-    "graph_type=\"regular\"\n",
-    "degree=3\n",
-    "shots=None\n",
-    "seed=None\n",
-    "rng = np.random.default_rng(seed)\n",
-    "graph_seed = rng.integers(1e9)\n",
-    "n=14\n",
-    "n_stat=1\n",
-    "results = {\"LP\": [], \"Dual-Primal\": [], \"Greedy random edge\": [], \"Greedy vertex degree\": [], \"Quantum greedy bias\": [], \"Quantum greedy seq bias\": []}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 284,
-   "id": "41b2eab9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if graph_type == \"erdos\":\n",
-    "    p = degree\n",
-    "    G = nx.erdos_renyi_graph(n, p)\n",
-    "elif graph_type == \"regular\":\n",
-    "    G = nx.random_regular_graph(degree, n)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 285,
-   "id": "541867e8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "\n",
-    "def plot_graph(G):\n",
-    "    \"\"\"Plot a NetworkX graph with labels.\"\"\"\n",
-    "    plt.figure(figsize=(4,4))\n",
-    "    pos = nx.spring_layout(G, seed=42)  # nice-looking layout\n",
-    "\n",
-    "    nx.draw(\n",
-    "        G, pos,\n",
-    "        with_labels=True,\n",
-    "        node_size=800,\n",
-    "        node_color=\"lightblue\",\n",
-    "        font_size=12,\n",
-    "        font_weight=\"bold\",\n",
-    "        edge_color=\"gray\"\n",
-    "    )\n",
-    "\n",
-    "    plt.title(\"Graph G\")\n",
-    "    plt.axis(\"off\")\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 286,
-   "id": "cec59568",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_graph(G)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 287,
-   "id": "3f00e0f2",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'\"QGMVC_experiments copy.ipynb\"\\ndef node_order_by_cost_degree1(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (G.degree(i), -C[i]),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph1(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree1(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\n\\ndef node_order_by_cost_degree2(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (G.degree(i), C[i]),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph2(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree2(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\n\\ndef node_order_by_cost_degree3(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        #key=lambda i: (G.degree(i), -C[i]),\\n        key=lambda i: (G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph3(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree3(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\n\\ndef node_order_by_cost_degree4(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        key=lambda i: (i)\\n        #key=lambda i: (G.degree(i), -C[i]),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph4(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree4(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\ndef node_order_by_cost_degree5(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (C[i],G.degree(i)),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph5(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree5(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n\\ndef node_order_by_cost_degree6(G, C):\\n    \"\"\"\\n    Order nodes by:\\n      1) descending cost\\n      2) descending degree\\n    \"\"\"\\n    return sorted(\\n        G.nodes(),\\n        #key=lambda i: (i)\\n        key=lambda i: (-C[i],G.degree(i)),\\n        #key=lambda i: (-G.degree(i)/C[i])\\n    )\\n\\n\\n\\n# ---------------- Graph & mixer ----------------\\n\\ndef mixer_from_graph6(G,c):\\n    G = nx.convert_node_labels_to_integers(G)\\n    n = G.number_of_nodes()\\n    qc = QuantumCircuit(n)\\n    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\\n\\n    for i in range(n):\\n        qc.x(i)\\n    # 🔥 ORDER NODES HERE\\n    ordered_nodes = node_order_by_cost_degree6(G,c)\\n    for tgt in ordered_nodes:\\n        angle = 2 * betas[tgt]\\n        ctrls = list(G.neighbors(tgt))\\n        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\\n\\n\\n    return qc, betas, G\\n    '"
-      ]
-     },
-     "execution_count": 287,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'''\"QGMVC_experiments copy.ipynb\"\n",
-    "def node_order_by_cost_degree1(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (G.degree(i), -C[i]),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph1(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree1(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "\n",
-    "def node_order_by_cost_degree2(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (G.degree(i), C[i]),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph2(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree2(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "\n",
-    "def node_order_by_cost_degree3(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        #key=lambda i: (G.degree(i), -C[i]),\n",
-    "        key=lambda i: (G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph3(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree3(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "\n",
-    "def node_order_by_cost_degree4(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        key=lambda i: (i)\n",
-    "        #key=lambda i: (G.degree(i), -C[i]),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph4(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree4(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "def node_order_by_cost_degree5(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (C[i],G.degree(i)),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph5(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree5(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "\n",
-    "def node_order_by_cost_degree6(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (-C[i],G.degree(i)),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph6(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree6(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n",
-    "    '''\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 288,
-   "id": "940b7c79",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def mean_field_cost_degree_order_init(G, C_cost, order, alpha=1, beta=1, gamma=1,delta=0.2, n_iter=30):\n",
-    "    n = len(G)\n",
-    "    rank = {j: k / n for k, j in enumerate(order)}\n",
-    "    p = {j: 0.5 for j in G.nodes()}\n",
-    "    maxcost= max(C_cost)\n",
-    "    for _ in range(n_iter):\n",
-    "        p_new = {}\n",
-    "        for j in G.nodes():\n",
-    "            dj = max(1, G.degree(j))\n",
-    "            neigh_pressure = sum(p[k] for k in G.neighbors(j)) / dj\n",
-    "            field = (\n",
-    "                alpha * C_cost[j]\n",
-    "                - beta * neigh_pressure\n",
-    "                - gamma * rank[j]\n",
-    "            )\n",
-    "            p_new[j] = 1.0 / (1.0 + np.exp(-delta*field))\n",
-    "        p = p_new\n",
-    "\n",
-    "    return {j: np.arcsin(np.sqrt(p[j])) for j in p}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 289,
-   "id": "86791a06",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "\n",
-    "def is_vertex_cover(F: nx.Graph, bitstring: str):\n",
-    "    \"\"\"\n",
-    "    Check if a bitstring represents a feasible vertex cover.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    F : nx.Graph\n",
-    "        Input graph\n",
-    "    bitstring : str\n",
-    "        Binary string, one bit per node (ordered as F.nodes())\n",
-    "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    feasible : bool\n",
-    "        True if bitstring is a vertex cover\n",
-    "    uncovered_edges : list\n",
-    "        List of edges not covered (empty if feasible)\n",
-    "    \"\"\"\n",
-    "    nodes = list(F.nodes())\n",
-    "\n",
-    "    if len(bitstring) != len(nodes):\n",
-    "        raise ValueError(\"Bitstring length does not match number of nodes\")\n",
-    "\n",
-    "    cover = {\n",
-    "        nodes[i]\n",
-    "        for i, b in enumerate(bitstring)\n",
-    "        if b == \"1\"\n",
-    "    }\n",
-    "\n",
-    "    uncovered_edges = [\n",
-    "        (u, v)\n",
-    "        for u, v in F.edges()\n",
-    "        if u not in cover and v not in cover\n",
-    "    ]\n",
-    "\n",
-    "    return len(uncovered_edges) == 0, uncovered_edges\n",
-    "import networkx as nx\n",
-    "\n",
-    "def vertex_cover_cost(\n",
-    "    G: nx.Graph,\n",
-    "    bitstring: str,\n",
-    "    c: dict,\n",
-    "    check_feasible: bool = True\n",
-    "):\n",
-    "    \"\"\"\n",
-    "    Compute the cost of a vertex cover encoded by a bitstring.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    G : nx.Graph\n",
-    "        Input graph\n",
-    "    bitstring : str\n",
-    "        Binary string, one bit per node (ordered as G.nodes())\n",
-    "    c : dict\n",
-    "        Cost dictionary {node: cost}\n",
-    "    check_feasible : bool\n",
-    "        If True, raise an error if bitstring is not a vertex cover\n",
-    "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    cost : float\n",
-    "        Total cost of the vertex cover\n",
-    "    \"\"\"\n",
-    "    nodes = list(G.nodes())\n",
-    "\n",
-    "    if len(bitstring) != len(nodes):\n",
-    "        raise ValueError(\"Bitstring length does not match number of nodes\")\n",
-    "\n",
-    "    cover = {\n",
-    "        nodes[i]\n",
-    "        for i, b in enumerate(bitstring)\n",
-    "        if b == \"1\"\n",
-    "    }\n",
-    "\n",
-    "    if check_feasible:\n",
-    "        for u, v in G.edges():\n",
-    "            if u not in cover and v not in cover:\n",
-    "                raise ValueError(\n",
-    "                    f\"Bitstring is not a vertex cover: edge ({u}, {v}) uncovered\"\n",
-    "                )\n",
-    "\n",
-    "    cost = sum(c[node] for node in cover)\n",
-    "\n",
-    "    return cost\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 290,
-   "id": "843094fb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{0, 1, 3, 8, 9, 10, 12, 13}\n",
-      "Optimal cost: 4.678820039157657\n",
-      "{0, 1, 3, 8, 9, 10, 12, 13}\n",
-      "Optimal cost: 4.678820039157657\n",
-      "4.793101716562574\n",
-      "4.897822529091866\n",
-      "01101111110100 4.897822529091866\n",
-      "True\n",
-      "4.897822529091865\n",
-      "01101111110100 4.897822529091866\n",
-      "True\n",
-      "4.897822529091866\n",
-      "01101111110100 4.897822529091866\n",
-      "True\n",
-      "4.793101716562574\n",
-      "00111101110110 4.793101716562574\n",
-      "True\n",
-      "4.8937991602515485\n",
-      "10101111010110 4.893799160251548\n",
-      "True\n",
-      "4.833154913107865\n",
-      "00101111110110 4.833154913107865\n",
-      "True\n"
-     ]
-    }
-   ],
-   "source": [
-    "from classical_heuristics_util import SimulatedAnnealingWeighted\n",
-    "#G = nx.erdos_renyi_graph(n=n, p=degree, seed=int(graph_seed))\n",
-    "\n",
-    "\n",
-    "if case == \"unweighted\":\n",
-    "    c = {i: 1.0 for i in G.nodes()}\n",
-    "else:\n",
-    "    c = {i: random.uniform(0.40, 0.70) for i in G.nodes()}\n",
-    "\n",
-    "#C_opt = mvc_exact_cplex(G, c)\n",
-    "\n",
-    "C_opt = mvc_exact_cplex(G, c)\n",
-    "opt_cost = sum(c[i] for i in C_opt)\n",
-    "\n",
-    "print(C_opt)\n",
-    "print(\"Optimal cost:\", opt_cost)\n",
-    "\n",
-    "C_opt=SimulatedAnnealingWeighted(G,c,T=100,alpha=0.95,max_iter=1000).run()\n",
-    "opt_cost = sum(c[i] for i in C_opt) \n",
-    "print(C_opt)\n",
-    "print(\"Optimal cost:\", opt_cost)\n",
-    "\n",
-    "\n",
-    "\n",
-    "C_lp = mvc_lp_relaxation(G, c)\n",
-    "results[\"LP\"].append(sum(c[i] for i in C_lp) / opt_cost)\n",
-    "\n",
-    "C_pd = mvc_primal_dual_weighted(G,  c)\n",
-    "results[\"Dual-Primal\"].append(sum(c[i] for i in C_pd) / opt_cost)\n",
-    "\n",
-    "C_gd = greedy_degree_vertex_cover(G,c)\n",
-    "results[\"Greedy vertex degree\"].append(sum(c[i] for i in C_gd) / opt_cost)\n",
-    "print(sum(c[i] for i in C_gd) )\n",
-    "                                   \n",
-    "for s in range(n_stat):\n",
-    "    run_seed = rng.integers(1e9)\n",
-    "    random.seed(int(run_seed))\n",
-    "    np.random.seed(int(run_seed))\n",
-    "\n",
-    "    C_ge = greedy_edge_vertex_cover(G,c)\n",
-    "    results[\"Greedy random edge\"].append(sum(c[i] for i in C_ge) / opt_cost)\n",
-    "\n",
-    "qc, betas, Gn = mixer_from_graph(G,c)\n",
-    "\n",
-    "C_cost = c\n",
-    "\n",
-    "beta_bias1={i: 0.8*np.pi/2 for i in C_cost} #bias\n",
-    "beta_bias1={i: np.pi/8+((i+1)/len(C_cost)*np.pi/8)+0.1 for i in C_cost} #depth dependent \n",
-    "#beta_bias2={i: ((i+1)/len(C_cost)*np.pi/2) for i in C_cost} #depth dependent \n",
-    "#beta_bias2={i: np.pi/4+((i+1)/len(C_cost)*np.pi/2) for i in C_cost} #depth dependent \n",
-    "beta_bias2={i: np.random.uniform(np.pi/4,np.pi/2) for i in C_cost} # random \n",
-    "beta_bias2={i: np.pi/4+((i+1)/len(C_cost)*np.pi/8)*0.2 for i in C_cost} #depth dependent \n",
-    "beta_bias3={i: np.pi/4 for i in C_cost} # equal \n",
-    "# warm started\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "sol_weighted= greedy_optimize_seq(qc, betas, C_cost, beta_bias1, shots=shots)\n",
-    "E_weighted1,sol1= expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted1)\n",
-    "print(sol1[::-1],vertex_cover_cost(G,sol1[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol1[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted= greedy_optimize_seq(qc, betas, C_cost, beta_bias2, shots=shots)\n",
-    "E_weighted2,sol2 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted2)\n",
-    "print(sol2[::-1],vertex_cover_cost(G,sol2[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol2[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted= greedy_optimize_seq(qc, betas, C_cost, beta_bias3, shots=shots)\n",
-    "E_weighted3,sol3 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted3)\n",
-    "print(sol3[::-1],vertex_cover_cost(G,sol3[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol3[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted= greedy_optimize(qc, betas, C_cost, beta_bias1, shots=shots)\n",
-    "E_weighted4 ,sol4= expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted4)\n",
-    "print(sol4[::-1],vertex_cover_cost(G,sol4[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol4[::-1])\n",
-    "print(Feas)\n",
-    "sol_weighted = greedy_optimize(qc, betas, C_cost, beta_bias2, shots=shots)\n",
-    "E_weighted5,sol5 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted5)\n",
-    "print(sol5[::-1],vertex_cover_cost(G,sol5[::-1],c))\n",
-    "Feas,uncover=is_vertex_cover(G, sol5[::-1])\n",
-    "print(Feas)\n",
-    "results[\"Quantum greedy bias\"].append(E_weighted3 / opt_cost)\n",
-    "sol_weighted= greedy_optimize(qc, betas, C_cost, beta_bias3, shots=shots)\n",
-    "E_weighted6,sol6 = expectation_value_cost_shifted_with_bitstring(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "print(E_weighted6)\n",
-    "Feas,uncover=is_vertex_cover(G, sol6[::-1])\n",
-    "print(sol6[::-1],vertex_cover_cost(G,sol6[::-1],c))\n",
-    "print(Feas)\n",
-    "\n",
-    "results[\"Quantum greedy seq bias\"].append(E_weighted6 / opt_cost)\n",
-    "\n",
-    "\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv (3.11.5)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/MVC/QGMVC_experiments.ipynb b/MVC/QGMVC_experiments.ipynb
deleted file mode 100644
index a955748..0000000
--- a/MVC/QGMVC_experiments.ipynb
+++ /dev/null
@@ -1,759 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 178,
-   "id": "44dddc40",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from __future__ import annotations\n",
-    "from typing import Union\n",
-    "import random\n",
-    "import math\n",
-    "\n",
-    "import networkx as nx\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Optional rustworkx support\n",
-    "try:\n",
-    "    import rustworkx as rx\n",
-    "    RxGraph = rx.PyGraph\n",
-    "except ImportError:\n",
-    "    rx = None\n",
-    "    RxGraph = tuple()\n",
-    "\n",
-    "# Qiskit imports\n",
-    "from qiskit import QuantumCircuit\n",
-    "from qiskit.circuit import Parameter\n",
-    "from qiskit.circuit.library import RXGate\n",
-    "from qiskit.quantum_info import Statevector, SparsePauliOp\n",
-    "from qiskit_aer import Aer\n",
-    "from qiskit import transpile\n",
-    "\n",
-    "# CPLEX import\n",
-    "from docplex.mp.model import Model\n",
-    "from quantum_greedy_util import mixer_from_graph\n",
-    "#from classical_heuristics_util import is_vertex_cover, local_search_vertex_cover, ga_vertex_cover\n",
-    "from classical_runtime_guarantee_util import mvc_exact_cplex, mvc_lp_relaxation, greedy_degree_vertex_cover, greedy_edge_vertex_cover,mvc_primal_dual_weighted\n",
-    "import os\n",
-    "import pickle"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 179,
-   "id": "3c5e478d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " You are running without reading from qaoa_settings.txt - you should never see this message on solstorm!\n",
-      "[INFO] graph pickle counts per requested size:\n",
-      "  n8: 1\n",
-      "  n10: 1\n",
-      "  n12: 1\n",
-      "  n14: 1\n",
-      "  n16: 0\n",
-      "  n18: 0\n",
-      "  n20: 1\n"
-     ]
-    }
-   ],
-   "source": [
-    "local = True\n",
-    "\n",
-    "# Configuration: change these constants in this file to control runs\n",
-    "# LIMIT: number of graphs to process (None -> all)\n",
-    "# REPS: number of repetitions per parameter set\n",
-    "LIMIT = 20\n",
-    "\n",
-    "# If True, treat `LIMIT` as a per-size limit when the script iterates over\n",
-    "# multiple graph sizes (useful when you want N graphs per size). If False,\n",
-    "# LIMIT caps the total number of graphs across all sizes.\n",
-    "LIMIT_PER_SIZE = False\n",
-    "\n",
-    "if local:\n",
-    "    # depths 1..4\n",
-    "    settings = [\n",
-    "        {'backend_mode': 'statevector',\n",
-    "         'problem_type': 'minvertexcover',\n",
-    "         'qaoa_variant': 'multiangle_cpm_no_cost_custom',\n",
-    "         'param_initialization': 'uniform',\n",
-    "         'optimizer': 'BFGS',\n",
-    "         'depth': d,\n",
-    "         'warm_start': False}\n",
-    "        for d in range(1, 5)\n",
-    "    ]\n",
-    "    print(' You are running without reading from qaoa_settings.txt - you should never see this message on solstorm!')\n",
-    "#/p/fm/FinleyQuinton/QAOA/QAOA_copy/QAOA_copy/run_my_qaoa/results/graphs/paper_graphs/3_regular/rdr3_20_paper_graphs_n8.pkl\n",
-    "# -------------------- LOAD GRAPHS -------------------- #\n",
-    "#erdos_20_paper_graphs_05P_n20.pkl\n",
-    "#rdr3_20_paper_graphs_n20.pkl\n",
-    "graph_dir = os.path.join(os.path.dirname('erdos_20_paper_graphs_05P_n20.pkl'), \"graphs\", \"erdos\")\n",
-    "from glob import glob\n",
-    "\n",
-    "# include sizes 8,10,...,14\n",
-    "sizes = [8, 10, 12, 14,16,18,20]\n",
-    "graph_files = []\n",
-    "per_size_counts = {}\n",
-    "for s in sizes:\n",
-    "    pattern = os.path.join(graph_dir, f\"*n{s}.pkl\")\n",
-    "    found = sorted(glob(pattern))\n",
-    "    if not found:\n",
-    "        # also accept files that contain the size number elsewhere\n",
-    "        found = sorted(glob(os.path.join(graph_dir, f\"*{s}*.pkl\")))\n",
-    "    # Optionally limit per-size if requested\n",
-    "    if LIMIT is not None and LIMIT_PER_SIZE and found:\n",
-    "        found = found[:LIMIT]\n",
-    "    # record how many pickle files were found for this size (after optional per-size LIMIT)\n",
-    "    per_size_counts[s] = len(found)\n",
-    "    graph_files.extend(found)\n",
-    "\n",
-    "if not graph_files:\n",
-    "    raise RuntimeError(f\"No graph files found in {graph_dir} for sizes {sizes}\")\n",
-    "\n",
-    "# Print per-size summary so user can verify how many pickles were found per size\n",
-    "print(\"[INFO] graph pickle counts per requested size:\")\n",
-    "for s in sizes:\n",
-    "    print(f\"  n{s}: {per_size_counts.get(s, 0)}\")\n",
-    "\n",
-    "graph_data = []\n",
-    "for gf in graph_files:\n",
-    "    with open(gf, \"rb\") as f:\n",
-    "        try:\n",
-    "            data = pickle.load(f)\n",
-    "            if isinstance(data, list):\n",
-    "                graph_data.extend(data)\n",
-    "        except Exception as e:\n",
-    "            print(f\"Failed to load {gf}: {e}\")\n",
-    "\n",
-    "graphs = [g[\"graph\"] if isinstance(g, dict) and \"graph\" in g else g for g in graph_data]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 194,
-   "id": "76bd1b96",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "100"
-      ]
-     },
-     "execution_count": 194,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(graphs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 180,
-   "id": "03b21468",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def rx_to_nx(rx_graph):\n",
-    "\n",
-    "    G = nx.Graph()\n",
-    "\n",
-    "     # Nodes: indices + data\n",
-    "    for i in rx_graph.node_indices():\n",
-    "        data = rx_graph[i]          # node payload\n",
-    "        G.add_node(i, data=data)\n",
-    "\n",
-    "    # Edges: indices + weight/data\n",
-    "    for u, v, w in rx_graph.weighted_edge_list():\n",
-    "        if isinstance(w, dict):\n",
-    "            G.add_edge(u, v, **w)\n",
-    "        else:\n",
-    "            G.add_edge(u, v, weight=w)\n",
-    "\n",
-    "    return G"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "485de73e",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 181,
-   "id": "0840f18f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "k=-2\n",
-    "G=rx_to_nx(graphs[k]) if rx and isinstance(graphs[k], RxGraph) else graphs[k]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9cb1e380",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 182,
-   "id": "df3ed6e9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def expectation_value_cost_shifted(qc, betas, C, beta_values, shots=None):\n",
-    "    bind_dict = {betas[i]: beta_values[i] for i in betas}\n",
-    "    qc_bound = qc.assign_parameters(bind_dict)\n",
-    "\n",
-    "    n = qc.num_qubits\n",
-    "    paulis = []\n",
-    "    coeffs = []\n",
-    "\n",
-    "    for i, c_i in C.items():\n",
-    "        p = [\"I\"] * n\n",
-    "        p[i] = \"Z\"\n",
-    "        paulis.append(\"\".join(p))\n",
-    "        coeffs.append(-0.5 * c_i)\n",
-    "\n",
-    "    HZ = SparsePauliOp(paulis, coeffs)\n",
-    "    shift = 0.5 * sum(C.values())\n",
-    "\n",
-    "    if shots is None:\n",
-    "        psi = Statevector.from_instruction(qc_bound)\n",
-    "        return shift + psi.expectation_value(HZ).real\n",
-    "\n",
-    "    # ----- shot-based -----\n",
-    "    qc_meas = qc_bound.copy()\n",
-    "    qc_meas.measure_all()\n",
-    "\n",
-    "    backend = Aer.get_backend(\"aer_simulator\")\n",
-    "    qc_meas = transpile(qc_meas, backend)\n",
-    "    counts = backend.run(qc_meas, shots=shots).result().get_counts()\n",
-    "\n",
-    "    exp_val = 0.0\n",
-    "    for bitstring, count in counts.items():\n",
-    "        prob = count / shots\n",
-    "        z_vals = np.array([1 if b == \"0\" else -1 for b in bitstring[::-1]])\n",
-    "\n",
-    "        hz_value = 0.0\n",
-    "        for i, c_i in C.items():\n",
-    "            hz_value += -0.5 * c_i * z_vals[i]\n",
-    "\n",
-    "        exp_val += prob * hz_value\n",
-    "\n",
-    "    return shift + exp_val"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 183,
-   "id": "13af780d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def greedy_optimize(qc, betas, C, beta_values,shots=None):\n",
-    "    values = beta_values.copy()\n",
-    "    free = list(betas.keys())\n",
-    "    energies=[]\n",
-    "    while free:\n",
-    "        i = random.choice(free)\n",
-    "        best_val = values[i]\n",
-    "        best_E = expectation_value_cost_shifted(qc, betas, C, values,shots)\n",
-    "        E_aux=[]\n",
-    "        for candidate in (0.0, math.pi/2):\n",
-    "            trial = values.copy()\n",
-    "            trial[i] =  candidate \n",
-    "\n",
-    "            E = expectation_value_cost_shifted(qc, betas, C, trial,shots)\n",
-    "            E_aux.append(E)\n",
-    "            if E < best_E:\n",
-    "                best_E = E\n",
-    "                best_val = candidate\n",
-    "        energies.append(E_aux)\n",
-    "        values[i] = best_val\n",
-    "        free.remove(i)\n",
-    "\n",
-    "    return values,energies\n",
-    "\n",
-    "def greedy_optimize_seq(qc, betas, C, beta_values,shots= None):\n",
-    "    values = beta_values.copy()\n",
-    "\n",
-    "    # assume betas is an ordered mapping or keys are index-like\n",
-    "    indices = list(betas.keys())\n",
-    "    energies=[]\n",
-    "    # iterate from last to first\n",
-    "    for i in reversed(indices):\n",
-    "    #for i in indices:\n",
-    "        best_val = values[i]\n",
-    "        best_E = expectation_value_cost_shifted(qc, betas, C, values,shots)\n",
-    "        E_aux=[]\n",
-    "        for candidate in (0.0, math.pi / 2):\n",
-    "            trial = values.copy()\n",
-    "            trial[i] = candidate\n",
-    "            E = expectation_value_cost_shifted(qc, betas, C, trial,shots)\n",
-    "            E_aux.append(E)\n",
-    "            if E < best_E:\n",
-    "                best_E = E\n",
-    "                best_val = candidate\n",
-    "        energies.append(E_aux)\n",
-    "        values[i] = best_val\n",
-    "\n",
-    "    return values,energies\n",
-    "\n",
-    "def greedy_optimize_seq_rev(qc, betas, C, beta_values,shots= None):\n",
-    "    values = beta_values.copy()\n",
-    "\n",
-    "    # assume betas is an ordered mapping or keys are index-like\n",
-    "    indices = list(betas.keys())\n",
-    "    energies=[]\n",
-    "    # iterate from last to first\n",
-    "    #for i in reversed(indices):\n",
-    "    for i in indices:\n",
-    "        best_val = values[i]\n",
-    "        best_E = expectation_value_cost_shifted(qc, betas, C, values,shots)\n",
-    "        E_aux=[]\n",
-    "        for candidate in (0.0, math.pi / 2):\n",
-    "            trial = values.copy()\n",
-    "            trial[i] = candidate\n",
-    "            E = expectation_value_cost_shifted(qc, betas, C, trial,shots)\n",
-    "            E_aux.append(E)\n",
-    "            if E < best_E:\n",
-    "                best_E = E\n",
-    "                best_val = candidate\n",
-    "        energies.append(E_aux)\n",
-    "        values[i] = best_val\n",
-    "\n",
-    "    return values,energies\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 184,
-   "id": "fae1eff9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "case=\"unweighted\"\n",
-    "graph_type=\"regular\"\n",
-    "degree=3\n",
-    "shots=1000\n",
-    "seed=None\n",
-    "rng = np.random.default_rng(seed)\n",
-    "graph_seed = rng.integers(1e9)\n",
-    "n=18\n",
-    "n_stat=1\n",
-    "results = {\"LP\": [], \"Dual-Primal\": [], \"Greedy random edge\": [], \"Greedy vertex degree\": [], \"Quantum greedy bias\": [], \"Quantum greedy seq bias\": []}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 185,
-   "id": "41b2eab9",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'\\nif graph_type == \"erdos\":\\n    p = degree\\n    G = nx.erdos_renyi_graph(n, p)\\nelif graph_type == \"regular\":\\n    G = nx.random_regular_graph(degree, n)\\n'"
-      ]
-     },
-     "execution_count": 185,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'''\n",
-    "if graph_type == \"erdos\":\n",
-    "    p = degree\n",
-    "    G = nx.erdos_renyi_graph(n, p)\n",
-    "elif graph_type == \"regular\":\n",
-    "    G = nx.random_regular_graph(degree, n)\n",
-    "'''"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 186,
-   "id": "541867e8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "\n",
-    "def plot_graph(G):\n",
-    "    \"\"\"Plot a NetworkX graph with labels.\"\"\"\n",
-    "    plt.figure(figsize=(4,4))\n",
-    "    pos = nx.spring_layout(G, seed=42)  # nice-looking layout\n",
-    "\n",
-    "    nx.draw(\n",
-    "        G, pos,\n",
-    "        with_labels=True,\n",
-    "        node_size=800,\n",
-    "        node_color=\"lightblue\",\n",
-    "        font_size=12,\n",
-    "        font_weight=\"bold\",\n",
-    "        edge_color=\"gray\"\n",
-    "    )\n",
-    "\n",
-    "    plt.title(\"Graph G\")\n",
-    "    plt.axis(\"off\")\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 187,
-   "id": "cec59568",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_graph(G)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 188,
-   "id": "3f00e0f2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def node_order_by_cost_degree(G, C):\n",
-    "    \"\"\"\n",
-    "    Order nodes by:\n",
-    "      1) descending cost\n",
-    "      2) descending degree\n",
-    "    \"\"\"\n",
-    "    return sorted(\n",
-    "        G.nodes(),\n",
-    "        #key=lambda i: (i)\n",
-    "        key=lambda i: (G.degree(i), -C[i]),\n",
-    "        #key=lambda i: (-G.degree(i)/C[i])\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "\n",
-    "# ---------------- Graph & mixer ----------------\n",
-    "\n",
-    "def mixer_from_graph(G,c):\n",
-    "    G = nx.convert_node_labels_to_integers(G)\n",
-    "    n = G.number_of_nodes()\n",
-    "    qc = QuantumCircuit(n)\n",
-    "    betas = {i: Parameter(f\"β_{i}\") for i in G.nodes()}\n",
-    "\n",
-    "    for i in range(n):\n",
-    "        qc.x(i)\n",
-    "    # 🔥 ORDER NODES HERE\n",
-    "    ordered_nodes = node_order_by_cost_degree(G,c)\n",
-    "    for tgt in ordered_nodes:\n",
-    "        angle = 2 * betas[tgt]\n",
-    "        ctrls = list(G.neighbors(tgt))\n",
-    "        qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])\n",
-    "\n",
-    "\n",
-    "    return qc, betas, G\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 189,
-   "id": "940b7c79",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def mean_field_cost_degree_order_init(G, C_cost, order, alpha=1, beta=1, gamma=1,delta=0.2, n_iter=30):\n",
-    "    n = len(G)\n",
-    "    rank = {j: k / n for k, j in enumerate(order)}\n",
-    "    p = {j: 0.5 for j in G.nodes()}\n",
-    "    maxcost= max(C_cost)\n",
-    "    for _ in range(n_iter):\n",
-    "        p_new = {}\n",
-    "        for j in G.nodes():\n",
-    "            dj = max(1, G.degree(j))\n",
-    "            neigh_pressure = sum(p[k] for k in G.neighbors(j)) / dj\n",
-    "            field = (\n",
-    "                alpha * C_cost[j]\n",
-    "                - beta * neigh_pressure\n",
-    "                - gamma * rank[j]\n",
-    "            )\n",
-    "            p_new[j] = 1.0 / (1.0 + np.exp(-delta*field))\n",
-    "        p = p_new\n",
-    "\n",
-    "    return {j: np.arcsin(np.sqrt(p[j])) for j in p}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 190,
-   "id": "843094fb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Beta bias 3: {0: np.float64(1.1354449491070366), 1: np.float64(1.5491485034210035), 2: np.float64(1.5287123311535777), 3: np.float64(1.5655697036292406), 4: np.float64(0.5870947218435765), 5: np.float64(0.7489466594912398), 6: np.float64(1.5688671874272333), 7: np.float64(1.2028906606067677), 8: np.float64(1.3821628665523744), 9: np.float64(1.2986482458017807), 10: np.float64(1.4349250632605868), 11: np.float64(1.567720532490262), 12: np.float64(1.5583875391170832), 13: np.float64(1.4669567760885025), 14: np.float64(1.494317568285612), 15: np.float64(1.552009278055701), 16: np.float64(1.5662864530466767), 17: np.float64(1.5304876692964369), 18: np.float64(1.5610255402701783), 19: np.float64(0.7949310813751967)}\n",
-      "Beta bias 4: {0: 1.2566370614359172, 1: 1.2566370614359172, 2: 1.2566370614359172, 3: 1.2566370614359172, 4: 1.2566370614359172, 5: 1.2566370614359172, 6: 1.2566370614359172, 7: 1.2566370614359172, 8: 1.2566370614359172, 9: 1.2566370614359172, 10: 1.2566370614359172, 11: 1.2566370614359172, 12: 1.2566370614359172, 13: 1.2566370614359172, 14: 1.2566370614359172, 15: 1.2566370614359172, 16: 1.2566370614359172, 17: 1.2566370614359172, 18: 1.2566370614359172, 19: 1.2566370614359172}\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "#G = nx.erdos_renyi_graph(n=n, p=degree, seed=int(graph_seed))\n",
-    "\n",
-    "\n",
-    "if case == \"unweighted\":\n",
-    "    c = {i: 1.0 for i in G.nodes()}\n",
-    "else:\n",
-    "    c = {i: random.uniform(0.40, 0.70) for i in G.nodes()}\n",
-    "\n",
-    "C_opt = mvc_exact_cplex(G, c)\n",
-    "opt_cost = sum(c[i] for i in C_opt)\n",
-    "\n",
-    "C_lp = mvc_lp_relaxation(G, c)\n",
-    "results[\"LP\"].append(sum(c[i] for i in C_lp) / opt_cost)\n",
-    "\n",
-    "C_pd = mvc_primal_dual_weighted(G,  c)\n",
-    "results[\"Dual-Primal\"].append(sum(c[i] for i in C_pd) / opt_cost)\n",
-    "\n",
-    "C_gd = greedy_degree_vertex_cover(G,c)\n",
-    "results[\"Greedy vertex degree\"].append(sum(c[i] for i in C_gd) / opt_cost)\n",
-    "qc, betas, Gn = mixer_from_graph(G,c)\n",
-    "C_cost = {i: c[i] for i in Gn.nodes()}                                          \n",
-    "for s in range(n_stat):\n",
-    "    run_seed = rng.integers(1e9)\n",
-    "    random.seed(int(run_seed))\n",
-    "    np.random.seed(int(run_seed))\n",
-    "\n",
-    "    C_ge = greedy_edge_vertex_cover(G,c)\n",
-    "    results[\"Greedy random edge\"].append(sum(c[i] for i in C_ge) / opt_cost)\n",
-    "\n",
-    "    \n",
-    "\n",
-    "beta_bias1={i: 0.5*np.pi/2 for i in C_cost}\n",
-    "beta_bias4={i: 0.8*np.pi/2 for i in C_cost}\n",
-    "\n",
-    "order = node_order_by_cost_degree(G, C_cost)\n",
-    "beta_bias3 = mean_field_cost_degree_order_init(G, order, C_cost, alpha=1,beta=1.0, gamma=1, delta=0.7, n_iter=50)\n",
-    "print(\"Beta bias 3:\", beta_bias3)\n",
-    "print(\"Beta bias 4:\", beta_bias4)\n",
-    "\n",
-    "\n",
-    "sol_weighted,en1 = greedy_optimize_seq(qc, betas, C_cost, beta_bias3, shots=shots)\n",
-    "E_weighted1 = expectation_value_cost_shifted(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "sol_weighted,en2 = greedy_optimize_seq(qc, betas, C_cost, beta_bias4, shots=shots)\n",
-    "E_weighted2 = expectation_value_cost_shifted(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "sol_weighted,en3 = greedy_optimize_seq(qc, betas, C_cost, beta_bias1, shots=shots)\n",
-    "E_weighted3 = expectation_value_cost_shifted(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "sol_weighted,en4 = greedy_optimize(qc, betas, C_cost, beta_bias1, shots=shots)\n",
-    "E_weighted4 = expectation_value_cost_shifted(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "sol_weighted,en5 = greedy_optimize(qc, betas, C_cost, beta_bias3, shots=shots)\n",
-    "E_weighted5 = expectation_value_cost_shifted(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "results[\"Quantum greedy bias\"].append(E_weighted3 / opt_cost)\n",
-    "sol_weighted,en6 = greedy_optimize(qc, betas, C_cost, beta_bias4, shots=shots)\n",
-    "E_weighted6 = expectation_value_cost_shifted(qc, betas, C_cost, sol_weighted, shots=shots)\n",
-    "results[\"Quantum greedy seq bias\"].append(E_weighted4 / opt_cost)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 191,
-   "id": "9415309e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Convert to NumPy array\n",
-    "data1 = np.array(en1)\n",
-    "data2 = np.array(en2)\n",
-    "data3 = np.array(en3)\n",
-    "data4 = np.array(en4)\n",
-    "data5 = np.array(en5)\n",
-    "data6 = np.array(en6)\n",
-    "# Rearrange each row: [max, min]\n",
-    "rearranged_data1 = np.column_stack((\n",
-    "    np.max(data1, axis=1),\n",
-    "    np.min(data1, axis=1)\n",
-    "))\n",
-    "rearranged_data2 = np.column_stack((\n",
-    "    np.max(data2, axis=1),\n",
-    "    np.min(data2, axis=1)\n",
-    "))\n",
-    "rearranged_data3 = np.column_stack((\n",
-    "    np.max(data3, axis=1),\n",
-    "    np.min(data3, axis=1)\n",
-    "))\n",
-    "rearranged_data4 = np.column_stack((\n",
-    "    np.max(data4, axis=1),\n",
-    "    np.min(data4, axis=1)\n",
-    "))\n",
-    "rearranged_data5 = np.column_stack((\n",
-    "    np.max(data5, axis=1),\n",
-    "    np.min(data5, axis=1)\n",
-    "))\n",
-    "rearranged_data6 = np.column_stack((\n",
-    "    np.max(data6, axis=1),\n",
-    "    np.min(data6, axis=1)\n",
-    "))\n",
-    "# X axis (index)\n",
-    "x = np.arange(len(data1))\n",
-    "\n",
-    "\n",
-    "# Plot\n",
-    "plt.figure()\n",
-    "#plt.plot(x, rearranged_data1[:, 0]/opt_cost, label=\"big 1\")\n",
-    "plt.plot(x, rearranged_data1[:, 1]/opt_cost, label=\"small 1\")\n",
-    "#plt.plot(x, rearranged_data2[:, 0]/opt_cost, label=\"big 2\")\n",
-    "plt.plot(x, rearranged_data2[:, 1]/opt_cost, label=\"small 2\")\n",
-    "#plt.plot(x, rearranged_data3[:, 0]/opt_cost, label=\"big 3\")\n",
-    "plt.plot(x, rearranged_data3[:, 1]/opt_cost, label=\"small 3\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, rearranged_data4[:, 1]/opt_cost, label=\"small 4\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, rearranged_data5[:, 1]/opt_cost, label=\"small 5\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, rearranged_data6[:, 1]/opt_cost, label=\"small 6\")\n",
-    "plt.axhline(y=results[\"Greedy vertex degree\"][0], linestyle='--', linewidth=2)\n",
-    "plt.xlabel(\"Index\")\n",
-    "plt.ylabel(\"Value\")\n",
-    "plt.title(\"First and Second Column\")\n",
-    "plt.legend()\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 192,
-   "id": "174cbe09",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Plot\n",
-    "plt.figure()\n",
-    "#plt.plot(x, rearranged_data1[:, 0]/opt_cost, label=\"big 1\")\n",
-    "plt.plot(x, -rearranged_data1[:, 1]/opt_cost+rearranged_data1[:, 0]/opt_cost, label=\"small 1\")\n",
-    "#plt.plot(x, rearranged_data2[:, 0]/opt_cost, label=\"big 2\")\n",
-    "plt.plot(x, -rearranged_data2[:, 1]/opt_cost+rearranged_data2[:, 0]/opt_cost, label=\"small 2\")\n",
-    "#plt.plot(x, rearranged_data3[:, 0]/opt_cost, label=\"big 3\")\n",
-    "plt.plot(x, -rearranged_data3[:, 1]/opt_cost+rearranged_data3[:, 0]/opt_cost, label=\"small 3\")\n",
-    "#plt.plot(x, rearranged_data4[:, 0]/opt_cost, label=\"big 4\")\n",
-    "plt.plot(x, -rearranged_data4[:, 1]/opt_cost+rearranged_data4[:, 0]/opt_cost, label=\"small 4\")\n",
-    "#plt.axhline(y=results[\"Greedy vertex degree\"][0], linestyle='--', linewidth=2)\n",
-    "plt.xlabel(\"Index\")\n",
-    "plt.ylabel(\"Value\")\n",
-    "plt.title(\"First and Second Column\")\n",
-    "plt.legend()\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 193,
-   "id": "b6397471",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'LP': [1.5384615384615385],\n",
-       " 'Dual-Primal': [1.3846153846153846],\n",
-       " 'Greedy random edge': [1.3846153846153846],\n",
-       " 'Greedy vertex degree': [1.2307692307692308],\n",
-       " 'Quantum greedy bias': [np.float64(1.0)],\n",
-       " 'Quantum greedy seq bias': [np.float64(1.0)]}"
-      ]
-     },
-     "execution_count": 193,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3a35d529",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d2eca4a3",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv (3.11.5)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/MVC/QGMVC_parallel.py b/MVC/QGMVC_parallel.py
deleted file mode 100644
index c7c5ba4..0000000
--- a/MVC/QGMVC_parallel.py
+++ /dev/null
@@ -1,284 +0,0 @@
-from __future__ import annotations
-
-# =======================
-# Environment safeguards
-# =======================
-import os
-os.environ["OMP_NUM_THREADS"] = "1"
-os.environ["MKL_NUM_THREADS"] = "1"
-
-# =======================
-# Standard imports
-# =======================
-import sys
-import random
-import numpy as np
-import networkx as nx
-from multiprocessing import Pool, cpu_count
-from datetime import datetime
-
-# =======================
-# Optional rustworkx
-# =======================
-try:
-    import rustworkx as rx
-    RxGraph = rx.PyGraph
-except ImportError:
-    rx = None
-    RxGraph = tuple()
-
-# =======================
-# CPLEX + project imports
-# =======================
-from docplex.mp.model import Model
-
-from quantum_greedy_util import (
-    mixer_from_graph,
-    expectation_value_cost_shifted,
-    greedy_optimize,
-    greedy_optimize_seq
-)
-
-from classical_runtime_guarantee_util import (
-    mvc_exact_cplex,
-    mvc_lp_relaxation,
-    greedy_degree_vertex_cover,
-    mvc_primal_dual_weighted,
-)
-
-# ============================================================
-# STEP A — one independent (n, graph) experiment
-# ============================================================
-def run_single_graph(args):
-    (n, graph_seed, case, graph_type, degree, shots, n_stat) = args
-
-    rng = np.random.default_rng(graph_seed)
-
-    # ----- graph generation -----
-    if graph_type == "regular":
-        G = nx.random_regular_graph(
-            degree if n % 2 == 0 else degree + 1,
-            n,
-            seed=int(graph_seed),
-        )
-    elif graph_type == "erdos":
-        while True:
-            G = nx.erdos_renyi_graph(n=n, p=degree, seed=int(graph_seed))
-            if nx.is_connected(G):
-                break
-    else:
-        raise ValueError("Unknown graph type")
-
-    # ----- weights -----
-    if case == "unweighted":
-        c = {i: 1.0 for i in G.nodes()}
-    else:
-        c = {i: random.uniform(0.40, 0.70) for i in G.nodes()}
-
-    out = {}
-
-    # ----- exact MVC -----
-    C_opt = mvc_exact_cplex(G, c)
-    opt_cost = sum(c[i] for i in C_opt)
-
-    out["optimal"] = opt_cost
-    out["worst_case"] = sum(c.values()) / opt_cost
-    out["LP"] = sum(c[i] for i in mvc_lp_relaxation(G, c)) / opt_cost
-    out["Dual-Primal"] = sum(c[i] for i in mvc_primal_dual_weighted(G, c)) / opt_cost
-    out["Greedy vertex degree"] = (
-        sum(c[i] for i in greedy_degree_vertex_cover(G, c)) / opt_cost
-    )
-
-    # ----- quantum greedy -----
-    qc, betas, Gn = mixer_from_graph(G, c)
-    C_cost = {i: c[i] for i in Gn.nodes()}
-
-    beta_bias={i: np.pi/4+(i/len(C_cost))*0.1 for i in C_cost} #depth dependent 
-    beta_unbias = {i: 0.5 * np.pi / 2 for i in C_cost}
-
-    E_bias, E_unbias = [], []
-
-    for _ in range(n_stat):
-        sol = greedy_optimize(qc, betas, C_cost, beta_bias, shots=shots)
-        E_bias.append(
-            expectation_value_cost_shifted(qc, betas, C_cost, sol, shots=shots)
-        )
-
-        sol = greedy_optimize(qc, betas, C_cost, beta_unbias, shots=shots)
-        E_unbias.append(
-            expectation_value_cost_shifted(qc, betas, C_cost, sol, shots=shots)
-        )
-
-    out["Quantum greedy bias"] = np.mean(E_bias) / opt_cost
-    out["Quantum greedy unbias"] = np.mean(E_unbias) / opt_cost
-
-    sol_bias = greedy_optimize_seq(qc, betas, C_cost, beta_bias, shots=shots)
-    E = expectation_value_cost_shifted(qc, betas, C_cost, sol_bias, shots=shots)
-    out["Quantum greedy seq bias"] = E / opt_cost
-
-    sol_unbias = greedy_optimize_seq(qc, betas, C_cost, beta_unbias, shots=shots)
-    E = expectation_value_cost_shifted(qc, betas, C_cost, sol_unbias, shots=shots)
-    out["Quantum greedy seq unbias"] = E / opt_cost
-
-    return n, out
-
-
-# ============================================================
-# STEP B — parallel driver over (n, graph_seed)
-# ============================================================
-def run_experiment_stats_weighted(
-    n_values,
-    N_graphs=10,
-    n_stat=1,
-    shots=None,
-    case="weighted",
-    graph_type="regular",
-    degree=3,
-    seed=None,
-):
-    methods = [
-        "optimal",
-        "worst_case",
-        "LP",
-        "Dual-Primal",
-        "Greedy vertex degree",
-        "Quantum greedy bias",
-        "Quantum greedy unbias",
-        "Quantum greedy seq bias",
-        "Quantum greedy seq unbias",
-    ]
-
-    results = {n: {m: [] for m in methods} for n in n_values}
-
-    rng = np.random.default_rng(seed)
-
-    # ----- build flat task list -----
-    tasks = []
-    for n in n_values:
-        for _ in range(N_graphs):
-            graph_seed = rng.integers(1e9)
-            tasks.append(
-                (n, graph_seed, case, graph_type, degree, shots, n_stat)
-            )
-
-    nproc = int(os.environ.get("SLURM_CPUS_PER_TASK", cpu_count()))
-    print(f"Using {nproc} worker processes")
-
-    with Pool(processes=nproc) as pool:
-        for n, out in pool.imap_unordered(run_single_graph, tasks):
-            for k, v in out.items():
-                results[n][k].append(v)
-
-    return results
-
-
-# ============================================================
-# Utilities: save + summarize
-# ============================================================
-def save_results(
-    results,
-    n_values,
-    N_graphs,
-    n_stat,
-    case,
-    graph_type,
-    degree,
-    shots,
-    seed,
-    prefix="mvc_results",
-):
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-
-    fname = (
-        f"{prefix}_{case}_{graph_type}_deg{degree}_"
-        f"nG{N_graphs}_nStat{n_stat}_shots{shots}_seed{seed}_{timestamp}.npz"
-    )
-
-    out_dir = os.path.dirname(os.path.abspath(__file__))
-    out_path = os.path.join(out_dir, fname)
-
-    np.savez_compressed(
-        out_path,
-        results=results,
-        n_values=np.array(n_values),
-        N_graphs=N_graphs,
-        n_stat=n_stat,
-        case=case,
-        graph_type=graph_type,
-        degree=degree,
-        shots=shots,
-        seed=seed,
-    )
-
-    print(f"Results saved to:\n{out_path}")
-
-
-# ============================================================
-# Main
-# ============================================================
-def main(n_values, N_graphs, n_stat, case, graph_type, degree, shots, seed):
-
-    results = run_experiment_stats_weighted(
-        n_values=n_values,
-        N_graphs=N_graphs,
-        n_stat=n_stat,
-        case=case,
-        graph_type=graph_type,
-        degree=degree,
-        shots=shots,
-        seed=seed,
-    )
-
-    save_results(
-        results,
-        n_values,
-        N_graphs,
-        n_stat,
-        case,
-        graph_type,
-        degree,
-        shots,
-        seed,
-    )
-
-
-if __name__ == "__main__":
-
-    # Usage:
-    # python QGMVC.py N_graphs n_stat case graph_type degree shots
-
-    N_graphs = int(sys.argv[1])
-    n_stat = int(sys.argv[2])
-    case = sys.argv[3]
-    graph_type = sys.argv[4]
-    degree = float(sys.argv[5])
-    shots = int(sys.argv[6])
-
-    if graph_type == "regular":
-        degree = int(degree)
-    elif graph_type == "erdos":
-        if not (0.0 <= degree <= 1.0):
-            raise ValueError("Erdos p must be in [0,1]")
-    else:
-        raise ValueError("graph_type must be 'regular' or 'erdos'")
-
-    n_values = [6, 8, 10, 12, 14, 16, 18, 20]
-    seed = 0
-
-    print("N_graphs =", N_graphs)
-    print("n_stat =", n_stat)
-    print("case =", case)
-    print("graph_type =", graph_type)
-    print("degree =", degree)
-    print("shots =", shots)
-
-    main(
-        n_values=n_values,
-        N_graphs=N_graphs,
-        n_stat=n_stat,
-        case=case,
-        graph_type=graph_type,
-        degree=degree,
-        shots=shots,
-        seed=seed,
-    )
diff --git a/MVC/classical_heuristics_util.py b/MVC/classical_heuristics_util.py
deleted file mode 100644
index 5f74554..0000000
--- a/MVC/classical_heuristics_util.py
+++ /dev/null
@@ -1,281 +0,0 @@
-from __future__ import annotations
-import random
-import math
-
-
-# Optional rustworkx support
-try:
-    import rustworkx as rx
-    RxGraph = rx.PyGraph
-except ImportError:
-    rx = None
-    RxGraph = tuple()
-
-
-def is_vertex_cover(G, C):
-    return all(u in C or v in C for u, v in G.edges())
-
-def local_search_vertex_cover(G, C_init, c, max_iters=1000):
-    C = set(C_init)
-
-    def cost(C):
-        return sum(c[v] for v in C)
-
-    for _ in range(max_iters):
-        improved = False
-        for v in list(C):
-            C_new = C - {v}
-            if is_vertex_cover(G, C_new) and cost(C_new) < cost(C):
-                C = C_new
-                improved = True
-                break
-        if not improved:
-            break
-    return C
-
-
-def ga_vertex_cover(G, c, pop_size=50, generations=100, mutation_rate=0.05, alpha=100):
-    n = G.number_of_nodes()
-
-    def fitness(chromosome):
-        cover = {i for i, x in enumerate(chromosome) if x == 1}
-        uncovered_edges = sum(
-            1 for u, v in G.edges() if u not in cover and v not in cover
-        )
-        return sum(c[i] for i in cover) + alpha * uncovered_edges
-
-    def generate_individual():
-        chromosome = [0] * n
-        for u, v in G.edges():
-            if chromosome[u] == 0 and chromosome[v] == 0:
-                # pick cheaper vertex with probability 0.7, otherwise random
-                if random.random() < 0.7:
-                    chosen = u if c[u] <= c[v] else v
-                else:
-                    chosen = random.choice([u, v])
-                chromosome[chosen] = 1
-        # add some random nodes to increase diversity
-        for i in range(n):
-            if chromosome[i] == 0 and random.random() < 0.1:
-                chromosome[i] = 1
-        return chromosome
-
-    def crossover(p1, p2):
-        point = random.randint(1, n-1)
-        return p1[:point] + p2[point:], p2[:point] + p1[point:]
-
-    def mutate(chrom):
-        for i in range(n):
-            if random.random() < mutation_rate:
-                chrom[i] = 1 - chrom[i]
-        return chrom
-
-    # Initialize population
-    population = [generate_individual() for _ in range(pop_size)]
-
-    for _ in range(generations):
-        population.sort(key=fitness)
-        new_pop = population[:2]  # elitism: keep best 2
-        while len(new_pop) < pop_size:
-            p1, p2 = random.sample(population[:20], 2)  # tournament from top 20
-            c1, c2 = crossover(p1, p2)
-            new_pop += [mutate(c1), mutate(c2)]
-        population = new_pop[:pop_size]
-
-    best = min(population, key=fitness)
-    return {i for i, x in enumerate(best) if x == 1}
-
-def bp_vertex_cover_enforced(
-    G,
-    c,
-    beta=1.0,
-    max_iter=500,
-    tol=1e-6,
-    damping=0.5,
-    seed=None
-):
-    """
-    Belief Propagation for weighted Vertex Cover with HARD constraints.
-    
-    P(x) ∝ exp(-beta * sum_i c_i x_i) * ∏_{(i,j)} 1[x_i + x_j ≥ 1]
-    """
-
-    if seed is not None:
-        random.seed(seed)
-
-    # Messages: m[(i,j)] = (p0, p1)
-    messages = {}
-    for i, j in G.edges():
-        messages[(i, j)] = (0.5, 0.5)
-        messages[(j, i)] = (0.5, 0.5)
-
-    for _ in range(max_iter):
-        delta = 0.0
-        new_messages = {}
-
-        for (i, j), (p0_old, p1_old) in messages.items():
-
-            # ----- x_i = 1 (vertex i IN cover) -----
-            prod1 = 1.0
-            for k in G.neighbors(i):
-                if k == j:
-                    continue
-                p0, p1 = messages[(k, i)]
-                prod1 *= (p0 + p1)
-
-            m1 = math.exp(-beta * c[i]) * prod1
-
-            # ----- x_i = 0 (vertex i OUT of cover) -----
-            # All neighbors must be in
-            prod0 = 1.0
-            for k in G.neighbors(i):
-                if k == j:
-                    continue
-                _, p1 = messages[(k, i)]
-                prod0 *= p1
-
-            m0 = prod0
-
-            # ----- Normalize -----
-            Z = m0 + m1
-            if Z == 0:
-                m0_new, m1_new = 0.0, 1.0
-            else:
-                m0_new = m0 / Z
-                m1_new = m1 / Z
-
-            # ----- Damping -----
-            p0 = damping * p0_old + (1 - damping) * m0_new
-            p1 = damping * p1_old + (1 - damping) * m1_new
-
-            new_messages[(i, j)] = (p0, p1)
-            delta = max(delta, abs(p0 - p0_old), abs(p1 - p1_old))
-
-        messages = new_messages
-        if delta < tol:
-            break
-
-    # ----- Compute marginals -----
-    marginals = {}
-    for i in G.nodes():
-        prod1 = math.exp(-beta * c[i])
-        prod0 = 1.0
-
-        for j in G.neighbors(i):
-            p0, p1 = messages[(j, i)]
-            prod1 *= (p0 + p1)
-            prod0 *= p1
-
-        Z = prod0 + prod1
-        marginals[i] = prod1 / Z if Z > 0 else 1.0
-
-    return marginals
-
-def bp_decode_vertex_cover(G, marginals):
-    """
-    Deterministic decoding guaranteeing feasibility.
-    """
-    C = set()
-    uncovered_edges = set(G.edges())
-
-    # Sort by decreasing belief of being in cover
-    order = sorted(marginals, key=lambda i: -marginals[i])
-
-    for i in order:
-        incident = [(u, v) for (u, v) in uncovered_edges if u == i or v == i]
-        if incident:
-            C.add(i)
-            for e in incident:
-                uncovered_edges.remove(e)
-        if not uncovered_edges:
-            break
-
-    return C
-
-class SimulatedAnnealingWeighted:
-    def __init__(self, G, c, T=100, alpha=0.99, max_iter=10000, perturbation_type='bitflip'):
-        """
-        G: networkx graph
-        c: dict mapping node -> weight
-        """
-        self.G = G
-        self.c = c
-        self.n = G.number_of_nodes()
-        self.T = T
-        self.alpha = alpha
-        self.max_iter = max_iter
-        self.perturbation_type = perturbation_type
-        self.vertex_cover = self.generate_vertex_cover()
-
-    # ---------- FITNESS ----------
-    def fitness(self, individual):
-        if not self.is_feasible(individual):
-            return float('inf')  # infeasible covers have very high cost
-        return sum(self.c[i] for i, bit in enumerate(individual) if bit == 1)
-
-    def is_feasible(self, individual):
-        cover_nodes = {i for i, bit in enumerate(individual) if bit == 1}
-        for u, v in self.G.edges():
-            if u not in cover_nodes and v not in cover_nodes:
-                return False
-        return True
-
-    # ---------- INITIAL COVER ----------
-    def generate_vertex_cover(self):
-        # start with empty bitstring
-        individual = [0] * self.n
-        # greedy heuristic: for each uncovered edge, pick the cheaper vertex
-        uncovered_edges = set(self.G.edges())
-        while uncovered_edges:
-            u, v = random.choice(list(uncovered_edges))
-            chosen = u if self.c[u] <= self.c[v] else v
-            individual[chosen] = 1
-            # remove edges covered by chosen node
-            uncovered_edges = {e for e in uncovered_edges if chosen not in e}
-        return individual
-
-    # ---------- PERTURBATION ----------
-    def perturb(self, vertex_cover, type='bitflip'):
-        new_cover = vertex_cover.copy()
-        if type == 'bitflip':
-            i = random.randint(0, self.n - 1)
-            new_cover[i] = 1 - new_cover[i]
-            if self.is_feasible(new_cover):
-                return new_cover
-            else:
-                return vertex_cover
-        elif type == 'swap':
-            i, j = random.sample(range(self.n), 2)
-            new_cover[i], new_cover[j] = new_cover[j], new_cover[i]
-            if self.is_feasible(new_cover):
-                return new_cover
-            else:
-                return vertex_cover
-        else:
-            raise ValueError("Invalid perturbation type")
-
-    # ---------- SIMULATED ANNEALING ----------
-    def run(self):
-        current = self.vertex_cover
-        current_cost = self.fitness(current)
-        best = current
-        best_cost = current_cost
-
-        while self.T > 1e-3:
-            for _ in range(self.max_iter):
-                new_cover = self.perturb(current, self.perturbation_type)
-                new_cost = self.fitness(new_cover)
-                if new_cost < current_cost:
-                    current = new_cover
-                    current_cost = new_cost
-                else:
-                    p = math.exp((current_cost - new_cost) / self.T)
-                    if random.random() < p:
-                        current = new_cover
-                        current_cost = new_cost
-                if current_cost < best_cost:
-                    best = current
-                    best_cost = current_cost
-            self.T *= self.alpha
-
-        return {i for i, bit in enumerate(best) if bit == 1}
diff --git a/MVC/classical_runtime_guarantee_util.py b/MVC/classical_runtime_guarantee_util.py
deleted file mode 100644
index 37a0a8d..0000000
--- a/MVC/classical_runtime_guarantee_util.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from __future__ import annotations
-import random
-# Optional rustworkx support
-try:
-    import rustworkx as rx
-    RxGraph = rx.PyGraph
-except ImportError:
-    rx = None
-    RxGraph = tuple()
-# CPLEX import
-from docplex.mp.model import Model
-
-
-def greedy_degree_vertex_cover(G, c):
-    Gc = G.copy()
-    cover = set()
-
-    while Gc.number_of_edges() > 0:
-        v = max(
-            Gc.nodes(),
-            #key=lambda x: (c[x],G.degree(x))
-            key=lambda x: Gc.degree(x) / c[x]
-        )
-        cover.add(v)
-        Gc.remove_node(v)
-
-    return cover
-def greedy_edge_vertex_cover(G, c):
-    Gc = G.copy()
-    cover = set()
-
-    while Gc.number_of_edges() > 0:
-        u, v = random.choice(list(Gc.edges()))
-        chosen = u if c[u] <= c[v] else v
-        cover.add(chosen)
-        Gc.remove_node(chosen)
-
-    return cover
-
-
-
-def mvc_exact_cplex(G, c):
-    mdl = Model("wmvc_exact")
-    x = {i: mdl.binary_var(name=f"x_{i}") for i in G.nodes()}
-
-    for u, v in G.edges():
-        mdl.add_constraint(x[u] + x[v] >= 1)
-
-    mdl.minimize(mdl.sum(c[i] * x[i] for i in G.nodes()))
-    mdl.solve(log_output=False)
-
-    return {i for i in x if x[i].solution_value > 0.5}
-
-
-
-def mvc_lp_relaxation(G, c):
-    mdl = Model("wmvc_lp")
-    x = {i: mdl.continuous_var(lb=0, ub=1, name=f"x_{i}") for i in G.nodes()}
-
-    for u, v in G.edges():
-        mdl.add_constraint(x[u] + x[v] >= 1)
-
-    mdl.minimize(mdl.sum(c[i] * x[i] for i in G.nodes()))
-    mdl.solve(log_output=False)
-
-    return {i for i in x if x[i].solution_value >= 0.5}
-
-
-def mvc_primal_dual_weighted(G, c):
-    """
-    Weighted Minimum Vertex Cover using primal-dual / local-ratio.
-    Returns a set of vertices.
-    """
-    remaining_edges = set(G.edges())
-    cover = set()
-    vertex_weights = c.copy()
-
-    while remaining_edges:
-        # Pick an edge with minimal combined weight
-        u, v = min(remaining_edges, key=lambda e: vertex_weights[e[0]] + vertex_weights[e[1]])
-        # Add the vertex with smaller weight
-        if vertex_weights[u] <= vertex_weights[v]:
-            cover.add(u)
-            # Remove all edges incident to u
-            remaining_edges = {e for e in remaining_edges if u not in e}
-        else:
-            cover.add(v)
-            remaining_edges = {e for e in remaining_edges if v not in e}
-    
-    return cover
\ No newline at end of file
diff --git a/MVC/quantum_greedy_util.py b/MVC/quantum_greedy_util.py
deleted file mode 100644
index ca3b4c8..0000000
--- a/MVC/quantum_greedy_util.py
+++ /dev/null
@@ -1,486 +0,0 @@
-from __future__ import annotations
-import random
-import math
-import networkx as nx
-import numpy as np
-
-# Optional rustworkx support
-try:
-    import rustworkx as rx
-    RxGraph = rx.PyGraph
-except ImportError:
-    rx = None
-    RxGraph = tuple()
-
-# Qiskit imports
-from qiskit import QuantumCircuit
-from qiskit.circuit import Parameter
-from qiskit.circuit.library import RXGate,XGate
-from qiskit.quantum_info import Statevector, SparsePauliOp
-from qiskit_aer import Aer
-from qiskit import transpile
-
-from collections import defaultdict
-
-
-def node_order_by_cost_degree(G, C):
-    """
-    Order nodes by:
-      1) descending cost
-      2) descending degree
-    """
-    return sorted(
-        G.nodes(),
-        #key=lambda i: (i)
-        key=lambda i: (-C[i],G. degree(i))
-        #key=lambda i: (G.degree(i),-C[i])
-        #key=lambda i: (G.degree(i)/C[i])
-    )
-
-
-
-# ---------------- Graph & mixer ----------------
-
-def mixer_from_graph(G, c, node_order=None):
-    G = nx.convert_node_labels_to_integers(G)
-    n = G.number_of_nodes()
-
-    qc = QuantumCircuit(n)
-    betas = {i: Parameter(f"β_{i}") for i in G.nodes()}
-
-    for i in range(n):
-        qc.x(i)
-
-    if node_order is None:
-        node_order = node_order_by_cost_degree(G, c)
-
-    for tgt in node_order:
-        angle = 2 * betas[tgt]
-        ctrls = list(G.neighbors(tgt))
-        if ctrls:
-            qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])
-        else:
-            qc.rx(angle, tgt)
-
-    return qc, betas, G
-
-# ---------------- Expectation value ----------------
-
-def expectation_value_cost_shifted(qc, betas, C, beta_values, shots=None):
-    bind_dict = {betas[i]: beta_values[i] for i in betas}
-    qc_bound = qc.assign_parameters(bind_dict)
-
-    n = qc.num_qubits
-    paulis = []
-    coeffs = []
-
-    for i, c_i in C.items():
-        p = ["I"] * n
-        p[i] = "Z"
-        paulis.append("".join(p))
-        coeffs.append(-0.5 * c_i)
-
-    HZ = SparsePauliOp(paulis, coeffs)
-    shift = 0.5 * sum(C.values())
-
-    if shots is None:
-        psi = Statevector.from_instruction(qc_bound)
-        return shift + psi.expectation_value(HZ).real
-
-    # ----- shot-based -----
-    qc_meas = qc_bound.copy()
-    qc_meas.measure_all()
-
-    backend = Aer.get_backend("aer_simulator")
-    qc_meas = transpile(qc_meas, backend)
-    counts = backend.run(qc_meas, shots=shots).result().get_counts()
-
-    exp_val = 0.0
-    for bitstring, count in counts.items():
-        prob = count / shots
-        z_vals = np.array([1 if b == "0" else -1 for b in bitstring[::-1]])
-
-        hz_value = 0.0
-        for i, c_i in C.items():
-            hz_value += -0.5 * c_i * z_vals[i]
-
-        exp_val += prob * hz_value
-
-    return shift + exp_val
-def expectation_value_cost_shifted_with_bitstring(
-    qc, betas, C, beta_values, shots=None
-):
-    bind_dict = {betas[i]: beta_values[i] for i in betas}
-    qc_bound = qc.assign_parameters(bind_dict)
-
-    n = qc.num_qubits
-    paulis = []
-    coeffs = []
-
-    for i, c_i in C.items():
-        p = ["I"] * n
-        p[n-i-1] = "Z"
-        paulis.append("".join(p))
-        coeffs.append(-0.5 * c_i)
-
-    HZ = SparsePauliOp(paulis, coeffs)
-    shift = 0.5 * sum(C.values())
-
-    # ----- statevector -----
-    if shots is None:
-        psi = Statevector.from_instruction(qc_bound)
-        exp_val = shift + psi.expectation_value(HZ).real
-
-        probs = psi.probabilities_dict()
-        most_probable_bitstring = max(probs, key=probs.get)
-
-        return exp_val, most_probable_bitstring
-
-    # ----- shot-based -----
-    qc_meas = qc_bound.copy()
-    qc_meas.measure_all()
-
-    backend = Aer.get_backend("aer_simulator")
-    qc_meas = transpile(qc_meas, backend)
-    counts = backend.run(qc_meas, shots=shots).result().get_counts()
-
-    exp_val = 0.0
-    for bitstring, count in counts.items():
-        prob = count / shots
-        z_vals = np.array([1 if b == "0" else -1 for b in bitstring[::-1]])
-
-        hz_value = 0.0
-        for i, c_i in C.items():
-            hz_value += -0.5 * c_i * z_vals[i]
-
-        exp_val += prob * hz_value
-
-    most_probable_bitstring = max(counts, key=counts.get)
-
-    return shift + exp_val, most_probable_bitstring
-
-
-
-# ---------------- Greedy optimizers ----------------
-
-def greedy_optimize(qc, betas, C, beta_values,shots=None):
-    values = beta_values.copy()
-    free = list(betas.keys())
-
-    while free:
-        i = random.choice(free)
-        best_val = values[i]
-        best_E = expectation_value_cost_shifted(qc, betas, C, values,shots)
-
-        for candidate in (0.0, math.pi/2):
-            trial = values.copy()
-            trial[i] = candidate
-            E = expectation_value_cost_shifted(qc, betas, C, trial,shots)
-            if E < best_E:
-                best_E = E
-                best_val = candidate
-                
-
-        values[i] = best_val
-        free.remove(i)
-
-    return values
-
-
-
-
-def greedy_optimize_seq(qc, betas, C, beta_values,shots= None):
-    values = beta_values.copy()
-
-    # assume betas is an ordered mapping or keys are index-like
-    indices = list(betas.keys())
-
-    # iterate from last to first
-    for i in reversed(indices):
-    #for i in indices :
-        best_val = values[i]
-        best_E = expectation_value_cost_shifted(qc, betas, C, values,shots)
-
-        for candidate in (0.0, math.pi / 2):
-            trial = values.copy()
-            trial[i] = candidate
-            E = expectation_value_cost_shifted(qc, betas, C, trial,shots)
-
-            if E < best_E:
-                best_E = E
-                best_val = candidate
-
-        values[i] = best_val
-
-    return values
-
-def greedy_optimize_seq_rev(qc, betas, C, beta_values,shots= None):
-    values = beta_values.copy()
-
-    # assume betas is an ordered mapping or keys are index-like
-    indices = list(betas.keys())
-
-    # iterate from last to first
-    #for i in reversed(indices):
-    for i in indices :
-        best_val = values[i]
-        best_E = expectation_value_cost_shifted(qc, betas, C, values,shots)
-
-        for candidate in (0.0, math.pi / 2):
-            trial = values.copy()
-            trial[i] = candidate
-            E = expectation_value_cost_shifted(qc, betas, C, trial,shots)
-
-            if E < best_E:
-                best_E = E
-                best_val = candidate
-
-        values[i] = best_val
-
-    return values
-
-# ---------------- Mean field initialization ----------------
-
-def mean_field_cost_degree_order_init(G, C_cost, order, alpha=1, beta=1, gamma=1,delta=0.2, n_iter=30):
-    n = len(G)
-    rank = {j: k / n for k, j in enumerate(order)}
-    p = {j: np.random.uniform(0.4,0.6) for j in G.nodes()}
-    maxcost= max(C_cost)
-    for _ in range(n_iter):
-        p_new = {}
-        for j in G.nodes():
-            dj = max(1, G.degree(j))
-            neigh_pressure = sum(p[k] for k in G.neighbors(j)) / dj
-            field = (
-                alpha * C_cost[j]
-                - beta * neigh_pressure
-                - gamma * rank[j]
-            )
-            p_new[j] = 1.0 / (1.0 + np.exp(-delta*field))
-        p = p_new
-
-    return {j: np.arcsin(np.sqrt(p[j])) for j in p}
-
-
-
-'''
-def greedy_distance1_coloring(G):
-    """
-    Standard greedy vertex coloring (distance-1).
-    Returns:
-        c : dict {node: color}
-    """
-    c = {}
-    nodes = list(G.nodes())
-
-    for v in nodes:
-        forbidden = set()
-
-        # distance 1 only
-        for u in G.neighbors(v):
-            if u in c:
-                forbidden.add(c[u])
-
-        # choose smallest available color
-        color = 0
-        while color in forbidden:
-            color += 1
-
-        c[v] = color
-
-    return c
-
-def greedy_distance2_coloring(G):
-    """
-    Greedy distance-2 coloring.
-    Returns:
-        c : dict {node: color}
-    """
-    c = {}
-    nodes = list(G.nodes())
-
-    for v in nodes:
-        forbidden = set()
-
-        # distance 1
-        for u in G.neighbors(v):
-            if u in c:
-                forbidden.add(c[u])
-
-        # distance 2
-        for u in G.neighbors(v):
-            for w in G.neighbors(u):
-                if w in c:
-                    forbidden.add(c[w])
-
-        # assign smallest available color
-        color = 0
-        while color in forbidden:
-            color += 1
-
-        c[v] = color
-
-    return c
-def order_nodes_by_color_size(G, c):
-    """
-    Orders nodes so that vertices belonging to the
-    largest color class come first.
-    """
-    color_classes = defaultdict(list)
-    for v, col in c.items():
-        color_classes[col].append(v)
-
-    # sort colors by size (descending)
-    sorted_colors = sorted(
-        color_classes.keys(),
-        key=lambda col: len(color_classes[col]),
-        reverse=True
-    )
-
-    ordered_nodes = []
-    for col in sorted_colors:
-        ordered_nodes.extend(color_classes[col])
-
-    return ordered_nodes
-'''
-
-'''
-def mixer_from_graph(G,c):
-    G = nx.convert_node_labels_to_integers(G)
-    n = G.number_of_nodes()
-
-    qc = QuantumCircuit(n)
-    betas = {i: Parameter(f"β_{i}") for i in G.nodes()}
-
-    for i in range(n):
-        qc.x(i)
-
-    for tgt in G.nodes():
-        angle = 2 * betas[tgt]
-        ctrls = list(G.neighbors(tgt))
-        if ctrls:
-            qc.append(RXGate(angle).control(len(ctrls)), ctrls + [tgt])
-        else:
-            qc.rx(angle, tgt)
-
-    return qc, betas, G
-'''
-
-'''
-def mixer_from_graph(G,c):
-    G = nx.convert_node_labels_to_integers(G)
-    n = G.number_of_nodes()
-
-    # 1️⃣ distance-2 coloring
-    color = greedy_distance1_coloring(G)
-
-    qc = QuantumCircuit(n)
-    betas = {i: Parameter(f"β_{i}") for i in G.nodes()}
-
-    # initialize |+>
-    for i in range(n):
-        qc.x(i)
-
-    # 2️⃣ order nodes by largest color class first
-    ordered_nodes = order_nodes_by_color_size(G, color)
-
-    # 3️⃣ build mixer
-    for tgt in ordered_nodes:
-        angle = 2 * betas[tgt]
-        ctrls = list(G.neighbors(tgt))
-
-        if ctrls:
-            qc.append(
-                RXGate(angle).control(len(ctrls)),
-                ctrls + [tgt]
-            )
-        else:
-            qc.rx(angle, tgt)
-
-    return qc, betas, G
-
-
-def expectation_and_variance(qc, betas, C, beta_values, shots: int | None = None):
-    """
-    Compute the mean and variance of the cost H = sum_i c_i (1-Z_i)/2
-    Supports both ideal (shots=None) and shot-based estimation.
-
-    Args:
-        qc: QuantumCircuit with parameterized mixer
-        betas: dict of Qiskit Parameters
-        C: dict mapping qubit -> cost coefficient
-        beta_values: dict mapping qubit -> float
-        shots: number of shots for measurement (None = ideal)
-
-    Returns:
-        (mean, variance)
-    """
-    bind_dict = {betas[i]: beta_values[i] for i in betas}
-    qc_bound = qc.assign_parameters(bind_dict)
-
-    n = qc.num_qubits
-
-    if shots is None:
-        # Ideal case using statevector
-        psi = Statevector.from_instruction(qc_bound)
-        mean = 0.0
-        var = 0.0
-        for i, c_i in C.items():
-            # expectation <Z_i>
-            p_str = ["I"] * n
-            p_str[i] = "Z"
-            Zi = SparsePauliOp("".join(p_str))
-            exp_Z = psi.expectation_value(Zi).real
-
-            # probability qubit i = 1
-            p1 = (1 - exp_Z) / 2
-            mean += c_i * p1
-            var += c_i**2 * p1 * (1 - p1)
-
-        return mean, var
-
-    else:
-        # Shot-based case
-        qc_meas = qc_bound.copy()
-        qc_meas.measure_all()
-
-        backend = Aer.get_backend("aer_simulator")
-        qc_meas = transpile(qc_meas, backend)
-        counts = backend.run(qc_meas, shots=shots).result().get_counts()
-
-        costs = []
-        for bitstring, count in counts.items():
-            z_vals = np.array([1 if b == "0" else -1 for b in bitstring[::-1]])
-            cost = sum(c_i * (1 - z_vals[i]) / 2 for i, c_i in C.items())
-            costs += [cost] * count
-
-        costs = np.array(costs)
-        mean = costs.mean()
-        var = costs.var(ddof=0)  # population variance
-        return mean, var
-
-    return best
-
-def greedy_optimize_risk_aware(qc, betas, C, beta_values, shots=None, lam=0.5):
-    values = beta_values.copy()
-    free = list(betas.keys())
-    #while free:
-        #i = random.choice(free)
-    for i in range(len(free)):
-        mu, var = expectation_and_variance(qc, betas, C, values, shots)
-        best_score = mu + lam * math.sqrt(var)
-        best_val = values[i]
-
-        for candidate in (0.0, math.pi/2):
-            trial = values.copy()
-            trial[i] = candidate
-            mu_t, var_t = expectation_and_variance(qc, betas, C, trial, shots)
-            score = mu_t + lam * math.sqrt(var_t)
-            if score < best_score:
-                best_score = score
-                best_val = candidate
-
-        values[i] = best_val
-        free.remove(i)
-    return values
-'''
diff --git a/MVC/run_QGMVC.sh b/MVC/run_QGMVC.sh
deleted file mode 100644
index 3d360da..0000000
--- a/MVC/run_QGMVC.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/bash
-#SBATCH --job-name=QGMVC
-#SBATCH --time=30-00:00:00        # 30 days max
-#SBATCH --output=%j.out
-#SBATCH --nodes=1
-#SBATCH --tasks-per-node=1
-#SBATCH --cpus-per-task=1
-
-# Activate your Python environment
-source quantumreservoirpy/bin/activate   # adjust path if needed
-
-# Run the script with all command-line arguments passed
-python QGMVC.py "$@"
diff --git a/MVC/run_QGMVC_parallel.sh b/MVC/run_QGMVC_parallel.sh
deleted file mode 100644
index 8e11631..0000000
--- a/MVC/run_QGMVC_parallel.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-#SBATCH --job-name=QGMVC
-#SBATCH --time=30-00:00:00        # max 30 days
-#SBATCH --output=%j.out            # stdout to JOBID.out
-#SBATCH --nodes=1
-#SBATCH --ntasks=1                 # 1 Python process per job
-#SBATCH --cpus-per-task=30      # number of cores to use (adjust!)
-#SBATCH --mem=64G                  # memory per node (adjust as needed)
-
-# =========================
-# Load environment
-# =========================
-# Activate your Python environment
-source /path/to/quantumreservoirpy/bin/activate   # <-- change path
-
-# =========================
-# Prevent thread oversubscription
-# =========================
-export OMP_NUM_THREADS=1
-export MKL_NUM_THREADS=1
-
-# =========================
-# Run the Python script
-# =========================
-# Pass all command-line arguments ($@)
-python QGMVC_parallel.py "$@"
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..89af903
--- /dev/null
+++ b/README.md
@@ -0,0 +1,54 @@
+# Quantum-Greedy-MVC
+
+A small Python package for solving:
+- **MVC**: weighted/unweighted Minimum Vertex Cover
+- **MIS**: weighted/unweighted Maximum Independent Set
+
+## Install
+
+```bash
+pip install .
+```
+
+Optional extras:
+
+```bash
+pip install .[quantum]
+pip install .[cplex]
+pip install .[all]
+```
+
+## Minimal usage
+
+```python
+import networkx as nx
+from quantum_greedy_mvc import QuantumGreedySolver
+
+G = nx.cycle_graph(6)
+solver = QuantumGreedySolver(method="qeg_ldf", qeg_time=0.35, qeg_trotter_layers=1)
+
+mvc = solver.solve_mvc(G)
+mis = solver.solve_mis(G)
+
+print(mvc.solution, mvc.objective)
+print(mis.solution, mis.objective)
+```
+
+## Notebook example
+
+- `examples/basic_usage.ipynb`
+
+## Methods
+
+- `quantum_greedy` (existing heuristic mixer)
+- `qeg_ldf` (recursive Quantum Energy Greedy with LDF-like reduction)
+- `greedy_degree`
+- `primal_dual`
+- `exact` and `lp_relaxation`
+
+Reference: https://arxiv.org/pdf/2607.27915
+
+## Notes
+
+- The main interface is Python API (`QuantumGreedySolver`).
+- CLI tools are not required for core usage.
diff --git a/examples/basic_usage.ipynb b/examples/basic_usage.ipynb
new file mode 100644
index 0000000..81f7f41
--- /dev/null
+++ b/examples/basic_usage.ipynb
@@ -0,0 +1,60 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Quantum-Greedy-MVC: Basic Usage\\n",
+    "\\n",
+    "This notebook shows the simplest way to solve MVC and MIS with the package API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx\\n",
+    "from quantum_greedy_mvc import QuantumGreedySolver"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = nx.cycle_graph(6)\\n",
+    "weights = {node: 1.0 for node in G.nodes()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "solver = QuantumGreedySolver(method=\"qeg_ldf\", qeg_time=0.35, qeg_trotter_layers=1)\\n",
+    "mvc = solver.solve_mvc(G, weights=weights)\\n",
+    "mis = solver.solve_mis(G, weights=weights)\\n",
+    "\\n",
+    "print('MVC solution:', sorted(mvc.solution), 'objective:', mvc.objective)\\n",
+    "print('MIS solution:', sorted(mis.solution), 'objective:', mis.objective)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..f830728
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quantum-greedy-mvc"
+version = "0.1.0"
+description = "Quantum-greedy solvers for Minimum Vertex Cover (MVC) and Maximum Independent Set (MIS)"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+  { name = "OpenQuantumComputing" }
+]
+license = { text = "Proprietary" }
+dependencies = [
+  "networkx>=3.0",
+  "numpy>=1.24"
+]
+
+[project.optional-dependencies]
+quantum = [
+  "qiskit>=1.0",
+  "qiskit-aer>=0.14"
+]
+cplex = [
+  "docplex>=2.25"
+]
+all = [
+  "qiskit>=1.0",
+  "qiskit-aer>=0.14",
+  "docplex>=2.25"
+]
+dev = [
+  "pytest>=8.0"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
diff --git a/src/quantum_greedy_mvc/__init__.py b/src/quantum_greedy_mvc/__init__.py
new file mode 100644
index 0000000..9392fd6
--- /dev/null
+++ b/src/quantum_greedy_mvc/__init__.py
@@ -0,0 +1,6 @@
+"""Public API for quantum_greedy_mvc."""
+
+from .solver import QuantumGreedySolver
+from .types import SolveResult
+
+__all__ = ["QuantumGreedySolver", "SolveResult"]
diff --git a/src/quantum_greedy_mvc/_internal/__init__.py b/src/quantum_greedy_mvc/_internal/__init__.py
new file mode 100644
index 0000000..ffe968f
--- /dev/null
+++ b/src/quantum_greedy_mvc/_internal/__init__.py
@@ -0,0 +1 @@
+"""Internal solver implementations."""
diff --git a/src/quantum_greedy_mvc/_internal/classical.py b/src/quantum_greedy_mvc/_internal/classical.py
new file mode 100644
index 0000000..22b15b0
--- /dev/null
+++ b/src/quantum_greedy_mvc/_internal/classical.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import random
+from typing import Any
+
+
+def is_vertex_cover(graph, cover: set[Any]) -> bool:
+    return all(u in cover or v in cover for u, v in graph.edges())
+
+
+def greedy_degree_vertex_cover(graph, weights: dict[Any, float]) -> set[Any]:
+    gc = graph.copy()
+    cover: set[Any] = set()
+    unweighted = len({float(w) for w in weights.values()}) == 1
+    while gc.number_of_edges() > 0:
+        if unweighted:
+            node = max(gc.nodes(), key=lambda x: gc.degree(x))
+        else:
+            node = max(gc.nodes(), key=lambda x: gc.degree(x) / max(weights[x], 1e-12))
+        cover.add(node)
+        gc.remove_node(node)
+    return cover
+
+
+def greedy_edge_vertex_cover(graph, weights: dict[Any, float]) -> set[Any]:
+    gc = graph.copy()
+    cover: set[Any] = set()
+    while gc.number_of_edges() > 0:
+        u, v = random.choice(list(gc.edges()))
+        chosen = u if weights[u] <= weights[v] else v
+        cover.add(chosen)
+        gc.remove_node(chosen)
+    return cover
+
+
+def mvc_primal_dual_weighted(graph, weights: dict[Any, float]) -> set[Any]:
+    remaining_edges = set(graph.edges())
+    cover: set[Any] = set()
+    while remaining_edges:
+        u, v = min(
+            remaining_edges,
+            key=lambda edge: weights[edge[0]] + weights[edge[1]],
+        )
+        chosen = u if weights[u] <= weights[v] else v
+        cover.add(chosen)
+        remaining_edges = {edge for edge in remaining_edges if chosen not in edge}
+    return cover
+
+
+def mvc_exact_cplex(graph, weights: dict[Any, float]) -> set[Any]:
+    try:
+        from docplex.mp.model import Model
+    except ImportError as exc:
+        raise ImportError("Method 'exact' requires optional dependency 'docplex'.") from exc
+
+    model = Model("wmvc_exact")
+    x = {node: model.binary_var(name=f"x_{node}") for node in graph.nodes()}
+
+    for u, v in graph.edges():
+        model.add_constraint(x[u] + x[v] >= 1)
+
+    model.minimize(model.sum(weights[node] * x[node] for node in graph.nodes()))
+    model.solve(log_output=False)
+
+    return {node for node in x if x[node].solution_value > 0.5}
+
+
+def mvc_lp_relaxation(graph, weights: dict[Any, float]) -> set[Any]:
+    try:
+        from docplex.mp.model import Model
+    except ImportError as exc:
+        raise ImportError("Method 'lp_relaxation' requires optional dependency 'docplex'.") from exc
+
+    model = Model("wmvc_lp")
+    x = {
+        node: model.continuous_var(lb=0, ub=1, name=f"x_{node}")
+        for node in graph.nodes()
+    }
+
+    for u, v in graph.edges():
+        model.add_constraint(x[u] + x[v] >= 1)
+
+    model.minimize(model.sum(weights[node] * x[node] for node in graph.nodes()))
+    model.solve(log_output=False)
+
+    return {node for node in x if x[node].solution_value >= 0.5}
diff --git a/src/quantum_greedy_mvc/_internal/quantum.py b/src/quantum_greedy_mvc/_internal/quantum.py
new file mode 100644
index 0000000..9ad70ca
--- /dev/null
+++ b/src/quantum_greedy_mvc/_internal/quantum.py
@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import math
+import random
+from typing import Any
+
+import networkx as nx
+import numpy as np
+
+
+def _require_qiskit():
+    try:
+        from qiskit import QuantumCircuit, transpile
+        from qiskit.circuit import Parameter
+        from qiskit.circuit.library import RXGate
+        from qiskit.quantum_info import SparsePauliOp, Statevector
+        from qiskit_aer import Aer
+    except ImportError as exc:
+        raise ImportError(
+            "Quantum methods require optional dependencies 'qiskit' and 'qiskit-aer'."
+        ) from exc
+    return QuantumCircuit, transpile, Parameter, RXGate, SparsePauliOp, Statevector, Aer
+
+
+def _deterministic_node_order(nodes) -> list[Any]:
+    return sorted(nodes, key=lambda node: (str(type(node)), repr(node)))
+
+
+def _relabel_graph_and_weights(
+    graph: nx.Graph,
+    weights: dict[Any, float],
+) -> tuple[nx.Graph, dict[int, float], dict[Any, int], dict[int, Any]]:
+    ordered_nodes = _deterministic_node_order(graph.nodes())
+    node_to_int = {node: i for i, node in enumerate(ordered_nodes)}
+    int_to_node = {i: node for node, i in node_to_int.items()}
+
+    graph_int = nx.relabel_nodes(graph, node_to_int, copy=True)
+    weights_int = {node_to_int[node]: float(weights[node]) for node in ordered_nodes}
+    return graph_int, weights_int, node_to_int, int_to_node
+
+
+def _build_cost_hamiltonian(weights: dict[int, float], n_qubits: int):
+    _, _, _, _, SparsePauliOp, _, _ = _require_qiskit()
+
+    paulis = []
+    coeffs = []
+    for qubit, weight in weights.items():
+        pauli = ["I"] * n_qubits
+        pauli[n_qubits - 1 - qubit] = "Z"
+        paulis.append("".join(pauli))
+        coeffs.append(-0.5 * weight)
+
+    return SparsePauliOp(paulis, coeffs), 0.5 * sum(weights.values())
+
+
+def _expected_cost_from_circuit(circuit, weights: dict[int, float], shots: int | None) -> float:
+    _, transpile, _, _, _, Statevector, Aer = _require_qiskit()
+
+    hamiltonian, shift = _build_cost_hamiltonian(weights, circuit.num_qubits)
+
+    if shots is None:
+        state = Statevector.from_instruction(circuit)
+        return float(shift + state.expectation_value(hamiltonian).real)
+
+    measured = circuit.copy()
+    measured.measure_all()
+    backend = Aer.get_backend("aer_simulator")
+    measured = transpile(measured, backend)
+    counts = backend.run(measured, shots=shots).result().get_counts()
+
+    expectation = 0.0
+    for bitstring, count in counts.items():
+        prob = count / shots
+        z_vals = np.array([1 if bit == "0" else -1 for bit in bitstring[::-1]])
+        hz = sum(-0.5 * weights[i] * z_vals[i] for i in weights)
+        expectation += prob * hz
+
+    return float(shift + expectation)
+
+
+def _mixer_from_graph(graph: nx.Graph, weights: dict[int, float]):
+    QuantumCircuit, _, Parameter, RXGate, _, _, _ = _require_qiskit()
+
+    n_qubits = graph.number_of_nodes()
+    circuit = QuantumCircuit(n_qubits)
+    betas = {node: Parameter(f"β_{node}") for node in graph.nodes()}
+
+    for qubit in range(n_qubits):
+        circuit.x(qubit)
+
+    node_order = sorted(graph.nodes(), key=lambda node: (-weights[node], graph.degree(node)))
+    for target in node_order:
+        angle = 2 * betas[target]
+        controls = list(graph.neighbors(target))
+        if controls:
+            circuit.append(RXGate(angle).control(len(controls)), controls + [target])
+        else:
+            circuit.rx(angle, target)
+
+    return circuit, betas
+
+
+def expectation_value_cost_shifted(circuit, betas, weights, beta_values, shots: int | None = None):
+    bound = circuit.assign_parameters({betas[i]: beta_values[i] for i in betas})
+    return _expected_cost_from_circuit(bound, weights, shots)
+
+
+def _greedy_optimize_angles(circuit, betas, weights, beta_values, shots: int | None = None):
+    values = beta_values.copy()
+    free = list(betas.keys())
+
+    while free:
+        idx = random.choice(free)
+        best_val = values[idx]
+        best_energy = expectation_value_cost_shifted(circuit, betas, weights, values, shots)
+
+        for candidate in (0.0, math.pi / 2):
+            trial = values.copy()
+            trial[idx] = candidate
+            energy = expectation_value_cost_shifted(circuit, betas, weights, trial, shots)
+            if energy < best_energy:
+                best_energy = energy
+                best_val = candidate
+
+        values[idx] = best_val
+        free.remove(idx)
+
+    return values
+
+
+def _is_selected_for_cover(beta: float, atol: float = 1e-9) -> bool:
+    # Preserve established behavior:
+    # near pi/2 -> not selected; everything else -> selected fallback.
+    return not (abs(beta - (math.pi / 2)) <= atol)
+
+
+def quantum_greedy_vertex_cover(
+    graph: nx.Graph,
+    weights: dict[Any, float],
+    shots: int | None = None,
+) -> set[Any]:
+    graph_int, weights_int, _, int_to_node = _relabel_graph_and_weights(graph, weights)
+    circuit, betas = _mixer_from_graph(graph_int, weights_int)
+    beta_init = {i: 0.5 * math.pi / 2 for i in graph_int.nodes()}
+    solved = _greedy_optimize_angles(circuit, betas, weights_int, beta_init, shots)
+
+    cover_int = {i for i, beta in solved.items() if _is_selected_for_cover(beta)}
+
+    for u, v in graph_int.edges():
+        if u not in cover_int and v not in cover_int:
+            cover_int.add(u if weights_int[u] <= weights_int[v] else v)
+
+    return {int_to_node[i] for i in cover_int}
+
+
+def _conditioned_mvc_mixer_circuit(
+    graph_int: nx.Graph,
+    fixed_vertex: int,
+    evolution_time: float,
+    trotter_layers: int,
+):
+    QuantumCircuit, _, _, RXGate, _, _, _ = _require_qiskit()
+
+    if trotter_layers < 1:
+        raise ValueError("trotter_layers must be >= 1")
+
+    circuit = QuantumCircuit(graph_int.number_of_nodes())
+    for qubit in range(graph_int.number_of_nodes()):
+        circuit.x(qubit)
+
+    delta_t = evolution_time / trotter_layers
+    # RX(theta) = exp(-i theta X / 2), so exp(+i delta_t X) => RX(-2*delta_t)
+    theta = -2.0 * delta_t
+
+    for _ in range(trotter_layers):
+        for qubit in range(graph_int.number_of_nodes()):
+            if qubit == fixed_vertex:
+                continue
+            controls = sorted(graph_int.neighbors(qubit))
+            if controls:
+                circuit.append(RXGate(theta).control(len(controls)), controls + [qubit])
+            else:
+                circuit.rx(theta, qubit)
+
+    return circuit
+
+
+def _remove_isolated_nodes_inplace(graph: nx.Graph, weights: dict[Any, float]) -> None:
+    isolated = [node for node, degree in graph.degree() if degree == 0]
+    if isolated:
+        graph.remove_nodes_from(isolated)
+        for node in isolated:
+            weights.pop(node, None)
+
+
+def qeg_ldf_vertex_cover(
+    graph: nx.Graph,
+    weights: dict[Any, float],
+    evolution_time: float = 0.35,
+    trotter_layers: int = 1,
+    shots: int | None = None,
+) -> tuple[set[Any], list[dict[str, Any]]]:
+    if evolution_time <= 0:
+        raise ValueError("evolution_time must be > 0")
+    if trotter_layers < 1:
+        raise ValueError("trotter_layers must be >= 1")
+
+    working_graph = graph.copy()
+    working_weights = {node: float(weights[node]) for node in working_graph.nodes()}
+    cover: set[Any] = set()
+    diagnostics: list[dict[str, Any]] = []
+
+    _remove_isolated_nodes_inplace(working_graph, working_weights)
+
+    step = 0
+    while working_graph.number_of_edges() > 0:
+        candidates = [node for node, degree in working_graph.degree() if degree > 0]
+        if not candidates:
+            break
+
+        graph_int, weights_int, node_to_int, int_to_node = _relabel_graph_and_weights(
+            working_graph,
+            working_weights,
+        )
+
+        energies: dict[Any, float] = {}
+        for node in candidates:
+            circuit = _conditioned_mvc_mixer_circuit(
+                graph_int=graph_int,
+                fixed_vertex=node_to_int[node],
+                evolution_time=evolution_time,
+                trotter_layers=trotter_layers,
+            )
+            energies[node] = _expected_cost_from_circuit(circuit, weights_int, shots)
+
+        chosen = min(
+            candidates,
+            key=lambda node: (energies[node], -working_graph.degree(node), str(type(node)), repr(node)),
+        )
+
+        remaining_before = working_graph.number_of_edges()
+        cover.add(chosen)
+        working_graph.remove_node(chosen)
+        working_weights.pop(chosen, None)
+        _remove_isolated_nodes_inplace(working_graph, working_weights)
+
+        diagnostics.append(
+            {
+                "step": step,
+                "chosen": chosen,
+                "chosen_energy": float(energies[chosen]),
+                "remaining_edges_before": int(remaining_before),
+                "remaining_edges_after": int(working_graph.number_of_edges()),
+                "mapping": [{"node": int_to_node[q], "qubit": q} for q in sorted(int_to_node)],
+                "candidates": [
+                    {
+                        "node": node,
+                        "qubit": node_to_int[node],
+                        "energy": float(energies[node]),
+                        "degree": int(working_graph.degree(node)) if node in working_graph else 0,
+                        "weight": float(weights_int[node_to_int[node]]),
+                    }
+                    for node in _deterministic_node_order(candidates)
+                ],
+            }
+        )
+        step += 1
+
+    return cover, diagnostics
diff --git a/src/quantum_greedy_mvc/solver.py b/src/quantum_greedy_mvc/solver.py
new file mode 100644
index 0000000..3fdb084
--- /dev/null
+++ b/src/quantum_greedy_mvc/solver.py
@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+import networkx as nx
+
+from ._internal.classical import (
+    greedy_degree_vertex_cover,
+    is_vertex_cover,
+    mvc_exact_cplex,
+    mvc_lp_relaxation,
+    mvc_primal_dual_weighted,
+)
+from ._internal.quantum import qeg_ldf_vertex_cover, quantum_greedy_vertex_cover
+from .types import SolveResult
+
+ProblemName = Literal["mvc", "mis"]
+MethodName = Literal[
+    "quantum_greedy",
+    "qeg_ldf",
+    "greedy_degree",
+    "primal_dual",
+    "exact",
+    "lp_relaxation",
+]
+
+
+@dataclass
+class QuantumGreedySolver:
+    method: MethodName = "quantum_greedy"
+    shots: int | None = None
+    qeg_time: float = 0.35
+    qeg_trotter_layers: int = 1
+
+    def __post_init__(self) -> None:
+        if self.shots is not None and self.shots <= 0:
+            raise ValueError("shots must be a positive integer or None")
+        if self.method == "qeg_ldf":
+            if self.qeg_time <= 0:
+                raise ValueError("qeg_time must be > 0")
+            if self.qeg_trotter_layers < 1:
+                raise ValueError("qeg_trotter_layers must be >= 1")
+
+    def solve(
+        self,
+        graph: nx.Graph,
+        problem: ProblemName = "mvc",
+        weights: dict[Any, float] | None = None,
+    ) -> SolveResult:
+        if problem == "mvc":
+            return self.solve_mvc(graph=graph, weights=weights)
+        if problem == "mis":
+            return self.solve_mis(graph=graph, weights=weights)
+        raise ValueError(f"Unsupported problem '{problem}'. Use 'mvc' or 'mis'.")
+
+    def solve_mvc(self, graph: nx.Graph, weights: dict[Any, float] | None = None) -> SolveResult:
+        graph = self._validate_graph(graph)
+        weights = self._normalize_weights(graph, weights)
+        cover, extra = self._solve_vertex_cover(graph, weights)
+
+        metadata = {
+            "n_nodes": graph.number_of_nodes(),
+            "n_edges": graph.number_of_edges(),
+            **extra,
+        }
+
+        return SolveResult(
+            problem="mvc",
+            method=self.method,
+            solution=set(cover),
+            objective=float(sum(weights[node] for node in cover)),
+            feasible=is_vertex_cover(graph, cover),
+            metadata=metadata,
+        )
+
+    def solve_mis(self, graph: nx.Graph, weights: dict[Any, float] | None = None) -> SolveResult:
+        graph = self._validate_graph(graph)
+        weights = self._normalize_weights(graph, weights)
+        cover, extra = self._solve_vertex_cover(graph, weights)
+        independent_set = set(graph.nodes()) - set(cover)
+
+        metadata = {
+            "n_nodes": graph.number_of_nodes(),
+            "n_edges": graph.number_of_edges(),
+            "via": "complement_of_vertex_cover",
+            **extra,
+        }
+
+        return SolveResult(
+            problem="mis",
+            method=self.method,
+            solution=independent_set,
+            objective=float(sum(weights[node] for node in independent_set)),
+            feasible=self._is_independent_set(graph, independent_set),
+            metadata=metadata,
+        )
+
+    def _solve_vertex_cover(
+        self,
+        graph: nx.Graph,
+        weights: dict[Any, float],
+    ) -> tuple[set[Any], dict[str, Any]]:
+        if self.method == "quantum_greedy":
+            return quantum_greedy_vertex_cover(graph, weights, shots=self.shots), {}
+        if self.method == "qeg_ldf":
+            cover, steps = qeg_ldf_vertex_cover(
+                graph=graph,
+                weights=weights,
+                evolution_time=self.qeg_time,
+                trotter_layers=self.qeg_trotter_layers,
+                shots=self.shots,
+            )
+            return cover, {
+                "qeg_ldf": {
+                    "time": float(self.qeg_time),
+                    "trotter_layers": int(self.qeg_trotter_layers),
+                    "shots": self.shots,
+                    "steps": steps,
+                }
+            }
+        if self.method == "greedy_degree":
+            return greedy_degree_vertex_cover(graph, weights), {}
+        if self.method == "primal_dual":
+            return mvc_primal_dual_weighted(graph, weights), {}
+        if self.method == "exact":
+            return mvc_exact_cplex(graph, weights), {}
+        if self.method == "lp_relaxation":
+            return mvc_lp_relaxation(graph, weights), {}
+        raise ValueError(f"Unsupported method '{self.method}'.")
+
+    @staticmethod
+    def _validate_graph(graph: nx.Graph) -> nx.Graph:
+        if not isinstance(graph, nx.Graph):
+            raise TypeError("graph must be an instance of networkx.Graph")
+        if graph.is_directed():
+            raise ValueError("Directed graphs are not supported. Provide an undirected graph.")
+        return graph
+
+    @staticmethod
+    def _normalize_weights(graph: nx.Graph, weights: dict[Any, float] | None) -> dict[Any, float]:
+        if weights is None:
+            return {node: 1.0 for node in graph.nodes()}
+
+        node_set = set(graph.nodes())
+        weight_nodes = set(weights.keys())
+        if node_set != weight_nodes:
+            missing = node_set - weight_nodes
+            extra = weight_nodes - node_set
+            raise ValueError(f"weights keys must match graph nodes. missing={missing}, extra={extra}")
+
+        normalized = {node: float(value) for node, value in weights.items()}
+        if any(value < 0 for value in normalized.values()):
+            raise ValueError("All weights must be non-negative for MVC/MIS solving.")
+
+        return normalized
+
+    @staticmethod
+    def _is_independent_set(graph: nx.Graph, nodes: set[Any]) -> bool:
+        for u, v in graph.edges():
+            if u in nodes and v in nodes:
+                return False
+        return True
diff --git a/src/quantum_greedy_mvc/types.py b/src/quantum_greedy_mvc/types.py
new file mode 100644
index 0000000..f61e047
--- /dev/null
+++ b/src/quantum_greedy_mvc/types.py
@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SolveResult:
+    problem: str
+    method: str
+    solution: set[Any]
+    objective: float
+    feasible: bool
+    metadata: dict[str, Any] = field(default_factory=dict)
diff --git a/tests/test_solver.py b/tests/test_solver.py
new file mode 100644
index 0000000..60713f9
--- /dev/null
+++ b/tests/test_solver.py
@@ -0,0 +1,85 @@
+import networkx as nx
+import pytest
+
+from quantum_greedy_mvc import QuantumGreedySolver
+
+
+def test_mvc_unweighted_greedy_degree_returns_vertex_cover():
+    graph = nx.cycle_graph(6)
+    solver = QuantumGreedySolver(method="greedy_degree")
+    result = solver.solve_mvc(graph)
+
+    assert result.problem == "mvc"
+    assert result.feasible is True
+    assert isinstance(result.solution, set)
+    assert result.objective == float(len(result.solution))
+
+
+def test_mis_unweighted_is_independent_set():
+    graph = nx.path_graph(7)
+    solver = QuantumGreedySolver(method="primal_dual")
+    result = solver.solve_mis(graph)
+
+    assert result.problem == "mis"
+    assert result.feasible is True
+    for u, v in graph.edges():
+        assert not (u in result.solution and v in result.solution)
+
+
+def test_weighted_mvc_and_mis_objectives_sum_to_total_weight():
+    graph = nx.cycle_graph(4)
+    weights = {0: 2.0, 1: 1.0, 2: 2.0, 3: 1.0}
+
+    solver = QuantumGreedySolver(method="greedy_degree")
+    mvc = solver.solve_mvc(graph, weights=weights)
+    mis = solver.solve_mis(graph, weights=weights)
+
+    total_weight = sum(weights.values())
+    assert abs((mvc.objective + mis.objective) - total_weight) < 1e-9
+
+
+def test_invalid_weights_raise():
+    graph = nx.path_graph(3)
+    solver = QuantumGreedySolver(method="greedy_degree")
+
+    bad_weights = {0: 1.0, 1: 2.0}
+    with pytest.raises(ValueError, match="weights keys must match graph nodes"):
+        solver.solve_mvc(graph, weights=bad_weights)
+
+
+def test_qeg_ldf_dispatch_includes_metadata(monkeypatch):
+    graph = nx.path_graph(4)
+
+    def fake_qeg(graph, weights, evolution_time, trotter_layers, shots):
+        assert evolution_time == 0.7
+        assert trotter_layers == 3
+        assert shots is None
+        return {1, 2}, [{"step": 0, "chosen": 1, "chosen_energy": 1.23}]
+
+    monkeypatch.setattr("quantum_greedy_mvc.solver.qeg_ldf_vertex_cover", fake_qeg)
+
+    solver = QuantumGreedySolver(method="qeg_ldf", qeg_time=0.7, qeg_trotter_layers=3)
+    result = solver.solve_mvc(graph)
+
+    assert result.method == "qeg_ldf"
+    assert result.solution == {1, 2}
+    assert result.metadata["qeg_ldf"]["time"] == 0.7
+    assert result.metadata["qeg_ldf"]["trotter_layers"] == 3
+    assert result.metadata["qeg_ldf"]["steps"][0]["chosen"] == 1
+
+
+def test_qeg_parameter_validation():
+    with pytest.raises(ValueError, match="qeg_trotter_layers"):
+        QuantumGreedySolver(method="qeg_ldf", qeg_trotter_layers=0)
+
+    with pytest.raises(ValueError, match="qeg_time"):
+        QuantumGreedySolver(method="qeg_ldf", qeg_time=-0.1)
+
+    with pytest.raises(ValueError, match="qeg_time"):
+        QuantumGreedySolver(method="qeg_ldf", qeg_time=0.0)
+
+
+def test_non_qeg_methods_ignore_qeg_parameters():
+    solver = QuantumGreedySolver(method="greedy_degree", qeg_time=-1.0, qeg_trotter_layers=0)
+    result = solver.solve_mvc(nx.path_graph(4))
+    assert result.feasible is True