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

tequila/simulators/simulator_qibo.py

@@ -17,6 +17,7 @@ class TequilaQiboException(TequilaException):
     def __str__(self):
         return "Error in qibo backend:" + self.message
 
+
 def kraus_tensor(klist, n):
     """
     Recursive function that produces every (n-fold) tensor product of a list of kraus operators.
@@ -39,9 +40,10 @@ 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 TequilaQiboException('wtf, you gave me n={}'.format(str(n)))
+        raise TequilaQiboException("wtf, you gave me n={}".format(str(n)))
+
 
-def bit_flip_map(qs,p):
+def bit_flip_map(qs, p):
     """
     returns the kraus operators for bit flip with probability p
     Parameters
@@ -56,16 +58,16 @@ def bit_flip_map(qs,p):
     """
     mat1 = np.array([[np.sqrt(1 - p), 0], [0, np.sqrt(1 - p)]])
     mat2 = np.array([[0, np.sqrt(p)], [np.sqrt(p), 0]])
-    back= []
+    back = []
     matlist = [mat1, mat2]
-    newmats = kraus_tensor(matlist,len(qs))
+    newmats = kraus_tensor(matlist, len(qs))
     for mat in newmats:
         back.append((tuple(qs), mat))
 
     return back
 
 
-def phase_flip_map(qs,p):
+def phase_flip_map(qs, p):
     """
     returns the kraus operators for phase flip with probability p
     Parameters
@@ -80,7 +82,7 @@ def phase_flip_map(qs,p):
     """
     mat1 = np.array([[np.sqrt(1 - p), 0], [0, np.sqrt(1 - p)]])
     mat2 = np.array([[np.sqrt(p), 0], [0, -np.sqrt(p)]])
-    back= []
+    back = []
     matlist = [mat1, mat2]
     newmats = kraus_tensor(matlist, len(qs))
     for mat in newmats:
@@ -88,7 +90,7 @@ def phase_flip_map(qs,p):
     return back
 
 
-def amp_damp_map(qs,p):
+def amp_damp_map(qs, p):
     """
     Generate the Kraus operators corresponding to an amplitude damping
     noise channel.
@@ -97,10 +99,9 @@ def amp_damp_map(qs,p):
     :return: A list [k1, k2] of the Kraus operators that parametrize the map.
     :rtype: list
     """
-    mat1 = np.sqrt(p) * np.array([[0, 1],
-                                        [0, 0]])
+    mat1 = np.sqrt(p) * np.array([[0, 1], [0, 0]])
     mat2 = np.diag([1, np.sqrt(1 - p)])
-    back= []
+    back = []
     matlist = [mat1, mat2]
     newmats = kraus_tensor(matlist, len(qs))
     for mat in newmats:
@@ -108,7 +109,7 @@ def amp_damp_map(qs,p):
     return back
 
 
-def phase_damp_map(qs,p):
+def phase_damp_map(qs, p):
     """
     returns the kraus operators for phase damping with probability p
     Parameters
@@ -131,6 +132,7 @@ def phase_damp_map(qs,p):
         back.append((tuple(qs), mat))
     return back
 
+
 def phase_amp_damp_map(qs, a, b):
     """
     the kraus maps for combined phase amplitude damping
@@ -153,12 +155,13 @@ def phase_amp_damp_map(qs, a, b):
 
     back = []
     matlist = [np.array(k) for k in [A0, A1, A2]]
-    newmats = kraus_tensor(matlist,len(qs))
+    newmats = kraus_tensor(matlist, len(qs))
     for mat in newmats:
         back.append((tuple(qs), mat))
     return back
 
-def depolarizing_map(qs,p):
+
+def depolarizing_map(qs, p):
     """
     the kraus maps for symmetric depolarizing
     Parameters
@@ -175,14 +178,15 @@ def depolarizing_map(qs,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]])
     back = []
-    matlist= [mat1,mat2,mat3,mat4]
+    matlist = [mat1, mat2, mat3, mat4]
     newmats = kraus_tensor(matlist, len(qs))
     for mat in newmats:
         back.append((tuple(qs), mat))
     return back
 
+
 class BackendCircuitQibo(BackendCircuit):
     """
     Class representing circuits compiled to qibo.
@@ -222,12 +226,11 @@ class BackendCircuitQibo(BackendCircuit):
         "controlled_phase": False,
         "toffoli": False,
         "phase_to_z": False,
-        "cc_max": True
+        "cc_max": True,
     }
     numbering: BitNumbering = BitNumbering.MSB
 
-
-    def __init__(self, abstract_circuit, noise=None, device=None,highest_qubit=None, *args, **kwargs):
+    def __init__(self, abstract_circuit, noise=None, device=None, highest_qubit=None, *args, **kwargs):
         """
 
         Parameters
@@ -242,17 +245,17 @@ class BackendCircuitQibo(BackendCircuit):
         kwargs
         """
         self.op_lookup = {
-            'I': gates.I,
-            'X': gates.X,
-            'Y': gates.Y,
-            'Z': gates.Z,
-            'H': gates.H,
-            'Rx': gates.RX,
-            'Ry': gates.RY,
-            'Rz': gates.RZ,
-            'SWAP': gates.SWAP,
-            'Measure': gates.M,
-            'Phase': gates.ZPow
+            "I": gates.I,
+            "X": gates.X,
+            "Y": gates.Y,
+            "Z": gates.Z,
+            "H": gates.H,
+            "Rx": gates.RX,
+            "Ry": gates.RY,
+            "Rz": gates.RZ,
+            "SWAP": gates.SWAP,
+            "Measure": gates.M,
+            "Phase": gates.ZPow,
         }
         self.counter = 0  # keeps track of how many parameters are in the circuit
         self.variables = []  # will map position to parameter better
@@ -261,59 +264,59 @@ class BackendCircuitQibo(BackendCircuit):
         if noise is not None:
             qibo.set_backend("defaulteinsum")  # necessary for Qibo to do density matrices!
         else:
-            qibo.set_backend('custom')
+            qibo.set_backend("custom")
         if highest_qubit is None:
-            self.highest_qubit=0
+            self.highest_qubit = 0
         else:
-            self.highest_qubit=highest_qubit
-        super().__init__(abstract_circuit=abstract_circuit, noise=noise,device=device, *args, **kwargs)
+            self.highest_qubit = highest_qubit
+        super().__init__(abstract_circuit=abstract_circuit, noise=noise, device=device, *args, **kwargs)
 
         if noise is not None:
             # a lookup table from tequila QuantumNoise to NoiseChannel qibo objects. See each function
             # for reference
             self.noise_lookup = {
-                'bit flip': lambda qs,px: gates.GeneralChannel(bit_flip_map(qs,px)),
-                'phase flip': lambda qs,px: gates.GeneralChannel(phase_flip_map(qs,px)),
-                'phase damp': lambda qs, p: gates.GeneralChannel(phase_damp_map(qs,p)),
-                'amplitude damp': lambda qs, p: gates.GeneralChannel(amp_damp_map(qs,p)),
-                'phase-amplitude damp': lambda qs,a,b: gates.GeneralChannel(phase_amp_damp_map(qs,a,b)),
-                'depolarizing': lambda qs,p: gates.GeneralChannel(depolarizing_map(qs,p))
+                "bit flip": lambda qs, px: gates.GeneralChannel(bit_flip_map(qs, px)),
+                "phase flip": lambda qs, px: gates.GeneralChannel(phase_flip_map(qs, px)),
+                "phase damp": lambda qs, p: gates.GeneralChannel(phase_damp_map(qs, p)),
+                "amplitude damp": lambda qs, p: gates.GeneralChannel(amp_damp_map(qs, p)),
+                "phase-amplitude damp": lambda qs, a, b: gates.GeneralChannel(phase_amp_damp_map(qs, a, b)),
+                "depolarizing": lambda qs, p: gates.GeneralChannel(depolarizing_map(qs, p)),
             }
-            self.circuit = self.add_noise_to_circuit(noise) # see this function for details
+            self.circuit = self.add_noise_to_circuit(noise)  # see this function for details
         self.baseline_variables = self.variables
 
     def check_device(self, device):
-        assert type(device) in [str,dict] or device is None
-        if isinstance(device,str):
-            d=device.upper()
-            if d[:5] not in ["/GPU:","/CPU:"]:
+        assert type(device) in [str, dict] or device is None
+        if isinstance(device, str):
+            d = device.upper()
+            if d[:5] not in ["/GPU:", "/CPU:"]:
                 raise TequilaQiboException("Device names must begin with either /GPU: or /CPU:; received {}".format(d))
-        elif isinstance(device,dict):
-            if 'memory_device' in device.keys(): #full spec paralellism
-                md = device['memory_device'].upper()
+        elif isinstance(device, dict):
+            if "memory_device" in device.keys():  # full spec paralellism
+                md = device["memory_device"].upper()
                 self.check_device(md)
-                if 'accelerators' in list(device.keys()):
-                    for k in device['accelerators'].keys():
+                if "accelerators" in list(device.keys()):
+                    for k in device["accelerators"].keys():
                         self.check_device(k)
                 else:
-                    raise TequilaQiboException('device dictionary formatted improperly!')
+                    raise TequilaQiboException("device dictionary formatted improperly!")
             else:
-                for k in device['accelerators'].keys():
+                for k in device["accelerators"].keys():
                     self.check_device(k)
         return
 
     def retrieve_device(self, device):
         if device is None:
             return device
-        elif isinstance(device,str):
+        elif isinstance(device, str):
             return device
-        elif isinstance(device,dict):
-            if 'memory_device' in device.keys():  # full spec paralellism
+        elif isinstance(device, dict):
+            if "memory_device" in device.keys():  # full spec paralellism
                 return device
             else:
-                return {'accelerators':device,'memory_device':"/CPU:0"}
+                return {"accelerators": device, "memory_device": "/CPU:0"}
         else:
-            raise TequilaQiboException('Invalid device of type {}'.format(type(device)))
+            raise TequilaQiboException("Invalid device of type {}".format(type(device)))
 
     def update_variables(self, variables, circuit=None):
         """
@@ -361,15 +364,15 @@ class BackendCircuitQibo(BackendCircuit):
                 wave = QubitWaveFunction.from_string(initial_state, self.numbering).to_array()
             elif isinstance(initial_state, QubitWaveFunction):
                 wave = initial_state
-            elif isinstance(initial_state,np.ndarray):
+            elif isinstance(initial_state, np.ndarray):
                 wave = QubitWaveFunction.from_array(initial_state, self.numbering)
             else:
-                raise TequilaQiboException('could not understand initial state of type {}'.format(type(initial_state)))
+                raise TequilaQiboException("could not understand initial state of type {}".format(type(initial_state)))
             state = wave.to_array()
             result = self.circuit(state)
         else:
             result = self.circuit()
-        back= QubitWaveFunction.from_array(result.numpy(), self.numbering)
+        back = QubitWaveFunction.from_array(result.numpy(), self.numbering)
         return back
 
     def simulate(self, variables, initial_state=0, *args, **kwargs) -> QubitWaveFunction:
@@ -393,23 +396,23 @@ class BackendCircuitQibo(BackendCircuit):
 
         """
 
-
         self.update_variables(variables)
         if isinstance(initial_state, BitString):
             initial_state = initial_state.integer
         if isinstance(initial_state, QubitWaveFunction):
             if initial_state.length() != 1:
-                return self.do_simulate(variables=variables,initial_state=initial_state, *args, **kwargs)
+                return self.do_simulate(variables=variables, initial_state=initial_state, *args, **kwargs)
             initial_state = list(initial_state.keys())[0].integer
-        if isinstance(initial_state,np.ndarray):
+        if isinstance(initial_state, np.ndarray):
             return self.do_simulate(variables=variables, initial_state=initial_state, *args, **kwargs)
         all_qubits = [i for i in range(self.abstract_circuit.n_qubits)]
         active_qubits = self.abstract_circuit.qubits
         # maps from reduced register to full register
         keymap = KeyMapSubregisterToRegister(subregister=active_qubits, register=all_qubits)
 
-        result = self.do_simulate(variables=variables, initial_state=keymap.inverted(initial_state).integer, *args,
-                                  **kwargs)
+        result = self.do_simulate(
+            variables=variables, initial_state=keymap.inverted(initial_state).integer, *args, **kwargs
+        )
         return result
 
     def convert_measurements(self, backend_result, target_qubits=None) -> QubitWaveFunction:
@@ -441,8 +444,7 @@ class BackendCircuitQibo(BackendCircuit):
 
         return result
 
-    def sample_paulistring(self, samples: int, paulistring, variables, *args,
-                           **kwargs):
+    def sample_paulistring(self, samples: int, paulistring, variables, *args, **kwargs):
         """
         Has to be rewritten because of the pro-scription in qibo against calling already executed circuits.
 
@@ -476,16 +478,17 @@ class BackendCircuitQibo(BackendCircuit):
             basis_change += change_basis(target=idx, axis=p)
 
         highest_qubit = max(paulistring.qubits)
-        new=self.rebuild_for_sample(abstract_circuit=basis_change,variables=variables,highest_qubit=highest_qubit)
+        new = self.rebuild_for_sample(abstract_circuit=basis_change, variables=variables, highest_qubit=highest_qubit)
 
         # run simulators
-        counts = new.sample(samples=samples, circuit=new.circuit, read_out_qubits=qubits, variables=variables, *args,
-                             **kwargs)
+        counts = new.sample(
+            samples=samples, circuit=new.circuit, read_out_qubits=qubits, variables=variables, *args, **kwargs
+        )
         # compute energy
         E = 0.0
         n_samples = 0
-        #print('printing the counts')
-        #print(counts)
+        # print('printing the counts')
+        # print(counts)
         for key, count in counts.items():
             parity = key.array.count(1)
             sign = (-1) ** parity
@@ -528,7 +531,7 @@ class BackendCircuitQibo(BackendCircuit):
             elif isinstance(initial_state, np.ndarray):
                 wave = QubitWaveFunction.from_array(initial_state, self.numbering)  # silly but necessary
             else:
-                raise TequilaQiboException('received an unusable initial state of type {}'.format(type(initial_state)))
+                raise TequilaQiboException("received an unusable initial state of type {}".format(type(initial_state)))
             state = wave.to_array()
             result = circuit(state, nshots=samples)
         else:
@@ -585,7 +588,7 @@ class BackendCircuitQibo(BackendCircuit):
         qibo.tensorflow.circuit.TensorflowCircuit
             an empty, though initialized, circuit that can be executed or manipulated.
         """
-        n_qubits=max(self.highest_qubit+1,self.n_qubits,self.abstract_circuit.max_qubit()+1)
+        n_qubits = max(self.highest_qubit + 1, self.n_qubits, self.abstract_circuit.max_qubit() + 1)
         if self.device is None:
             return Circuit(n_qubits)
         else:
@@ -595,8 +598,8 @@ class BackendCircuitQibo(BackendCircuit):
                     self.flag = True  # don't reset the device every time; such as during measurement.
                 return Circuit(n_qubits)
             elif isinstance(self.device, dict):
-                acc = self.device['accelerators']
-                mem = self.device['memory device']
+                acc = self.device["accelerators"]
+                mem = self.device["memory device"]
                 return Circuit(n_qubits, accelerators=acc, memory_device=mem)
 
     def add_parametrized_gate(self, gate, circuit, variables, *args, **kwargs):
@@ -623,9 +626,9 @@ class BackendCircuitQibo(BackendCircuit):
         self.variables.append(gate.parameter)
         value = gate.parameter(variables)
         if gate.is_controlled():
-            inst= op(t[0], theta=value).controlled_by(c[0])
+            inst = op(t[0], theta=value).controlled_by(c[0])
         else:
-            inst = op(t[0],theta=value)
+            inst = op(t[0], theta=value)
         self.inst_list.append(copy.deepcopy(inst))
         circuit.add(inst)
         return circuit
@@ -650,9 +653,9 @@ class BackendCircuitQibo(BackendCircuit):
         t = gate.target
         c = gate.control
         if gate.is_controlled():
-            inst= op(t[0]).controlled_by(c[0])
+            inst = op(t[0]).controlled_by(c[0])
         else:
-            if gate.name is ['Swap']:
+            if gate.name is ["Swap"]:
                 inst = op(t[0], t[1])
             else:
                 inst = op(t[0])
@@ -677,14 +680,14 @@ class BackendCircuitQibo(BackendCircuit):
         None
         """
         target_qubits = sorted(target_qubits)
-        added=[]
+        added = []
         for t in target_qubits:
             circuit.add(gates.M(t))
             added.append(copy.deepcopy(gates.M(t)))
         self.inst_list.extend(added)
         return circuit
 
-    def add_noise_to_circuit(self,noise_model):
+    def add_noise_to_circuit(self, noise_model):
         """
         Apply noise from a NoiseModel to a circuit.
         Parameters
@@ -698,14 +701,14 @@ class BackendCircuitQibo(BackendCircuit):
             self.circuit, with noise added on.
         """
         n = noise_model
-        new=self.initialize_circuit()
+        new = self.initialize_circuit()
         temp_list = []
         for g in self.inst_list:
             new.add(g)
-            qubits=g.qubits
+            qubits = g.qubits
             for noise in n.noises:
                 if len(qubits) == noise.level:
-                    ch = (self.noise_lookup[noise.name])
+                    ch = self.noise_lookup[noise.name]
                     chargs = [qubits]
                     for p in noise.probs:
                         chargs.append(p)
@@ -715,7 +718,7 @@ class BackendCircuitQibo(BackendCircuit):
         self.inst_list.extend(temp_list)
         return new
 
-    def rebuild_for_sample(self,abstract_circuit=None,variables=None,highest_qubit=None):
+    def rebuild_for_sample(self, abstract_circuit=None, variables=None, highest_qubit=None):
         """
         restructures the compiled circuit to that necessary for sampling
         Parameters
@@ -728,8 +731,13 @@ class BackendCircuitQibo(BackendCircuit):
         """
         if abstract_circuit is None:
             abstract_circuit = QCircuit()
-        new = BackendCircuitQibo(self.abstract_circuit+abstract_circuit,variables=variables,noise=self.noise,
-                                 device=self.device,highest_qubit=highest_qubit)
+        new = BackendCircuitQibo(
+            self.abstract_circuit + abstract_circuit,
+            variables=variables,
+            noise=self.noise,
+            device=self.device,
+            highest_qubit=highest_qubit,
+        )
         return new