tequila-basic 1.9.8__py3-none-any.whl → 1.9.10__py3-none-any.whl

tequila/circuit/circuit.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
-from tequila.circuit._gates_impl import QGateImpl, assign_variable, list_assignment
+from tequila.circuit._gates_impl import QGateImpl, assign_variable, list_assignment, GlobalPhaseGateImpl, PhaseGateImpl
 from tequila.utils.exceptions import TequilaException, TequilaWarning
 from tequila.utils.bitstrings import BitNumbering
 import typing
 import copy
 from collections import defaultdict
+import numpy as np
 import warnings
 
 from .qpic import export_to
 
-class QCircuit():
+
+class QCircuit:
     """
     Fundamental class representing an abstract circuit.
 
@@ -65,7 +67,6 @@ class QCircuit():
             spots = [table[q] for q in qus]
 
             if max(spots) == len(moms):
-
                 moms.append(Moment([g]))
             else:
                 moms[max(spots)].add_gate(g)
@@ -91,8 +92,8 @@ class QCircuit():
         for g in self.gates:
             p = 0
             qus = g.qubits
-            if g.is_parametrized():
-                if hasattr(g.parameter, 'extract_variables'):
+            if g.is_parameterized():
+                if hasattr(g.parameter, "extract_variables"):
                     p = 1
 
             if p == 0:
@@ -149,6 +150,10 @@ class QCircuit():
         else:
             return self._gates
 
+    @gates.setter
+    def gates(self, other):
+        self._gates = list(other)
+
     @property
     def numbering(self) -> BitNumbering:
         return BitNumbering.LSB
@@ -169,9 +174,11 @@ class QCircuit():
         self._min_n_qubits = other
         if other < self.max_qubit() + 1:
             raise TequilaException(
-                "You are trying to set n_qubits to " + str(
-                    other) + " but your circuit needs at least: " + str(
-                    self.max_qubit() + 1))
+                "You are trying to set n_qubits to "
+                + str(other)
+                + " but your circuit needs at least: "
+                + str(self.max_qubit() + 1)
+            )
         return self
 
     def __init__(self, gates=None, parameter_map=None):
@@ -209,7 +216,7 @@ class QCircuit():
         """
         parameter_map = defaultdict(list)
         for idx, gate in enumerate(self.gates):
-            if gate.is_parametrized():
+            if gate.is_parameterized():
                 variables = gate.extract_variables()
                 for variable in variables:
                     parameter_map[variable] += [(idx, gate)]
@@ -254,8 +261,8 @@ class QCircuit():
             the gates to add at the corresponding positions
         replace: list of bool: (Default value: None)
             Default is None which corresponds to all true
-            decide if gates shall be replaces or if the new parts shall be inserted without replacement
-            if replace[i] = true: gate at position [i] will be replaces by gates[i]
+            decide if gates shall be replaced or if the new parts shall be inserted without replacement
+            if replace[i] = true: gate at position [i] will be replaced by gates[i]
             if replace[i] = false: gates[i] circuit will be inserted at position [i] (beaming before gate previously at position [i])
         Returns
         -------
@@ -271,10 +278,10 @@ class QCircuit():
         dataset = zip(positions, circuits, replace)
         dataset = sorted(dataset, key=lambda x: x[0])
 
-        offset = 0
-        new_gatelist = self.gates
-        for idx, circuit, do_replace in dataset:
+        new_gatelist = []
+        last_idx = -1
 
+        for idx, circuit, do_replace in dataset:
             # failsafe
             if hasattr(circuit, "gates"):
                 gatelist = circuit.gates
@@ -283,13 +290,14 @@ class QCircuit():
             else:
                 gatelist = [circuit]
 
-            pos = idx + offset
-            if do_replace:
-                new_gatelist = new_gatelist[:pos] + gatelist + new_gatelist[pos + 1:]
-                offset += len(gatelist) - 1
-            else:
-                new_gatelist = new_gatelist[:pos] + gatelist + new_gatelist[pos:]
-                offset += len(gatelist)
+            new_gatelist += self.gates[last_idx + 1 : idx]
+            new_gatelist += gatelist
+            if not do_replace:
+                new_gatelist.append(self.gates[idx])
+
+            last_idx = idx
+
+        new_gatelist += self.gates[last_idx + 1 :]
 
         result = QCircuit(gates=new_gatelist)
         result.n_qubits = max(result.n_qubits, self.n_qubits)
@@ -344,11 +352,11 @@ class QCircuit():
             whether or not all gates in the circuit are paremtrized
         """
         for gate in self.gates:
-            if not gate.is_parametrized():
+            if not gate.is_parameterized():
                 return False
             else:
-                if hasattr(gate, 'parameter'):
-                    if not hasattr(gate.parameter, 'wrap'):
+                if hasattr(gate, "parameter"):
+                    if not hasattr(gate.parameter, "wrap"):
                         return False
                     else:
                         continue
@@ -364,11 +372,11 @@ class QCircuit():
             whether or not all gates in the circuit are unparametrized
         """
         for gate in self.gates:
-            if not gate.is_parametrized():
+            if not gate.is_parameterized():
                 continue
             else:
-                if hasattr(gate, 'parameter'):
-                    if not hasattr(gate.parameter, 'wrap'):
+                if hasattr(gate, "parameter"):
+                    if not hasattr(gate.parameter, "wrap"):
                         continue
                     else:
                         return False
@@ -386,7 +394,7 @@ class QCircuit():
         for k, v in other._parameter_map.items():
             self._parameter_map[k] += [(x[0] + offset, x[1]) for x in v]
 
-        self._gates += copy.deepcopy(other.gates)
+        self._gates += other.gates
         self._min_n_qubits = max(self._min_n_qubits, other._min_n_qubits)
 
         return self
@@ -438,6 +446,76 @@ class QCircuit():
         else:
             return QCircuit(gates=[gate])
 
+    def to_matrix(self, variables=None):
+        """
+        take the circuit and return the unitary matrix corresponding to it.
+        Parameters
+        ----------
+        variables: dict:
+            (Default value = None)
+            a dictionary mapping variable names to values. If None, the circuit must not contain any variables.
+            If the circuit contains variables, they must be provided here.
+
+        Returns
+        -------
+        np.ndarray:
+            the unitary matrix corresponding to the circuit.
+        """
+        import quimb.gates
+        import quimb.tensor as qtn
+        from tequila import compile_circuit
+
+        num_variables = len(self.extract_variables())
+
+        if num_variables == 0:
+            variables = {}
+        elif variables is None:
+            raise TequilaException(
+                f"QCircuit.to_matrix(): no variables provided, but the circuit has {num_variables} variables"
+            )
+
+        compiled_circuit = compile_circuit(
+            self,
+        )
+        compiled_circuit = compiled_circuit.map_variables(variables)
+
+        gate_mapping = {"Rx": "RX", "Ry": "RY", "Rz": "RZ", "H": "H", "X": "X"}
+
+        quimb_circuit = qtn.Circuit(self.n_qubits)
+
+        # quimb uses MSB convention, so we need to modify the qubit indices
+        # to LSB
+        for g in compiled_circuit.gates:
+            if g.name not in gate_mapping:
+                raise TequilaException(
+                    f"Gate {g.name} is not supported for conversion to matrix. "
+                    f"Supported gates: {list(gate_mapping.keys())}"
+                )
+
+            if g.is_parameterized():
+                quimb_circuit.apply_gate(
+                    gate_mapping[g.name],
+                    params=[float(g.parameter())],
+                    qubits=[abs(t - self.n_qubits + 1) for t in list(g.target)],
+                    parameterize=True,
+                )
+            elif g.is_controlled():
+                quimb_circuit.apply_gate(
+                    gate_mapping[g.name],
+                    qubits=[abs(t - self.n_qubits + 1) for t in list(g.target)],
+                    controls=[abs(c - self.n_qubits + 1) for c in list(g.control)],
+                )
+            else:
+                quimb_circuit.apply_gate(
+                    gate_mapping[g.name],
+                    qubits=[abs(t - self.n_qubits + 1) for t in list(g.target)],
+                )
+
+        uni = quimb_circuit.get_uni()
+        unitary = np.array(uni.to_dense())
+
+        return unitary
+
     def to_networkx(self):
         """
         Turn a given quantum circuit from tequila into graph form via NetworkX
@@ -446,6 +524,7 @@ class QCircuit():
         """
         # avoiding dependcies (only used here so far)
         import networkx as nx
+
         G = nx.Graph()
         for q in self.qubits:
             G.add_node(q)
@@ -454,20 +533,20 @@ class QCircuit():
             if gate.control:
                 for s in gate.control:
                     for t in gate.target:
-                        tstr = ''
+                        tstr = ""
                         tstr += str(t)
                         target = int(tstr)
                         Gdict[s].append(target)  # add target to key of correlated controls
                 for p in gate.target:
                     for r in gate.control:
-                        cstr = ''
+                        cstr = ""
                         cstr += str(r)
                         control = int(cstr)
                         Gdict[p].append(control)  # add control to key of correlated targets
             else:
                 for s in gate.target:
                     for t in gate.target:
-                        tstr2 = ''
+                        tstr2 = ""
                         tstr2 += str(t)
                         target2 = int(tstr2)
                         Gdict[s].append(target2)
@@ -476,8 +555,9 @@ class QCircuit():
             for q in b:
                 lConn.append((a, q))
         G.add_edges_from(lConn)
-        GPaths = list(nx.connected_components(
-            G))  # connections of various qubits, excluding repetitions (ex- (1,3) instead of (1,3) and (3,1))
+        GPaths = list(
+            nx.connected_components(G)
+        )  # connections of various qubits, excluding repetitions (ex- (1,3) instead of (1,3) and (3,1))
         GIso = [g for g in GPaths if len(g) == 1]  # list of Isolated qubits
         return G
 
@@ -508,7 +588,10 @@ class QCircuit():
             whether or not the circuit is properly constructed.
 
         """
-        for k, v, in self._parameter_map.items():
+        for (
+            k,
+            v,
+        ) in self._parameter_map.items():
             test = [self.gates[x[0]] == x[1] for x in v]
             test += [k in self._gates[x[0]].extract_variables() for x in v]
         return all(test)
@@ -533,8 +616,7 @@ class QCircuit():
         # currently its recreated in the init function
         return QCircuit(gates=new_gates)
 
-    def add_controls(self, control, inpl: typing.Optional[bool] = False) \
-            -> typing.Optional[QCircuit]:
+    def add_controls(self, control, inpl: typing.Optional[bool] = False) -> typing.Optional[QCircuit]:
         """Depending on the truth value of inpl:
             - return controlled version of self with control as the control qubits if inpl;
             - mutate self so that the qubits in control are added as the control qubits if not inpl.
@@ -570,8 +652,9 @@ class QCircuit():
                 if len(control_lst) < len(gate.control) + len(control):
                     # warnings.warn("Some of the controls {} were already included in the control "
                     #               "of a gate {}.".format(control, gate), TequilaWarning)
-                    raise TequilaWarning(f'Some of the controls {control} were already included '
-                                         f'in the control of a gate {gate}.')
+                    raise TequilaWarning(
+                        f"Some of the controls {control} were already included in the control of a gate {gate}."
+                    )
             else:
                 control_lst, not_control = list(control), list()
 
@@ -579,8 +662,9 @@ class QCircuit():
             if any(qubit in control for qubit in not_control):
                 # warnings.warn("The target and control {} were the same qubit for a gate {}."
                 #               .format(control, gate), TequilaWarning)
-                raise TequilaWarning(f'The target for a gate {gate} '
-                                     f'and the control list {control_lst} had a common qubit.')
+                raise TequilaWarning(
+                    f"The target for a gate {gate} and the control list {control_lst} had a common qubit."
+                )
 
             cgate._control = tuple(control_lst)
             cgate.finalize()
@@ -593,25 +677,33 @@ class QCircuit():
 
         This is an in-place method, so it mutates self and doesn't return any value.
 
-        Raise TequilaWarning if there any qubits in common between self and control.
+        Raise TequilaWarning if there are any qubits in common between self and control.
         """
         gates = self.gates
         control = list_assignment(control)
 
-        for gate in gates:
-            if gate.is_controlled():
+        for i, gate in enumerate(gates):
+            if isinstance(gate, GlobalPhaseGateImpl):
+                gate = PhaseGateImpl(phase=gate.parameter, target=control[0])
+                gates[i] = gate
+                not_control = []
+                control_lst = list(control[1:])
+            elif gate.is_controlled():
                 control_lst = list(set(list(gate.control) + list(control)))
 
                 # Need to check duplicates
-                not_control = list(set(qubit for qubit in list(gate.qubits)
-                                       if qubit not in list(gate.control)))
+                not_control = list(set(qubit for qubit in list(gate.qubits) if qubit not in list(gate.control)))
 
                 # Raise TequilaWarning if control qubit is duplicated
                 if len(control_lst) < len(gate.control) + len(control):
                     # warnings.warn("Some of the controls {} were already included in the control "
                     #               "of a gate {}.".format(control, gate), TequilaWarning)
-                    raise TequilaWarning(f'Some of the controls {control} were already included '
-                                         f'in the control of a gate {gate}.')
+                    raise TequilaWarning(
+                        f"Some of the controls {control} were already included "
+                        f"in the control of a gate {gate}. "
+                        f"This might be because the same instance of a gate is used in multiple places, "
+                        f"e.g. because the same circuit was appended twice."
+                    )
             else:
                 control_lst, not_control = list(control), list()
 
@@ -619,8 +711,7 @@ class QCircuit():
             if any(qubit in control for qubit in not_control):
                 # warnings.warn("The target and control {} were the same qubit for a gate {}."
                 #               .format(control, gate), TequilaWarning)
-                raise TequilaWarning(f'The target for a gate {gate} '
-                                     f'and the control list {control} had a common qubit.')
+                raise TequilaWarning(f"The target for a gate {gate} and the control list {control} had a common qubit.")
 
             gate._control = tuple(control_lst)
             gate.finalize()
@@ -645,9 +736,9 @@ class QCircuit():
         for k, v in variables.items():
             if k not in my_variables:
                 warnings.warn(
-                    "map_variables: variable {} is not part of circuit with variables {}".format(k,
-                                                                                                 my_variables),
-                    TequilaWarning)
+                    "map_variables: variable {} is not part of circuit with variables {}".format(k, my_variables),
+                    TequilaWarning,
+                )
 
         new_gates = [copy.deepcopy(gate).map_variables(variables) for gate in self.gates]
 
@@ -683,11 +774,11 @@ class Moment(QCircuit):
         mu = []
         mp = []
         for gate in self.gates:
-            if not gate.is_parametrized():
+            if not gate.is_parameterized():
                 mu.append(gate)
             else:
-                if hasattr(gate, 'parameter'):
-                    if not hasattr(gate.parameter, 'wrap'):
+                if hasattr(gate, "parameter"):
+                    if not hasattr(gate.parameter, "wrap"):
                         mu.append(gate)
                     else:
                         mp.append(gate)
@@ -720,8 +811,8 @@ class Moment(QCircuit):
                 for q in g.qubits:
                     if q in occ:
                         raise TequilaException(
-                            'cannot have doubly occupied qubits, which occurred at qubit {}'.format(
-                                str(q)))
+                            "cannot have doubly occupied qubits, which occurred at qubit {}".format(str(q))
+                        )
                     else:
                         occ.append(q)
         if sort:
@@ -782,8 +873,7 @@ class Moment(QCircuit):
                 if q not in first_overlap:
                     first_overlap.append(q)
                 else:
-                    raise TequilaException(
-                        'cannot have a moment with multiple operations acting on the same qubit!')
+                    raise TequilaException("cannot have a moment with multiple operations acting on the same qubit!")
 
         new = self.with_gate(gl[0])
         for g in gl[1:]:
@@ -810,8 +900,8 @@ class Moment(QCircuit):
         for n in newq:
             if n in prev:
                 raise TequilaException(
-                    'cannot add gate {} to moment; qubit {} already occupied.'.format(str(gate),
-                                                                                      str(n)))
+                    "cannot add gate {} to moment; qubit {} already occupied.".format(str(gate), str(n))
+                )
 
         self._gates.append(gate)
         self.sort_gates()
@@ -832,17 +922,17 @@ class Moment(QCircuit):
         QCircuit or Moment:
             self, with unwanted gate removed and new gates inserted. May not be a moment.
         """
-        if hasattr(gates, '__iter__'):
+        if hasattr(gates, "__iter__"):
             gs = gates
         else:
             gs = [gates]
 
         new = self.gates[:position]
         new.extend(gs)
-        new.extend(self.gates[(position + 1):])
+        new.extend(self.gates[(position + 1) :])
         try:
             return Moment(gates=new)
-        except:
+        except Exception:
             return QCircuit(gates=new)
 
     def as_circuit(self):
@@ -864,11 +954,11 @@ class Moment(QCircuit):
             whether or not EVERY gate in self.gates is parameterized.
         """
         for gate in self.gates:
-            if not gate.is_parametrized():
+            if not gate.is_parameterized():
                 return False
             else:
-                if hasattr(gate, 'parameter'):
-                    if not hasattr(gate.parameter, 'wrap'):
+                if hasattr(gate, "parameter"):
+                    if not hasattr(gate.parameter, "wrap"):
                         return False
                     else:
                         continue
@@ -883,7 +973,6 @@ class Moment(QCircuit):
         return result
 
     def __iadd__(self, other):
-
         new = self.as_circuit()
         if isinstance(other, QGateImpl):
             other = new.wrap_gate(other)
@@ -918,24 +1007,24 @@ class Moment(QCircuit):
                 try:
                     result = self.add_gate(other.gates[0])
                     result._min_n_qubits += len(other.qubits)
-                except:
+                except Exception:
                     result = self.as_circuit() + QCircuit.wrap_gate(other)
-                    result._min_n_qubits = max(self.as_circuit()._min_n_qubits,
-                                               QCircuit.wrap_gate(other)._min_n_qubits)
+                    result._min_n_qubits = max(self.as_circuit()._min_n_qubits, QCircuit.wrap_gate(other)._min_n_qubits)
 
         else:
             if isinstance(other, QGateImpl):
                 try:
                     result = self.add_gate(other)
                     result._min_n_qubits += len(other.qubits)
-                except:
+                except Exception:
                     result = self.as_circuit() + QCircuit.wrap_gate(other)
-                    result._min_n_qubits = max(self.as_circuit()._min_n_qubits,
-                                               QCircuit.wrap_gate(other)._min_n_qubits)
+                    result._min_n_qubits = max(self.as_circuit()._min_n_qubits, QCircuit.wrap_gate(other)._min_n_qubits)
             else:
                 raise TequilaException(
-                    'cannot add moments to types other than QCircuit,Moment,or Gate; recieved summand of type {}'.format(
-                        str(type(other))))
+                    "cannot add moments to types other than QCircuit,Moment,or Gate; recieved summand of type {}".format(
+                        str(type(other))
+                    )
+                )
         return result
 
     @staticmethod
@@ -964,36 +1053,36 @@ class Moment(QCircuit):
         TequilaException
         """
         raise TequilaException(
-            'this method should never be called from Moment. Call from the QCircuit class itself instead.')
-
+            "this method should never be called from Moment. Call from the QCircuit class itself instead."
+        )
 
 
-def find_unused_qubit(U0: QCircuit = None, U1: QCircuit = None)->int:
-    '''
-    Function that checks which are the active qubits of two circuits and 
+def find_unused_qubit(U0: QCircuit = None, U1: QCircuit = None) -> int:
+    """
+    Function that checks which are the active qubits of two circuits and
     provides an unused qubit that is not among them. If all qubits are used
     it adds a new one.
 
     Parameters
     ----------
     U0 : QCircuit, corresponding to the first state.
-        
+
     U1 : QCircuit, corresponding to the second state.
 
     Returns
     -------
     control_qubit : int
-        
-    '''
-    
-    active_qubits = list(set(U0.qubits+U1.qubits))
+
+    """
+
+    active_qubits = list(set(U0.qubits + U1.qubits))
     # default
     free_qubit = max(active_qubits) + 1
     # see if we can use another one
-    for n in range(max(active_qubits)+1):
+    for n in range(max(active_qubits) + 1):
         if n not in active_qubits:
             free_qubit = n
             break
     assert free_qubit not in active_qubits
-    
+
     return free_qubit