added tensor_up feature

referenceqvm/tests/test_unitary_generator.py

@@ -1,11 +1,14 @@
 import pytest
+import warnings
 import numpy as np
-from referenceqvm.unitary_generator import lifted_gate, apply_gate, tensor_gates
+from referenceqvm.unitary_generator import (lifted_gate, apply_gate,
+                                            tensor_gates, tensor_up)
 from referenceqvm.gates import gate_matrix, utility_gates
 from pyquil.quil import Program
 from pyquil.gates import H as Hgate
 from pyquil.gates import RX as RXgate
 from pyquil.gates import CNOT as CNOTgate
+from pyquil.paulis import PauliTerm, PauliSum
 
 
 def test_lifted_swap():
@@ -208,3 +211,38 @@ def test_tensor_gates_two_qubit():
     test_unitary = tensor_gates(gate_matrix, {}, prog.actions[0][1], 4).toarray()
     true_unitary = apply_gate(gate_matrix['CNOT'], [1, 3], 4).toarray()
     assert np.allclose(test_unitary, true_unitary)
+
+
+def test_tensor_up_error_catch():
+    """Testing tensor up type checking"""
+    x_term = PauliTerm("X", 5)
+
+    # testing type rejection
+    with pytest.raises(TypeError):
+        tensor_up(x_term, 5)
+
+    # testing index rejection
+    with pytest.raises(IndexError):
+        tensor_up(PauliSum([x_term]), 3)
+
+
+def test_tensor_up_correctness():
+    """Check the correctness of the tensor up routine"""
+    xy_term = PauliSum([PauliTerm("X", 0)*PauliTerm("Y", 1)])
+
+    # test correctness
+    trial_matrix = tensor_up(xy_term, 2)
+    true_matrix = np.kron(gate_matrix['Y'], gate_matrix['X'])
+    np.testing.assert_allclose(trial_matrix, true_matrix)
+
+    x1_term = PauliSum([PauliTerm("X", 1)])
+    trial_matrix = tensor_up(x1_term, 2)
+    true_matrix = np.kron(gate_matrix['X'], gate_matrix['I'])
+    np.testing.assert_allclose(trial_matrix, true_matrix)
+
+    zpz_term = PauliTerm("Z", 0) + PauliTerm("Z", 1)
+    trial_matrix = tensor_up(zpz_term, 2)
+    true_matrix = np.zeros((4, 4))
+    true_matrix[0, 0] = 2
+    true_matrix[-1, -1] = -2
+    np.testing.assert_allclose(trial_matrix, true_matrix)

referenceqvm/unitary_generator.py

@@ -21,9 +21,11 @@
 Note: uses SciPy sparse diagonal (DIA) representation to increase space and
 timeefficiency.
 """
+import warnings
 import scipy.sparse as sps
 from referenceqvm.gates import gate_matrix
 from pyquil.quilbase import *
+from pyquil.paulis import PauliSum
 
 """
 If True, only physically-implementable operations allowed!
@@ -355,6 +357,51 @@ def tensor_gates(gate_set, defgate_set, pyquil_gate, num_qubits):
     return gate
 
 
+def tensor_up(pauli_terms, num_qubits):
+    """
+    Takes a PauliSum object along with a total number of
+    qubits and returns a matrix corresponding the tensor representation of the
+    object.
+
+    Useful for generating the full Hamiltonian after a particular fermion to
+    pauli transformation. For example:
+
+    Converting a PauliSum X0Y1 + Y1X0 into the matrix
+
+    .. code-block:: python
+
+       [[ 0.+0.j,  0.+0.j,  0.+0.j,  0.-2.j],
+       [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
+       [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
+       [ 0.+2.j,  0.+0.j,  0.+0.j,  0.+0.j]]
+
+
+    :param pauli_terms: (PauliSum) object of PauliTerm
+    :param num_qubits: (int) number of qubits in the system
+    :returns: (numpy array) representation of the paui_terms operator
+    """
+    if not isinstance(pauli_terms, PauliSum):
+        raise TypeError("can only tensor PauliSum")
+
+    # check if operator is valid w.r.t the input number of qubits
+    for term in pauli_terms.terms:
+        if len(term._ops.keys()) > 0:
+            if max(term._ops.keys()) >= num_qubits:
+                raise IndexError("pauli_terms has higher index than qubits")
+
+    big_hilbert = np.zeros((2 ** num_qubits, 2 ** num_qubits), dtype=complex)
+    # left kronecker product corresponds to the correct basis ordering
+    for term in pauli_terms.terms:
+
+        tmp_big_hilbert = np.array([1])
+        for index in range(num_qubits):
+            tmp_big_hilbert = np.kron(gate_matrix[term[index]], tmp_big_hilbert)
+
+        big_hilbert += tmp_big_hilbert * term.coefficient
+
+    return big_hilbert
+
+
 def value_get(param_obj):
     """
     Function that returns the raw number / string stored in certain pyQuil