Merge pull request #36 from simsaidan/aidanfinishtests

expand out the test suite

Author: simsaidan

.coveragerc

@@ -6,9 +6,8 @@ branch = True
 [report]
 show_missing = True
 precision = 2
-# Fail the coverage run if total coverage drops below this floor. Adjust upward toward
-# the codecov target (70..90) as coverage allows (currently ~78%).
-fail_under = 75
+# Fail the coverage run if total coverage drops below this floor.
+fail_under = 90
 omit =
     */__init__.py
     */test/*

shadowsim/core/hamiltonian.py

@@ -48,7 +48,7 @@ def to_hamiltonian_set(self):
 
     def to_local_hamiltonian(self, local_dim: int = 2):
         """Returns a LocalHamiltonian representing the Hamiltonian acting on
-        the given sites.
+        a contiguous block of sites starting at 0.
 
         Parameter local_dim: The local dimension of the Hamiltonian.
         Precondition: local_dim is a positive integer.
@@ -58,5 +58,16 @@ def to_local_hamiltonian(self, local_dim: int = 2):
 
         from shadowsim.core.local_hamiltonian import LocalHamiltonian
 
-        lo = self.to_local_operator(local_dim)
+        dim = int(self.matrix.shape[0])
+        n_sites = 0
+        span = 1
+        while span < dim:
+            span *= local_dim
+            n_sites += 1
+        if span != dim:
+            raise ValueError(
+                f"Hamiltonian dimension {dim} is not a power of local_dim={local_dim}"
+            )
+        sites = list(range(n_sites))
+        lo = self.to_local_operator(sites, local_dim)
         return LocalHamiltonian(lo.matrix, lo.sites, lo.local_dim)

test/benchmarking/test_benchmark.py

@@ -0,0 +1,130 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from shadowsim.benchmarking import Benchmark
+from shadowsim.core import Hamiltonian
+from shadowsim.core import State
+from shadowsim.simulators.simulator import Simulator
+
+
+Z = np.array([[1, 0], [0, -1]], dtype=np.complex128)
+
+
+class StubSimulator(Simulator):
+    """Minimal simulator with canned expectation traces."""
+
+    def __init__(
+        self,
+        *,
+        total_time: float = 1.0,
+        time_steps: int = 3,
+        curves: list[np.ndarray] | None = None,
+        id: str = "stub",
+    ):
+        super().__init__(
+            [Hamiltonian(Z)],
+            [],
+            State(np.array([1.0, 0.0], dtype=np.complex128), 1),
+            1,
+            total_time,
+            time_steps,
+            id,
+        )
+        if curves is None:
+            t = self.tlist
+            curves = [np.cos(t), np.sin(t)]
+        self._curves = [np.asarray(c, dtype=float) for c in curves]
+
+    def simulate(self):
+        self.results = list(self._curves)
+        return self.results
+
+
+def _pair(**kwargs):
+    return StubSimulator(id="a", **kwargs), StubSimulator(id="b", **kwargs)
+
+
+def test_benchmark_rejects_mismatched_tlist():
+    a = StubSimulator(time_steps=3)
+    b = StubSimulator(time_steps=4)
+    with pytest.raises(ValueError, match="same time grid"):
+        Benchmark(a, b)
+
+
+def test_benchmark_run_and_get_results():
+    a, b = _pair()
+    benchmark = Benchmark(a, b)
+
+    assert np.array_equal(benchmark.get_tlist(), a.tlist)
+
+    benchmark.run()
+    all_a, all_b = benchmark.get_results()
+    assert len(all_a) == len(all_b) == 2
+    assert np.allclose(all_a[0], a.get_results(0))
+    assert np.allclose(all_b[1], b.get_results(1))
+
+    first_a, first_b = benchmark.get_results(0)
+    assert np.allclose(first_a, a.get_results(0))
+    assert np.allclose(first_b, b.get_results(0))
+
+
+def test_benchmark_save_result_plot_writes_three_files(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    a, b = _pair()
+    # Distinct curves so the abs-diff plot is nontrivial.
+    b._curves = [np.cos(b.tlist) + 0.1, np.sin(b.tlist) - 0.1]
+    benchmark = Benchmark(a, b)
+    benchmark.run()
+
+    pa, pb, pdiff = benchmark.save_result_plot(
+        labels=["cavity", "emitter"],
+        title_a="A",
+        title_b="B",
+        title="diff",
+        dpi=80,
+    )
+
+    assert pa.is_file()
+    assert pb.is_file()
+    assert pdiff.is_file()
+    assert pa.parent == Path("results")
+    assert pdiff.name.startswith("benchmark_abs_diff_")
+
+
+def test_benchmark_abs_diff_requires_results():
+    a, b = _pair()
+    benchmark = Benchmark(a, b)
+    with pytest.raises(ValueError, match="Results are not available"):
+        benchmark._save_abs_diff_plot(indices=None, dpi=80, title=None)
+
+
+def test_benchmark_abs_diff_with_explicit_indices_and_no_title(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    a, b = _pair()
+    a.results = a._curves
+    b.results = b._curves
+    benchmark = Benchmark(a, b)
+
+    path = benchmark._save_abs_diff_plot(indices=[0], dpi=80, title=None)
+    assert path.is_file()
+
+
+def test_benchmark_abs_diff_rejects_mismatched_observable_counts():
+    a = StubSimulator(id="a", curves=[np.zeros(3), np.ones(3)])
+    b = StubSimulator(id="b", curves=[np.zeros(3)])
+    a.results = a._curves
+    b.results = b._curves
+    benchmark = Benchmark(a, b)
+
+    with pytest.raises(ValueError, match="Mismatched observable counts"):
+        benchmark._save_abs_diff_plot(indices=None, dpi=80, title=None)
+
+
+def test_benchmark_str_and_repr():
+    a, b = _pair()
+    benchmark = Benchmark(a, b)
+
+    assert str(benchmark) == "Benchmark(simulator_a=StubSimulator, simulator_b=StubSimulator)"
+    assert "StubSimulator(" in repr(benchmark)

test/core/test_combined_hamiltonian_matrix.py

@@ -21,3 +21,19 @@ def test_combined_hamiltonian_matrix_rejects_mixed_local_dims():
     h3 = LocalHamiltonian(np.diag([1.0, 0.0, -1.0]), sites=[0], local_dim=3)
     with pytest.raises(ValueError, match="mixed local_dim"):
         combined_hamiltonian_matrix([h2, h3], num_qubits=1)
+
+
+def test_combined_hamiltonian_matrix_embeds_local_with_identity_padding():
+    # Local on middle qubit of a 3-qubit chain → n_before > 0 and n_after > 0.
+    local = LocalHamiltonian(np.diag([1.0, -1.0]), sites=[1], local_dim=2)
+    out = combined_hamiltonian_matrix([local], num_qubits=3)
+    expected = np.kron(np.eye(2), np.kron(np.diag([1.0, -1.0]), np.eye(2)))
+    assert out.shape == (8, 8)
+    assert np.allclose(out, expected)
+
+
+def test_combined_hamiltonian_matrix_rejects_disagreeing_dimensions():
+    local = LocalHamiltonian(np.diag([1.0, -1.0]), sites=[0], local_dim=2)
+    full = Hamiltonian(np.eye(4, dtype=np.complex128))
+    with pytest.raises(ValueError, match="dimensions disagree"):
+        combined_hamiltonian_matrix([local, full], num_qubits=1)

test/core/test_hamiltonian.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pytest
+
+from shadowsim.core import Hamiltonian
+from shadowsim.core import HamiltonianSet
+from shadowsim.core import LocalHamiltonian
+
+
+Z = np.diag([1.0, -1.0]).astype(np.complex128)
+X = np.array([[0.0, 1.0], [1.0, 0.0]], dtype=np.complex128)
+
+
+def test_hamiltonian_str_repr_equality_and_conversions():
+    h = Hamiltonian(Z)
+    other = Hamiltonian(Z)
+    different = Hamiltonian(X)
+
+    assert "Hamiltonian(matrix=" in str(h)
+    assert "Hamiltonian(matrix=" in repr(h)
+    assert h == other
+    assert h != different
+
+    h_set = h.to_hamiltonian_set()
+    assert isinstance(h_set, HamiltonianSet)
+    assert len(h_set) == 1
+    assert h_set[0] == h
+
+    local = h.to_local_hamiltonian(local_dim=2)
+    assert isinstance(local, LocalHamiltonian)
+    assert local.sites == [0]
+    assert local.local_dim == 2
+    assert np.allclose(local.matrix, Z)
+
+
+def test_hamiltonian_to_local_hamiltonian_validates_local_dim():
+    h = Hamiltonian(Z)
+    with pytest.raises(AssertionError, match="local_dim must be an integer"):
+        h.to_local_hamiltonian(local_dim=2.0)  # type: ignore[arg-type]
+    with pytest.raises(AssertionError, match="local_dim must be a positive integer"):
+        h.to_local_hamiltonian(local_dim=0)
+    with pytest.raises(ValueError, match="not a power of local_dim"):
+        Hamiltonian(np.eye(3, dtype=np.complex128)).to_local_hamiltonian(local_dim=2)

test/core/test_hamiltonian_set.py

@@ -0,0 +1,31 @@
+import numpy as np
+import pytest
+
+from shadowsim.core import Hamiltonian
+from shadowsim.core import HamiltonianSet
+
+
+Z = np.diag([1.0, -1.0]).astype(np.complex128)
+X = np.array([[0.0, 1.0], [1.0, 0.0]], dtype=np.complex128)
+
+
+def test_hamiltonian_set_protocols_and_repr():
+    h1 = Hamiltonian(Z)
+    h2 = Hamiltonian(X)
+    h_set = HamiltonianSet([h1, h2])
+
+    assert h_set.hamiltonian_count == 2
+    assert len(h_set) == 2
+    assert list(h_set) == [h1, h2]
+    assert h_set[0] == h1
+    assert h1 in h_set
+    assert Hamiltonian(np.eye(2, dtype=np.complex128)) not in h_set
+    assert "HamiltonianSet(hamiltonian_count=2)" == str(h_set)
+    assert "HamiltonianSet(hamiltonians=" in repr(h_set)
+
+
+def test_hamiltonian_set_validates_inputs():
+    with pytest.raises(AssertionError, match="hamiltonians must be a list"):
+        HamiltonianSet(Hamiltonian(Z))  # type: ignore[arg-type]
+    with pytest.raises(AssertionError, match="all hamiltonians must be Hamiltonian"):
+        HamiltonianSet([Hamiltonian(Z), "nope"])  # type: ignore[list-item]

test/core/test_local_hamiltonian.py

@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from shadowsim.core import Hamiltonian
+from shadowsim.core import LocalHamiltonian
+
+
+Z = np.diag([1.0, -1.0]).astype(np.complex128)
+
+
+def test_local_hamiltonian_to_full_and_accessors():
+    local = LocalHamiltonian(Z, sites=[1], local_dim=2)
+    full = local.to_full_hamiltonian(total_sites=3)
+
+    assert isinstance(full, Hamiltonian)
+    expected = np.kron(np.eye(2), np.kron(Z, np.eye(2)))
+    assert np.allclose(full.matrix, expected)
+    assert local.get_sites() == [1]
+    assert local.get_local_dim() == 2
+    assert np.allclose(local.get_matrix(), Z)
+
+
+def test_local_hamiltonian_to_full_validates_total_sites():
+    local = LocalHamiltonian(Z, sites=[1], local_dim=2)
+    with pytest.raises(AssertionError, match="total_sites must be an integer"):
+        local.to_full_hamiltonian(3.0)  # type: ignore[arg-type]
+    with pytest.raises(AssertionError, match="total_sites must be positive"):
+        local.to_full_hamiltonian(0)
+    with pytest.raises(ValueError, match="too small"):
+        local.to_full_hamiltonian(1)
+
+
+def test_local_hamiltonian_str_and_repr():
+    local = LocalHamiltonian(Z, sites=[0], local_dim=2)
+    text = str(local)
+    rep = repr(local)
+    assert "LocalHamiltonian(" in text
+    assert "sites=[0]" in text
+    assert "LocalHamiltonian(" in rep
+    assert "local_dim=2" in rep

test/core/test_local_operator.py

@@ -50,3 +50,24 @@ def test_local_operator_to_full_operator_validates_total_sites():
         local.to_full_operator(0)
     with pytest.raises(ValueError, match="too small"):
         local.to_full_operator(2)
+
+
+def test_local_operator_accessors_and_conversions():
+    local = LocalOperator(np.eye(2), sites=[0], local_dim=2)
+    assert local.get_sites() == [0]
+    assert local.get_local_dim() == 2
+    assert np.allclose(local.get_matrix(), np.eye(2))
+    as_op = local.to_operator()
+    assert isinstance(as_op, Operator)
+    assert as_op == Operator(np.eye(2))
+
+
+def test_local_operator_str_and_repr():
+    local = LocalOperator(np.eye(2), sites=[0], local_dim=2)
+    text = str(local)
+    rep = repr(local)
+    assert "LocalOperator(" in text
+    assert "sites=[0]" in text
+    assert "LocalOperator(" in rep
+    assert "local_dim=2" in rep
+

test/core/test_operator.py

@@ -47,6 +47,12 @@ def test_operator_equality_and_inequality():
     assert a != c
 
 
+def test_operator_str_and_repr():
+    op = Operator(np.eye(2, dtype=np.complex128))
+    assert "Operator(matrix=" in str(op)
+    assert "Operator(matrix=" in repr(op)
+
+
 def test_operator_set_name_updates_name_field():
     op = Operator(np.eye(2))
     op.set_name("X")

test/core/test_pauli.py

@@ -38,3 +38,25 @@ def test_pauli_multiply_and_commutator():
 
 def test_pauli_commutator_returns_none_for_commuting_pair():
     assert Pauli("X").commutator(Pauli("X")) == (None, None)
+
+
+def test_pauli_eq_returns_notimplemented_for_other_types():
+    assert Pauli("X").__eq__("X") is NotImplemented
+
+
+def test_pauli_multiply_labels_unreachable_raises(monkeypatch):
+    from shadowsim.core import pauli as pauli_module
+
+    monkeypatch.setattr(
+        pauli_module,
+        "_PAULI_MATRICES",
+        {
+            "I": np.zeros((2, 2), dtype=np.complex128),
+            "X": np.array([[1, 2], [3, 4]], dtype=np.complex128),
+            "Y": np.array([[5, 6], [7, 8]], dtype=np.complex128),
+            "Z": np.array([[9, 0], [0, 1]], dtype=np.complex128),
+        },
+    )
+    with pytest.raises(RuntimeError, match="unreachable"):
+        pauli_module._multiply_labels("X", "Y")
+