allow various parameterexpressions

Author: king-p3nguin

requirements/requirements-extra.txt

@@ -1,7 +1,7 @@
 # extra dependencies for ci
 qiskit<1.0
-qiskit_aer<1.0
-# qiskit-nature
+qiskit-aer<1.0
+qiskit-nature
 mitiq
 cirq
 torch

tensorcircuit/abstractcircuit.py

@@ -4,21 +4,21 @@
 
 # pylint: disable=invalid-name
 
-from typing import Any, Callable, Dict, List, Optional, Sequence, Union, Tuple
+import json
+import logging
 from copy import deepcopy
 from functools import reduce
 from operator import add
-import json
-import logging
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import tensornetwork as tn
 
 from . import gates
 from .cons import backend, dtypestr
-from .vis import qir2tex
 from .quantum import QuOperator
 from .utils import is_sequence
+from .vis import qir2tex
 
 logger = logging.getLogger(__name__)
 
@@ -756,7 +756,7 @@ def to_qiskit(
         :type enable_inputs: bool, defaults to False
         :return: A qiskit object of this circuit.
         """
-        from .translation import qir2qiskit, perm_matrix
+        from .translation import perm_matrix, qir2qiskit
 
         qir = self.to_qir()
         if enable_instruction:
@@ -887,7 +887,7 @@ def from_qiskit(
             n = qc.num_qubits
 
         return qiskit2tc(  # type: ignore
-            qc.data,
+            qc,
             n,
             inputs,
             circuit_constructor=cls,

tensorcircuit/translation.py

@@ -2,23 +2,26 @@
 Circuit object translation in different packages
 """
 
-from typing import Any, Dict, List, Optional, Tuple, Union, Sequence
-from copy import deepcopy
 import logging
+from copy import deepcopy
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
 import numpy as np
 
 logger = logging.getLogger(__name__)
 
 
 try:
+    import qiskit.quantum_info as qi
+    import symengine
+    import sympy
     from qiskit import QuantumCircuit
+    from qiskit.circuit import Parameter, ParameterExpression
     from qiskit.circuit.library import XXPlusYYGate
+    from qiskit.circuit.parametervector import ParameterVectorElement
+    from qiskit.circuit.quantumcircuitdata import CircuitInstruction
     from qiskit.extensions import UnitaryGate
-    import qiskit.quantum_info as qi
     from qiskit.extensions.exceptions import ExtensionError
-    from qiskit.circuit.quantumcircuitdata import CircuitInstruction
-    from qiskit.circuit.parametervector import ParameterVectorElement
-    from qiskit.circuit import Parameter, ParameterExpression
 except ImportError:
     logger.warning(
         "Please first ``pip install -U qiskit`` to enable related functionality in translation module"
@@ -34,11 +37,10 @@
 
 from . import gates
 from .circuit import Circuit
-from .densitymatrix import DMCircuit2
 from .cons import backend
+from .densitymatrix import DMCircuit2
 from .interfaces.tensortrans import tensor_to_numpy
 
-
 Tensor = Any
 
 
@@ -358,7 +360,7 @@ def _translate_qiskit_params(
     gate_info: CircuitInstruction, binding_params: Any
 ) -> List[float]:
     parameters = []
-    for p in gate_info[0].params:
+    for p in gate_info.operation.params:
         if isinstance(p, ParameterVectorElement):
             parameters.append(binding_params[p.index])
         elif isinstance(p, Parameter):
@@ -367,30 +369,29 @@ def _translate_qiskit_params(
             if len(p.parameters) == 0:
                 parameters.append(float(p))
                 continue
-            if len(p.parameters) != 1:
-                raise ValueError(
-                    f"Can't translate parameter expression with more than 1 parameters: {p}"
-                )
-            p_real = list(p.parameters)[0]
-            if not isinstance(p_real, ParameterVectorElement):
-                raise TypeError(
-                    "Parameters in parameter expression should be ParameterVectorElement"
-                )
+
             # note "sym" != "sim"
             expr = p.sympify().simplify()
-            # only allow simple expressions like 1.0 * theta
-            if not expr.is_Mul:
-                raise ValueError(f"Unsupported parameter expression: {p}")
-            arg1, arg2 = expr.args
-            if arg1.is_number and arg2.is_symbol:
-                coeff = arg1
-            elif arg1.is_symbol and arg2.is_number:
-                coeff = arg2
-            else:
-                raise ValueError(f"Unsupported parameter expression: {p}")
-            # taking real part here because using complex type will result in a type error
-            # for tf backend when the binding parameter is real
-            parameters.append(float(coeff) * binding_params[p_real.index])
+            if isinstance(expr, symengine.Expr):  # qiskit uses symengine if available
+                expr = expr._sympy_()  # sympy.Expr
+
+            for free_symbol in expr.free_symbols:
+                # replace names: theta[0] -> theta_0
+                # ParameterVector creates symbols with brackets like theta[0]
+                # but sympy.lambdify does not allow brackets in symbol names
+                free_symbol.name = free_symbol.name.replace("[", "_").replace("]", "")
+
+            parameter_list = list(p.parameters)
+            sympy_symbols = [param._symbol_expr for param in parameter_list]
+            # replace names again: theta[0] -> theta_0
+            sympy_symbols = [
+                sympy.Symbol(str(symbol).replace("[", "_").replace("]", ""))
+                for symbol in sympy_symbols
+            ]
+            lam_f = sympy.lambdify(sympy_symbols, expr, modules=backend.name)
+            parameters.append(
+                lam_f(*[binding_params[param.index] for param in parameter_list])
+            )
         else:
             # numbers, arrays, etc.
             parameters.append(p)
@@ -403,7 +404,7 @@ def ctrl_str2ctrl_state(ctrl_str: str, nctrl: int) -> List[int]:
 
 
 def qiskit2tc(
-    qcdata: List[CircuitInstruction],
+    qc: QuantumCircuit,
     n: int,
     inputs: Optional[List[float]] = None,
     is_dm: bool = False,
@@ -412,19 +413,18 @@ def qiskit2tc(
     binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] = None,
 ) -> Any:
     r"""
-    Generate a tensorcircuit circuit using the quantum circuit data in qiskit.
+    Generate a tensorcircuit circuit from the qiskit circuit.
 
     :Example:
 
     >>> qisc = QuantumCircuit(2)
     >>> qisc.h(0)
     >>> qisc.x(1)
-    >>> qc = tc.translation.qiskit2tc(qisc.data, 2)
+    >>> qc = tc.translation.qiskit2tc(qisc, 2)
     >>> qc.to_qir()[0]['gatef']
-    h
 
-    :param qcdata: Quantum circuit data from qiskit.
-    :type qcdata: List[CircuitInstruction]
+    :param qc: A quantum circuit in qiskit.
+    :type qc: QuantumCircuit
     :param n: # of qubits
     :type n: int
     :param inputs: Input state of the circuit. Default is None.
@@ -435,7 +435,7 @@ def qiskit2tc(
     :type circuit_params: Optional[Dict[str, Any]]
     :param binding_params: (variational) parameters for the circuit.
         Could be either a sequence or dictionary depending on the type of parameters in the Qiskit circuit.
-        For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary
+        For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary.
     :type binding_params: Optional[Union[Sequence[float], Dict[Any, float]]]
     :return: A quantum circuit in tensorcircuit
     :rtype: Any
@@ -451,17 +451,17 @@ def qiskit2tc(
     if "nqubits" not in circuit_params:
         circuit_params["nqubits"] = n
     if (
-        len(qcdata) > 0
-        and qcdata[0][0].name == "initialize"
+        len(qc.data) > 0
+        and qc.data[0][0].name == "initialize"
         and "inputs" not in circuit_params
     ):
-        circuit_params["inputs"] = perm_matrix(n) @ np.array(qcdata[0][0].params)
+        circuit_params["inputs"] = perm_matrix(n) @ np.array(qc.data[0][0].params)
     if inputs is not None:
         circuit_params["inputs"] = inputs
 
     tc_circuit: Any = Circ(**circuit_params)
-    for gate_info in qcdata:
-        idx = [qb.index for qb in gate_info[1]]
+    for gate_info in qc.data:
+        idx = [qc.find_bit(qb).index for qb in gate_info.qubits]
         gate_name = gate_info[0].name
         parameters = _translate_qiskit_params(gate_info, binding_params)
         if gate_name in [

tests/test_circuit.py

@@ -1,8 +1,9 @@
 # pylint: disable=invalid-name
 
-import sys
 import os
+import sys
 from functools import partial
+
 import numpy as np
 import opt_einsum as oem
 import pytest
@@ -975,6 +976,7 @@ def test_qir2cirq(backend):
 def test_qir2qiskit(backend):
     try:
         import qiskit.quantum_info as qi
+
         from tensorcircuit.translation import perm_matrix
     except ImportError:
         pytest.skip("qiskit is not installed")
@@ -1074,9 +1076,10 @@ def test_qir2qiskit(backend):
 
 def test_qiskit2tc():
     try:
-        from qiskit import QuantumCircuit
         import qiskit.quantum_info as qi
+        from qiskit import QuantumCircuit
         from qiskit.circuit.library.standard_gates import MCXGate, SwapGate
+
         from tensorcircuit.translation import perm_matrix
     except ImportError:
         pytest.skip("qiskit is not installed")
@@ -1149,26 +1152,34 @@ def test_qiskit2tc():
 @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")])
 def test_qiskit2tc_parameterized(backend):
     try:
-        from qiskit.circuit import QuantumCircuit, Parameter
-        from qiskit.quantum_info import Operator
+        from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
         from qiskit.circuit.library import TwoLocal
+        from qiskit.quantum_info import Operator
         from qiskit_nature.second_q.circuit.library import UCCSD
-        from qiskit_nature.second_q.mappers import ParityMapper, QubitConverter
+        from qiskit_nature.second_q.mappers import ParityMapper
     except ImportError:
         pytest.skip("qiskit or qiskit-nature is not installed")
     from tensorcircuit.translation import perm_matrix
 
     mapper = ParityMapper()
-    converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
-    ansatz1 = UCCSD(2, [1, 1], converter)
+    ansatz1 = UCCSD(2, [1, 1], mapper)
     ansatz2 = TwoLocal(2, rotation_blocks="ry", entanglement_blocks="cz")
     ansatz3 = QuantumCircuit(1)
     ansatz3_param = Parameter("θ")
     ansatz3.rx(ansatz3_param, 0)
-    ansatz_list = [ansatz1, ansatz2, ansatz3]
+    ansatz4 = QuantumCircuit(1)
+    ansatz4_param = ParameterVector("φ", 3)
+    ansatz4.rx(2.0 * ansatz4_param[0] + 5.0, 0)
+    ansatz4.ry(ansatz4_param[0] * ansatz4_param[1] + ansatz4_param[2], 0)
+    ansatz4.rz(
+        np.exp(np.sin(ansatz4_param[0]))
+        + np.abs(ansatz4_param[1]) / np.arctan(ansatz4_param[2]),
+        0,
+    )
+    ansatz_list = [ansatz1, ansatz2, ansatz3, ansatz4]
     for ansatz in ansatz_list:
         n = ansatz.num_qubits
-        if ansatz in [ansatz1, ansatz2]:
+        if ansatz in [ansatz1, ansatz2, ansatz4]:
             params = np.random.rand(ansatz.num_parameters)
         else:
             params = {ansatz3_param: 0.618}
@@ -1178,9 +1189,9 @@ def test_qiskit2tc_parameterized(backend):
 
         # test jit
         @tc.backend.jit
-        def get_unitary(_params):
+        def get_unitary(params):
             return tc.Circuit.from_qiskit(
-                ansatz, inputs=np.eye(2**n), binding_params=_params
+                ansatz, inputs=np.eye(2**n), binding_params=params
             ).state()
 
         tc_unitary = get_unitary(params)
@@ -1191,10 +1202,10 @@ def get_unitary(_params):
         )
 
         # test grad
-        def cost_fn(_params):
-            return tc.backend.real(tc.backend.sum(get_unitary(_params)))
+        def cost_fn(params):
+            return tc.backend.real(tc.backend.sum(get_unitary(params)))
 
-        if ansatz in [ansatz1, ansatz2]:
+        if ansatz in [ansatz1, ansatz2, ansatz4]:
             grad = tc.backend.grad(cost_fn)(tc.backend.convert_to_tensor(params))
             assert np.sum(np.isnan(grad)) == 0
         else:
@@ -1208,8 +1219,8 @@ def cost_fn(_params):
 @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")])
 def test_qiskit_vs_tc_intialization(backend):
     try:
-        from qiskit import QuantumCircuit
         import qiskit.quantum_info as qi
+        from qiskit import QuantumCircuit
     except ImportError:
         pytest.skip("qiskit is not installed")