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

tequila/simulators/simulator_pyquil.py

@@ -8,84 +8,91 @@ from pyquil.noise import combine_kraus_maps
 from tequila.utils import to_float
 
 name_dict = {
-    'I': 'I',
-    'ry': 'parametrized',
-    'rx': 'parametrized',
-    'rz': 'parametrized',
-    'Rz': 'parametrized',
-    'Ry': 'parametrized',
-    'Rx': 'parametrized',
-    'RZ': 'parametrized',
-    'RY': 'parametrized',
-    'RX': 'parametrized',
-    'r': 'parametrized',
-    'X': 'X',
-    'x': 'X',
-    'Y': 'Y',
-    'y': 'Y',
-    'Z': 'Z',
-    'z': 'Z',
-    'Cz': 'control',
-    'CZ': 'control',
-    'cz': 'control',
-    'SWAP': 'control',
-    'CX': 'control',
-    'Cx': 'control',
-    'cx': 'control',
-    'CNOT': 'control',
-    'ccx': 'multicontrol',
-    'CCx': 'multicontrol',
-    'CSWAP': 'multicontrol',
-    'H': 'H',
-    'h': 'H',
-    'Phase': 'parametrized',
-    'PHASE': 'parametrized'
+    "I": "I",
+    "ry": "parametrized",
+    "rx": "parametrized",
+    "rz": "parametrized",
+    "Rz": "parametrized",
+    "Ry": "parametrized",
+    "Rx": "parametrized",
+    "RZ": "parametrized",
+    "RY": "parametrized",
+    "RX": "parametrized",
+    "r": "parametrized",
+    "X": "X",
+    "x": "X",
+    "Y": "Y",
+    "y": "Y",
+    "Z": "Z",
+    "z": "Z",
+    "Cz": "control",
+    "CZ": "control",
+    "cz": "control",
+    "SWAP": "control",
+    "CX": "control",
+    "Cx": "control",
+    "cx": "control",
+    "CNOT": "control",
+    "ccx": "multicontrol",
+    "CCx": "multicontrol",
+    "CSWAP": "multicontrol",
+    "H": "H",
+    "h": "H",
+    "Phase": "parametrized",
+    "PHASE": "parametrized",
 }
 
 gate_qubit_lookup = {
-    'X': 1,
-    'Y': 1,
-    'Z': 1,
-    'H': 1,
-    'RX': 1,
-    'RY': 1,
-    'RZ': 1,
-    'CX': 2,
-    'CY': 2,
-    'CZ': 2,
-    'CH': 2,
-    'CRX': 2,
-    'CRY': 2,
-    'CRZ': 2,
-    'CNOT': 2,
-    'CCNOT': 3
+    "X": 1,
+    "Y": 1,
+    "Z": 1,
+    "H": 1,
+    "RX": 1,
+    "RY": 1,
+    "RZ": 1,
+    "CX": 2,
+    "CY": 2,
+    "CZ": 2,
+    "CH": 2,
+    "CRX": 2,
+    "CRY": 2,
+    "CRZ": 2,
+    "CNOT": 2,
+    "CCNOT": 3,
 }
 
 name_unitary_dict = {
-    'I': np.eye(2),
-    'X': np.array([[0., 1.], [1., 0.]]),
-    'Y': np.array([[0., -1.j], [1.j, 0.]]),
-    'Z': np.array([[1., 0.], [0., -1.]]),
-    'H': np.array([[1 / np.sqrt(2), 1 / np.sqrt(2)], [1 / np.sqrt(2), -1 / np.sqrt(2)]]),
-    'CNOT': np.array([[1., 0., 0., 0.],
-                      [0., 1., 0., 0., ],
-                      [0., 0., 0., 1.],
-                      [0., 0., 1.0, 0.]
-                      ]),
-    'SWAP': np.array([[1., 0., 0., 0.],
-                      [0., 0., 1., 0.],
-                      [0., 1., 0., 0.],
-                      [0., 0., 0., 1.]
-                      ]),
-    'CCNOT': np.array([[1., 0., 0., 0., 0., 0., 0., 0.],
-                       [0., 1., 0., 0., 0., 0., 0., 0.],
-                       [0., 0., 1., 0., 0., 0., 0., 0.],
-                       [0., 0., 0., 1., 0., 0., 0., 0.],
-                       [0., 0., 0., 0., 1., 0., 0., 0.],
-                       [0., 0., 0., 0., 0., 1., 0., 0.],
-                       [0., 0., 0., 0., 0., 0., 0., 1.],
-                       [0., 0., 0., 0., 0., 0., 1., 0.]
-                       ]),
+    "I": np.eye(2),
+    "X": np.array([[0.0, 1.0], [1.0, 0.0]]),
+    "Y": np.array([[0.0, -1.0j], [1.0j, 0.0]]),
+    "Z": np.array([[1.0, 0.0], [0.0, -1.0]]),
+    "H": np.array([[1 / np.sqrt(2), 1 / np.sqrt(2)], [1 / np.sqrt(2), -1 / np.sqrt(2)]]),
+    "CNOT": np.array(
+        [
+            [1.0, 0.0, 0.0, 0.0],
+            [
+                0.0,
+                1.0,
+                0.0,
+                0.0,
+            ],
+            [0.0, 0.0, 0.0, 1.0],
+            [0.0, 0.0, 1.0, 0.0],
+        ]
+    ),
+    "SWAP": np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]]),
+    "CCNOT": np.array(
+        [
+            [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+        ]
+    ),
 }
 
 
@@ -98,8 +105,7 @@ def amp_damp_map(p):
     :return: A list [k1, k2] of the Kraus operators that parametrize the map.
     :rtype: list
     """
-    damping_op = np.sqrt(p) * np.array([[0, 1],
-                                        [0, 0]])
+    damping_op = np.sqrt(p) * np.array([[0, 1], [0, 0]])
 
     residual_kraus = np.diag([1, np.sqrt(1 - p)])
     return [residual_kraus, damping_op]
@@ -199,7 +205,7 @@ def depolarizing_map(p):
     mat1 = np.array([[np.sqrt(1 - 3 * p / 4), 0], [0, np.sqrt(1 - 3 * p / 4)]])
     mat2 = np.array([[np.sqrt(p / 4), 0], [0, -np.sqrt(p / 4)]])
     mat3 = np.array([[0, np.sqrt(p / 4)], [np.sqrt(p / 4), 0]])
-    mat4 = np.array([[0., -1.j * np.sqrt(p / 4)], [1.j * np.sqrt(p / 4), .0]])
+    mat4 = np.array([[0.0, -1.0j * np.sqrt(p / 4)], [1.0j * np.sqrt(p / 4), 0.0]])
     return [mat1, mat2, mat3, mat4]
 
 
@@ -225,7 +231,7 @@ def kraus_tensor(klist, n):
     elif n >= 3:
         return [np.kron(k1, k2) for k1 in kraus_tensor(klist, n - 1) for k2 in klist]
     else:
-        raise TequilaPyquilException('wtf, you gave me n={}'.format(str(n)))
+        raise TequilaPyquilException("wtf, you gave me n={}".format(str(n)))
 
 
 def append_kraus_to_gate(kraus_ops, g, level):
@@ -268,8 +274,8 @@ def add_controls(matrix, count):
     controls = count - gc
     if int(controls) == 0:
         return matrix
-    new = np.eye(2 ** count)
-    new[-matrix.shape[0]:, -matrix.shape[0]:] = matrix
+    new = np.eye(2**count)
+    new[-matrix.shape[0] :, -matrix.shape[0] :] = matrix
     return new
 
 
@@ -324,6 +330,7 @@ class BackendCircuitPyquil(BackendCircuit):
         takes in a noise model and a circuit and applies noise to it.
 
     """
+
     compiler_arguments = {
         "trotterized": True,
         "swap": False,
@@ -339,13 +346,12 @@ class BackendCircuitPyquil(BackendCircuit):
         "controlled_phase": False,
         "toffoli": False,
         "phase_to_z": False,
-        "cc_max": False
+        "cc_max": False,
     }
 
     numbering = BitNumbering.LSB
 
-    def __init__(self, abstract_circuit: QCircuit, variables, qubit_map=None, noise=None, device=None, *args,
-                 **kwargs):
+    def __init__(self, abstract_circuit: QCircuit, variables, qubit_map=None, noise=None, device=None, *args, **kwargs):
         """
         Parameters
         ----------
@@ -367,39 +373,47 @@ class BackendCircuitPyquil(BackendCircuit):
         """
 
         self.op_lookup = {
-            'I': (pyquil.gates.I),
-            'X': (pyquil.gates.X, pyquil.gates.CNOT, pyquil.gates.CCNOT),
-            'Y': (pyquil.gates.Y,),
-            'Z': (pyquil.gates.Z, pyquil.gates.CZ),
-            'H': (pyquil.gates.H,),
-            'Rx': pyquil.gates.RX,
-            'Ry': pyquil.gates.RY,
-            'Rz': pyquil.gates.RZ,
-            'Phase': pyquil.gates.PHASE,
-            'SWAP': (pyquil.gates.SWAP, pyquil.gates.CSWAP),
+            "I": (pyquil.gates.I),
+            "X": (pyquil.gates.X, pyquil.gates.CNOT, pyquil.gates.CCNOT),
+            "Y": (pyquil.gates.Y,),
+            "Z": (pyquil.gates.Z, pyquil.gates.CZ),
+            "H": (pyquil.gates.H,),
+            "Rx": pyquil.gates.RX,
+            "Ry": pyquil.gates.RY,
+            "Rz": pyquil.gates.RZ,
+            "Phase": pyquil.gates.PHASE,
+            "SWAP": (pyquil.gates.SWAP, pyquil.gates.CSWAP),
         }
         self.match_par_to_dummy = {}
         self.counter = 0
         if device is not None:
-            self.compiler_arguments['cc_max'] = True
-        super().__init__(abstract_circuit=abstract_circuit, variables=variables, noise=noise, device=device,
-                         qubit_map=qubit_map, *args, **kwargs)
+            self.compiler_arguments["cc_max"] = True
+        super().__init__(
+            abstract_circuit=abstract_circuit,
+            variables=variables,
+            noise=noise,
+            device=device,
+            qubit_map=qubit_map,
+            *args,
+            **kwargs,
+        )
         if self.noise is not None:
             self.noise_lookup = {
-                'amplitude damp': amp_damp_map,
-                'phase damp': phase_damp_map,
-                'bit flip': bit_flip_map,
-                'phase flip': phase_flip_map,
-                'phase-amplitude damp': phase_amp_damp_map,
-                'depolarizing': depolarizing_map
+                "amplitude damp": amp_damp_map,
+                "phase damp": phase_damp_map,
+                "bit flip": bit_flip_map,
+                "phase flip": phase_flip_map,
+                "phase-amplitude damp": phase_amp_damp_map,
+                "depolarizing": depolarizing_map,
             }
 
             if isinstance(self.noise, str):
-                if self.noise == 'device':
+                if self.noise == "device":
                     pass
                 else:
                     raise TequilaException(
-                        'noise was a string: {}, which is not \'device\'. This is not allowed!'.format(self.noise))
+                        "noise was a string: {}, which is not 'device'. This is not allowed!".format(self.noise)
+                    )
 
             else:
                 self.circuit = self.build_noisy_circuit(self.circuit, self.noise)
@@ -408,8 +422,9 @@ class BackendCircuitPyquil(BackendCircuit):
             self.match_dummy_to_value = None
             self.resolver = None
         else:
-            self.match_dummy_to_value = {'theta_{}'.format(str(i)): k for i, k in
-                                         enumerate(self.match_par_to_dummy.keys())}
+            self.match_dummy_to_value = {
+                "theta_{}".format(str(i)): k for i, k in enumerate(self.match_par_to_dummy.keys())
+            }
             self.resolver = {k: [to_float(v(variables))] for k, v in self.match_dummy_to_value.items()}
 
     def do_simulate(self, variables, initial_state, *args, **kwargs):
@@ -464,12 +479,12 @@ class BackendCircuitPyquil(BackendCircuit):
         p = circuit
 
         if self.device is None:
-            qc = get_qc('{}q-qvm'.format(str(n_qubits)))
+            qc = get_qc("{}q-qvm".format(str(n_qubits)))
             p.wrap_in_numshots_loop(samples)
         else:
             qc = self.device
             p = qc.compile(p)
-            p.attributes['num_shots'] = samples
+            p.attributes["num_shots"] = samples
         stacked = qc.run(p, memory_map=self.resolver)
         return self.convert_measurements(stacked)
 
@@ -491,7 +506,7 @@ class BackendCircuitPyquil(BackendCircuit):
         def string_to_array(s):
             listing = []
             for letter in s:
-                if letter not in [',', ' ', '[', ']', '.']:
+                if letter not in [",", " ", "[", "]", "."]:
                     listing.append(int(letter))
             return listing
 
@@ -500,7 +515,7 @@ class BackendCircuitPyquil(BackendCircuit):
         for b in backend_result:
             try:
                 bit_dict[str(b)] += 1
-            except:
+            except Exception:
                 bit_dict[str(b)] = 1
 
         for k, v in bit_dict.items():
@@ -528,30 +543,30 @@ class BackendCircuitPyquil(BackendCircuit):
 
     def add_parametrized_gate(self, gate, circuit, *args, **kwargs):
         """
-       Add a parametrized gate to the circuit. Used in inherited method create_circuit.
-
-       Additionally, builds and updates mappings so that pyquil can resolve the parametrization of the gate at runtime.
-       Parameters
-       ----------
-       gate: QGateImpl:
-           the gate to translate to pyquil.
-       circuit:
-           the pyquil circuit, to which a new gate is to be added
-       args
-       kwargs
-
-       Returns
-       -------
-       None
-       """
+        Add a parametrized gate to the circuit. Used in inherited method create_circuit.
+
+        Additionally, builds and updates mappings so that pyquil can resolve the parametrization of the gate at runtime.
+        Parameters
+        ----------
+        gate: QGateImpl:
+            the gate to translate to pyquil.
+        circuit:
+            the pyquil circuit, to which a new gate is to be added
+        args
+        kwargs
+
+        Returns
+        -------
+        None
+        """
         op = self.op_lookup[gate.name]
         if isinstance(gate.parameter, float):
             par = gate.parameter
         else:
             try:
                 par = self.match_par_to_dummy[gate.parameter]
-            except:
-                par = circuit.declare('theta_{}'.format(str(self.counter)), 'REAL')
+            except Exception:
+                par = circuit.declare("theta_{}".format(str(self.counter)), "REAL")
                 self.match_par_to_dummy[gate.parameter] = par
                 self.counter += 1
         pyquil_gate = op(angle=par, qubit=self.qubit(gate.target[0]))
@@ -562,26 +577,26 @@ class BackendCircuitPyquil(BackendCircuit):
 
     def add_measurement(self, circuit, target_qubits, *args, **kwargs):
         """
-       Add a measurement to the circuit. Used in inherited method create_circuit.
-
-       ----------
-       gate: MeasurementGateImpl:
-           the measurement, to be translated to pyquil
-       circuit:
-           the pyquil circuit, to which measurement is to be added
-       args
-       kwargs
-
-       Returns
-       -------
-       None
-       """
+        Add a measurement to the circuit. Used in inherited method create_circuit.
+
+        ----------
+        gate: MeasurementGateImpl:
+            the measurement, to be translated to pyquil
+        circuit:
+            the pyquil circuit, to which measurement is to be added
+        args
+        kwargs
+
+        Returns
+        -------
+        None
+        """
         bits = len(target_qubits)
         measurements = self.initialize_circuit()
-        ro = measurements.declare('ro', 'BIT', bits)
+        ro = measurements.declare("ro", "BIT", bits)
         for i, t in enumerate(sorted(target_qubits)):
             measurements += pyquil.gates.MEASURE(self.qubit(t), ro[i])
-        return circuit + measurements # avoid inplace operations
+        return circuit + measurements  # avoid inplace operations
 
     def add_basic_gate(self, gate, circuit, *args, **kwargs):
         """
@@ -606,7 +621,7 @@ class BackendCircuitPyquil(BackendCircuit):
                 pyquil_gate = g(*[self.qubit(q) for q in gate.control + gate.target])
             else:
                 pyquil_gate = g(*[self.qubit(t) for t in gate.target])
-        except:
+        except Exception:
             g = op[0]
             for c in gate.control:
                 pyquil_gate = g(*[self.qubit(t) for t in gate.target]).controlled(self.qubit(c))
@@ -633,30 +648,31 @@ class BackendCircuitPyquil(BackendCircuit):
         collected = {}
         for noise in noise_model.noises:
             try:
-                collected[str(noise.level)] = combine_kraus_maps(self.noise_lookup[noise.name](*noise.probs),
-                                                                 collected[str(noise.level)])
-            except:
+                collected[str(noise.level)] = combine_kraus_maps(
+                    self.noise_lookup[noise.name](*noise.probs), collected[str(noise.level)]
+                )
+            except Exception:
                 collected[str(noise.level)] = self.noise_lookup[noise.name](*noise.probs)
         done = []
         for gate in prog:
             new.inst(gate)
-            if hasattr(gate, 'qubits'):
+            if hasattr(gate, "qubits"):
                 level = str(len(gate.qubits))
                 if level in collected.keys():
-                    if name_dict[gate.name] == 'parametrized':
+                    if name_dict[gate.name] == "parametrized":
                         new.inst([pyquil.gates.I(q) for q in gate.qubits])
-                        if ['parametrized', gate.qubits] not in done:
-                            new.define_noisy_gate('I',
-                                                  gate.qubits,
-                                                  append_kraus_to_gate(collected[level], np.eye(2), int(level)))
-                            done.append(['parametrized', 1, gate.qubits])
+                        if ["parametrized", gate.qubits] not in done:
+                            new.define_noisy_gate(
+                                "I", gate.qubits, append_kraus_to_gate(collected[level], np.eye(2), int(level))
+                            )
+                            done.append(["parametrized", 1, gate.qubits])
 
                     else:
                         if [gate.name, len(gate.qubits), gate.qubits] not in done:
                             k = unitary_maker(gate)
-                            new.define_noisy_gate(gate.name,
-                                                  gate.qubits,
-                                                  append_kraus_to_gate(collected[level], k, int(level)))
+                            new.define_noisy_gate(
+                                gate.name, gate.qubits, append_kraus_to_gate(collected[level], k, int(level))
+                            )
                             done.append([gate.name, len(gate.qubits), gate.qubits])
                 else:
                     pass
@@ -698,9 +714,9 @@ class BackendCircuitPyquil(BackendCircuit):
             return
         if isinstance(device, str):
             d = device
-            if '-qvm' in d.lower():
+            if "-qvm" in d.lower():
                 d = d[:-4]
-            if '-noisy' in d.lower():
+            if "-noisy" in d.lower():
                 d = d[:-6]
             if d in pyquil.list_quantum_computers():
                 return
@@ -708,25 +724,26 @@ class BackendCircuitPyquil(BackendCircuit):
                 try:
                     get_qc(d)
                     return
-                except:
+                except Exception:
                     try:
                         get_qc(d, as_qvm=True)
                         return
-                    except:
-                        raise TequilaException('could not obtain device from string; received {}'.format(device))
+                    except Exception:
+                        raise TequilaException("could not obtain device from string; received {}".format(device))
 
         elif isinstance(device, dict):
             try:
                 get_qc(**device)
                 return
-            except:
-                raise TequilaException('could not initialize device from dict; received {}'.format(device))
+            except Exception:
+                raise TequilaException("could not initialize device from dict; received {}".format(device))
         elif isinstance(device, pyquil.api.QuantumComputer):
             return
 
         else:
             raise TequilaException(
-                'Uninterpretable object {} of type {} passed to check_device!'.format(device, type(device)))
+                "Uninterpretable object {} of type {} passed to check_device!".format(device, type(device))
+            )
 
     def retrieve_device(self, device):
         """
@@ -741,33 +758,35 @@ class BackendCircuitPyquil(BackendCircuit):
         pyquil.api.QuantumComputer
             an instantiated device object for pyquil simulation or execution.
         """
-        use_device_noise = (self.noise == 'device')
+        use_device_noise = self.noise == "device"
         if device is None:
             return None
         if isinstance(device, str):
             try:
                 back = get_qc(device, noisy=use_device_noise)
                 return back
-            except:
+            except Exception:
                 try:
                     back = get_qc(device, as_qvm=True, noisy=use_device_noise)
                     return back
-                except:
-                    raise TequilaException('could not obtain device from string; received {}'.format(device))
+                except Exception:
+                    raise TequilaException("could not obtain device from string; received {}".format(device))
         elif isinstance(device, pyquil.api.QuantumComputer):
             return device
         elif isinstance(device, dict):
             try:
                 return get_qc(**device)
-            except:
-                raise TequilaException('could not initialize device from dict; received {}'.format(device))
+            except Exception:
+                raise TequilaException("could not initialize device from dict; received {}".format(device))
         else:
             raise TequilaException(
-                'Uninterpretable object {} of type {} passed to check_device!'.format(device, type(device)))
+                "Uninterpretable object {} of type {} passed to check_device!".format(device, type(device))
+            )
 
 
 class BackendExpectationValuePyquil(BackendExpectationValue):
     """
     See BackendExpectationValue for information.
     """
+
     BackendCircuitType = BackendCircuitPyquil