Merge pull request #1649 from victor-onofre/graph_state

[unitaryHack 2025] Graph state encoding

Author: renatomello

src/qibo/models/encodings.py

@@ -1555,3 +1555,37 @@ def _add_scs_gate(circuit: Circuit, n: int, k: int):
             gates.RY(target_qubit, theta).controlled_by(control_qubit, last_qubit)
         )
         circuit.add(gates.CNOT(target_qubit, last_qubit))
+
+
+def graph_state(matrix, backend=None, **kwargs):
+    """Create circuit encoding an undirected graph state given its adjacency matrix.
+
+    Args:
+        matrix (ndarray or list): Adjacency matrix of the graph.
+        kwargs (dict, optional): Additional arguments used to initialize a Circuit object.
+            For details, see the documentation of :class:`qibo.models.circuit.Circuit`.
+
+    Returns:
+        :class:`qibo.models.circuit.Circuit`:  Circuit of the graph state with the given Adjacency matrix.
+    """
+    backend = _check_backend(backend)
+
+    if isinstance(matrix, list):
+        matrix = backend.cast(matrix, dtype=int)
+
+    if not backend.np.allclose(matrix, matrix.T):
+        raise_error(
+            ValueError,
+            f"``matrix`` is not symmetric, not representing an undirected graph",
+        )
+
+    nqubits = len(matrix)
+
+    circuit = Circuit(nqubits, **kwargs)
+    circuit.add(gates.H(qubit) for qubit in range(nqubits))
+
+    # since the matrix is symmetric, we only need the upper triangular part
+    rows, columns = backend.np.nonzero(backend.np.triu(matrix))
+    circuit.add(gates.CZ(int(ind_r), int(ind_c)) for ind_r, ind_c in zip(rows, columns))
+
+    return circuit

tests/test_models_encodings.py

@@ -4,6 +4,7 @@
 from functools import reduce
 from itertools import combinations
 
+import networkx as nx
 import numpy as np
 import pytest
 from scipy.optimize import curve_fit
@@ -18,6 +19,7 @@
     dicke_state,
     entangling_layer,
     ghz_state,
+    graph_state,
     hamming_weight_encoder,
     phase_encoder,
     sparse_encoder,
@@ -493,3 +495,61 @@ def test_dicke_state(backend, nqubits, weight, density_matrix):
             target = backend.np.outer(target, backend.np.conj(target.T))
 
         backend.assert_allclose(state, target)
+
+
+@pytest.mark.parametrize(
+    "matrix, expects_error, circuit1, circuit2",
+    [
+        # Test Case 1: 3-qubit graph
+        ([[0, 1, 0], [1, 0, 1], [0, 1, 0]], False, True, False),
+        # Test Case 2: 5-qubit  graph
+        (
+            [
+                [0, 1, 0, 0, 1],
+                [1, 0, 1, 0, 0],
+                [0, 1, 0, 1, 0],
+                [0, 0, 1, 0, 1],
+                [1, 0, 0, 1, 0],
+            ],
+            False,
+            False,
+            True,
+        ),
+        # Test Case 3: Non-symmetric matrix (expected error)
+        (
+            [[0, 1, 0], [0, 0, 1], [0, 1, 0]],
+            True,
+            False,
+            False,
+        ),  # matrix[1,0] != matrix[0,1]
+        # Test Case 4: Non-symmetric matrix (expected error)
+        ([[0, 1], [0, 0]], True, False, False),  # matrix[1,0] != matrix[0,1]
+    ],
+)
+def test_graph_state(backend, matrix, expects_error, circuit1, circuit2):
+
+    if expects_error:
+        # We expect a ValueError for non-symmetric matrices
+        with pytest.raises(ValueError):
+            graph_state(matrix, backend=backend)
+
+    else:
+        if circuit1:
+            nqubits = 3
+            target = Circuit(nqubits)
+            target.add(gates.H(qubit) for qubit in range(nqubits))
+            target.add(gates.CZ(0, 1))
+            target.add(gates.CZ(1, 2))
+
+        if circuit2:
+            nqubits = 5
+            target = Circuit(nqubits)
+            target.add(gates.H(qubit) for qubit in range(nqubits))
+            target.add(gates.CZ(0, 1))
+            target.add(gates.CZ(0, 4))
+            target.add(gates.CZ(1, 2))
+            target.add(gates.CZ(2, 3))
+            target.add(gates.CZ(3, 4))
+
+        circuit = graph_state(matrix)
+        backend.assert_circuitclose(circuit, target)