vqe-pennylane 0.2.2__py3-none-any.whl

vqe_qpe_common/geometry.py

@@ -0,0 +1,52 @@
+"""
+common.geometry
+===============
+
+Shared geometry generation for bond scans, angle scans, etc.
+Used identically by VQE and QPE.
+"""
+
+from __future__ import annotations
+import numpy as np
+from typing import Tuple, List
+
+def generate_geometry(name: str, param: float):
+    """
+    Geometry wrapper.
+    Supported conventions (matching VQE):
+        "H2_BOND"
+        "H3+_BOND"
+        "LiH_BOND"
+        "H2O_ANGLE"
+    """
+    if name == "H2_BOND":
+        return ["H", "H"], np.array([
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, param]
+        ])
+
+    if name == "H3+_BOND":
+        # Example equilateral-ish geometry
+        return ["H", "H", "H"], np.array([
+            [0.0, 0.0, 0.0],
+            [param, 0.0, 0.0],
+            [0.5 * param, 0.866 * param, 0.0],
+        ])
+
+    if name == "LiH_BOND":
+        return ["Li", "H"], np.array([
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, param]
+        ])
+
+    if name == "H2O_ANGLE":
+        # Angle given in degrees
+        theta = np.deg2rad(param)
+        bond = 0.958
+        return ["O", "H", "H"], np.array([
+            [0.0, 0.0, 0.0],
+            [bond, 0.0, 0.0],
+            [bond * np.cos(theta), bond * np.sin(theta), 0.0],
+        ])
+
+    raise KeyError(f"Unknown geometry type: {name}")

vqe_qpe_common/hamiltonian.py

@@ -0,0 +1,58 @@
+"""
+common.hamiltonian
+==================
+
+Shared Hamiltonian construction used by VQE, QPE, and future solvers.
+"""
+
+from __future__ import annotations
+import numpy as np
+import pennylane as qml
+from pennylane import qchem
+from typing import Tuple
+
+from vqe_qpe_common.molecules import get_molecule_config
+
+def hartree_fock_state(symbols, charge, n_qubits):
+    """Compute electron count and return HF basis state bitstring."""
+    Z = {
+        "H": 1,
+        "He": 2,
+        "Li": 3,
+        "Be": 4,
+        "O": 8,
+    }
+    electrons = sum(Z[s] for s in symbols) - charge
+    return qchem.hf_state(int(electrons), n_qubits)
+
+def build_hamiltonian(symbols, coordinates, charge, basis) -> Tuple[qml.Hamiltonian, int, np.ndarray]:
+    """
+    Build Hamiltonian + deduce HF state.
+    Returns: (Hamiltonian, n_qubits, hf_state)
+    """
+    try:
+        H, n_qubits = qchem.molecular_hamiltonian(
+            symbols=symbols,
+            coordinates=coordinates,
+            charge=charge,
+            basis=basis,
+        )
+    except Exception as e_primary:
+        print("⚠️ Default PennyLane-qchem backend failed — retrying with OpenFermion...")
+        try:
+            H, n_qubits = qchem.molecular_hamiltonian(
+                symbols=symbols,
+                coordinates=coordinates,
+                charge=charge,
+                basis=basis,
+                method="openfermion",
+            )
+        except Exception as e_fallback:
+            raise RuntimeError(
+                f"Failed to construct Hamiltonian.\n"
+                f"Primary error: {e_primary}\n"
+                f"Fallback error: {e_fallback}"
+            )
+
+    hf_state = hartree_fock_state(symbols, charge, n_qubits)
+    return H, n_qubits, hf_state

vqe_qpe_common/molecules.py

@@ -0,0 +1,107 @@
+"""
+common.molecules
+================
+
+Canonical molecule registry shared by VQE and QPE.
+
+Every molecule entry contains:
+    • symbols      (list[str])
+    • coordinates  (np.ndarray)
+    • charge       (int)
+    • basis        (str)
+"""
+
+from __future__ import annotations
+import numpy as np
+
+MOLECULES = {
+    "H2": {
+        "symbols": ["H", "H"],
+        "coordinates": np.array([
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.7414],
+        ]),
+        "charge": 0,
+        "basis": "STO-3G",
+    },
+
+    "H3+": {
+        "symbols": ["H", "H", "H"],
+        "coordinates": np.array([
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.872],
+            [0.755, 0.0, 0.436],
+        ]),
+        "charge": +1,
+        "basis": "STO-3G",
+    },
+
+    "LiH": {
+        "symbols": ["Li", "H"],
+        "coordinates": np.array([
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 1.6],
+        ]),
+        "charge": 0,
+        "basis": "STO-3G",
+    },
+
+    "H2O": {
+        "symbols": ["O", "H", "H"],
+        "coordinates": np.array([
+            [0.000000, 0.000000, 0.000000],
+            [0.758602, 0.000000, 0.504284],
+            [-0.758602, 0.000000, 0.504284],
+        ]),
+        "charge": 0,
+        "basis": "STO-3G",
+    },
+
+    # ------------------------------------------------------
+    # NEW MOLECULES (BeH2, H4-chain, HeH+)
+    # ------------------------------------------------------
+
+    "HeH+": {
+        "symbols": ["He", "H"],
+        # Typical HeH+ bond length ~1.46 Å (varies in literature)
+        "coordinates": np.array([
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 1.46],
+        ]),
+        "charge": +1,
+        "basis": "STO-3G",
+    },
+
+    "BeH2": {
+        "symbols": ["Be", "H", "H"],
+        # Linear geometry: H–Be–H with ~1.33 Å Be–H bond length
+        "coordinates": np.array([
+            [0.0,   0.0, 0.0],
+            [0.0,   0.0, 1.33],
+            [0.0,   0.0, -1.33],
+        ]),
+        "charge": 0,
+        "basis": "STO-3G",
+    },
+
+    "H4": {
+        "symbols": ["H", "H", "H", "H"],
+        # Linear H4 chain, equally spaced at 1.0 Å
+        "coordinates": np.array([
+            [0.0, 0.0, 0.0],
+            [1.0, 0.0, 0.0],
+            [2.0, 0.0, 0.0],
+            [3.0, 0.0, 0.0],
+        ]),
+        "charge": 0,
+        "basis": "STO-3G",
+    },
+}
+
+
+def get_molecule_config(name: str):
+    """Return the molecule configuration dict."""
+    try:
+        return MOLECULES[name]
+    except KeyError:
+        raise KeyError(f"Unknown molecule '{name}'. Available = {list(MOLECULES.keys())}")

vqe_qpe_common/plotting.py

@@ -0,0 +1,167 @@
+"""
+common.plotting
+================
+
+Centralised plotting utilities for the entire VQE/QPE package.
+
+Provides:
+    - Unified filename builder for all PNG plots
+    - Automatic path sanitisation (molecule names, operators, symbols)
+    - Consistent plotting export (DPI, bbox, tight layout)
+    - Single point of control for changing any plotting behaviour
+
+This ensures:
+    • Zero filename collisions
+    • Fully consistent naming between VQE, QPE, and notebooks
+    • Clean, readable filenames for publication-quality figures
+"""
+
+from __future__ import annotations
+import os
+from typing import Dict, Optional
+import matplotlib.pyplot as plt
+
+
+# ---------------------------------------------------------------------
+# Base Directories
+# ---------------------------------------------------------------------
+BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+IMG_DIR = os.path.join(BASE_DIR, "images")
+
+
+def ensure_plot_dirs():
+    """Ensure required directories exist."""
+    os.makedirs(IMG_DIR, exist_ok=True)
+
+
+# ---------------------------------------------------------------------
+# Name Sanitisation
+# ---------------------------------------------------------------------
+def format_molecule_name(mol: str) -> str:
+    """
+    Convert a molecule name into a filesystem-safe token.
+
+    Examples:
+        "H3+"       → "H3plus"
+        "H2 O"      → "H2_O"
+        "LiH"       → "LiH"
+    """
+    mol = mol.replace("+", "plus")
+    mol = mol.replace(" ", "_")
+    return mol
+
+
+def format_token(val: Optional[str | float | int]) -> Optional[str]:
+    """
+    Convert metadata values into clean filename components.
+
+    Examples:
+        0.05      → "0p05"
+        0.0       → "0p0"
+        "Adam"    → "Adam"
+        None      → None
+    """
+    if val is None:
+        return None
+    if isinstance(val, (int, float)):
+        s = f"{val:.5f}".rstrip("0").rstrip(".")
+        return s.replace(".", "p")
+    return str(val).replace(" ", "_")
+
+
+# ---------------------------------------------------------------------
+# Filename Builder
+# ---------------------------------------------------------------------
+def build_filename(
+    molecule: Optional[str] = None,
+    *,
+    topic: str,
+    extras: Optional[Dict[str, Optional[float | int | str]]] = None,
+) -> str:
+    """
+    Build a descriptive, collision-safe PNG filename.
+
+    Parameters
+    ----------
+    molecule : str, optional
+        Molecule identifier (e.g., "H2", "H3+").
+    topic : str
+        The major theme of the plot, e.g.
+            "vqe_convergence", "qpe_distribution",
+            "noise_sweep", "optimizer_comparison"
+    extras : dict, optional
+        Arbitrary metadata to encode in filename, e.g.
+            {"optimizer": "Adam", "ansatz": "UCCSD", "anc": 4}
+
+    Returns
+    -------
+    str
+        Filename ending in `.png`.
+
+    Example
+    -------
+        build_filename(
+            molecule="H2",
+            topic="qpe_distribution",
+            extras={"anc": 4, "pdep": 0.02}
+        )
+
+        → "H2_qpe_distribution_anc4_pdep0p02.png"
+    """
+    parts = []
+
+    if molecule:
+        parts.append(format_molecule_name(molecule))
+
+    # Topic (safe)
+    topic = topic.lower().replace(" ", "_")
+    parts.append(topic)
+
+    # Append metadata tokens
+    if extras:
+        for key, val in extras.items():
+            fv = format_token(val)
+            if fv is not None:
+                parts.append(f"{key}{fv}")
+
+    return "_".join(parts) + ".png"
+
+
+# ---------------------------------------------------------------------
+# Unified Save
+# ---------------------------------------------------------------------
+def save_plot(filename: str, show: bool = True) -> str:
+    """
+    Save the current matplotlib figure to the global IMG_DIR and optionally
+    display it inline (for notebooks).
+
+    Parameters
+    ----------
+    filename : str
+        A clean filename produced by build_filename().
+    show : bool, default=True
+        If True, display the plot (for Jupyter/VSCode notebooks).
+        If False, only save.
+
+    Returns
+    -------
+    str
+        Absolute path to the saved PNG.
+    """
+    ensure_plot_dirs()
+
+    # Ensure .png suffix
+    if not filename.lower().endswith(".png"):
+        filename = filename + ".png"
+
+    path = os.path.join(IMG_DIR, filename)
+
+    plt.savefig(path, dpi=300, bbox_inches="tight")
+
+    if show:
+        plt.show()
+    else:
+        plt.close()
+
+    print(f"📁 Saved plot → {path}")
+    return path