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

tequila/simulators/simulator_qibo.py

@@ -356,20 +356,20 @@ class BackendCircuitQibo(BackendCircuit):
         n_qubits = max(self.highest_qubit + 1, self.n_qubits, self.abstract_circuit.max_qubit() + 1)
         if initial_state is not None:
             if isinstance(initial_state, (int, np.int64)):
-                wave = QubitWaveFunction.from_int(i=initial_state, n_qubits=n_qubits)
+                wave = QubitWaveFunction.from_basis_state(n_qubits, initial_state, self.numbering)
             elif isinstance(initial_state, str):
-                wave = QubitWaveFunction.from_string(string=initial_state).to_array()
+                wave = QubitWaveFunction.from_string(initial_state, self.numbering).to_array()
             elif isinstance(initial_state, QubitWaveFunction):
                 wave = initial_state
             elif isinstance(initial_state,np.ndarray):
-                wave = QubitWaveFunction.from_array(initial_state)
+                wave = QubitWaveFunction.from_array(initial_state, self.numbering)
             else:
                 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(arr=result.numpy())
+        back= QubitWaveFunction.from_array(result.numpy(), self.numbering)
         return back
 
     def simulate(self, variables, initial_state=0, *args, **kwargs) -> QubitWaveFunction:
@@ -398,7 +398,7 @@ class BackendCircuitQibo(BackendCircuit):
         if isinstance(initial_state, BitString):
             initial_state = initial_state.integer
         if isinstance(initial_state, QubitWaveFunction):
-            if len(initial_state.keys()) != 1:
+            if initial_state.length() != 1:
                 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):
@@ -426,19 +426,18 @@ class BackendCircuitQibo(BackendCircuit):
             results transformed to tequila native QubitWaveFunction
         """
 
-        result = QubitWaveFunction()
+        result = QubitWaveFunction(self.n_qubits, self.numbering)
         # todo there are faster ways
 
         for k, v in backend_result.frequencies(binary=True).items():
             converted_key = BitString.from_bitstring(other=BitString.from_binary(binary=k))
-            result._state[converted_key] = v
-
+            result[converted_key] = v
 
         if target_qubits is not None:
             mapped_target = [self.qubit_map[q].number for q in target_qubits]
             mapped_full = [self.qubit_map[q].number for q in self.abstract_qubits]
             keymap = KeyMapRegisterToSubregister(subregister=mapped_target, register=mapped_full)
-            result = result.apply_keymap(keymap=keymap)
+            result = QubitWaveFunction.from_wavefunction(result, keymap, len(mapped_target))
 
         return result
 
@@ -521,21 +520,20 @@ class BackendCircuitQibo(BackendCircuit):
         n_qubits = max(self.highest_qubit + 1, self.n_qubits, self.abstract_circuit.max_qubit() + 1)
         if initial_state is not None:
             if isinstance(initial_state, int):
-                wave=QubitWaveFunction.from_int(i=initial_state, n_qubits=n_qubits)
+                wave = QubitWaveFunction.from_basis_state(n_qubits, initial_state, self.numbering)
             elif isinstance(initial_state, str):
-                wave = QubitWaveFunction.from_string(string=initial_state).to_array()
+                wave = QubitWaveFunction.from_string(initial_state, self.numbering).to_array()
             elif isinstance(initial_state, QubitWaveFunction):
                 wave = initial_state
-            elif isinstance(initial_state,np.ndarray):
-                wave = QubitWaveFunction.from_array(arr=initial_state, n_qubits=n_qubits)  # silly but necessary
+            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)))
-            state=wave.to_array()
-            result = circuit(state,nshots=samples)
+            state = wave.to_array()
+            result = circuit(state, nshots=samples)
         else:
             result = circuit(nshots=samples)
 
-
         back = self.convert_measurements(backend_result=result)
         return back
 

tequila/simulators/simulator_qiskit.py

@@ -1,22 +1,28 @@
 from tequila.simulators.simulator_base import BackendCircuit, QCircuit, BackendExpectationValue
+from tequila.utils.bitstrings import reverse_int_bits
 from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
 from tequila import TequilaException, TequilaWarning
 from tequila import BitString, BitNumbering, BitStringLSB
 from tequila.utils.keymap import KeyMapRegisterToSubregister
 from tequila.utils import to_float
-import qiskit, numpy, warnings
+from typing import Union
+import warnings
+import numpy as np
+import qiskit, qiskit_aer, qiskit.providers.fake_provider
+from qiskit import QuantumCircuit, transpile
 
-HAS_NOISE=True
+HAS_NOISE = True
 try:
-    from qiskit_aer import noise as qiskitnoise
+    from qiskit_aer import noise as qiskitnoise, AerSimulator
 except:
     HAS_NOISE = False
 
-HAS_IBMQ=True
+HAS_IBMQ = True
 try:
-    from qiskit.providers.ibmq import IBMQBackend
+    from qiskit_ibm_runtime import IBMBackend
 except:
-    HAS_IBMQ=False
+    HAS_IBMQ = False
+
 
 def get_bit_flip(p):
     """
@@ -70,16 +76,24 @@ gate_qubit_lookup = {
     'multicontrol': 3
 }
 
-full_basis = ['x', 'y', 'z', 'id', 'u1', 'u2', 'u3', 'h','unitary','sx',
+full_basis = ['x', 'y', 'z', 'id', 'u1', 'u2', 'u3', 'h', 'unitary', 'sx',
               'cx', 'cy', 'cz', 'cu3', 'ccx']
 
+
 def qiskit_device_dict():
-    devices = {}
-    devices.update({str(x).lower():x for x in qiskit.Aer.backends()})
-    devices.update({str(x).lower():x for x in qiskit.test.mock.FakeProvider().backends()})
+    # As of Quiskit Aer 0.15.0, backends() also returns legacy backends which are not AerSimulators that will be
+    # deprecated in the future
+    # TODO: Instead of building a dict with all backends just to search it, search directly with `get_backend`
+    # https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.AerProvider.html#qiskit_aer.AerProvider.get_backend
+    devices = {backend.name.lower(): backend for backend in qiskit_aer.AerProvider().backends()
+               if isinstance(backend, AerSimulator)}
+
+    # FakeProvider has been removed, see https://github.com/Qiskit/qiskit/issues/10954
+    # devices.update({str(x).lower(): x for x in qiskit.test.mock.FakeProvider().backends()})
 
     return devices
 
+
 class TequilaQiskitException(TequilaException):
     def __str__(self):
         return "Error in qiskit backend:" + self.message
@@ -125,6 +139,8 @@ class BackendCircuitQiskit(BackendCircuit):
         transform a tequila NoiseModel into a qiskit noise model.
 
     """
+    STATEVECTOR_DEVICE_NAME = "aer_simulator_statevector"
+
     compiler_arguments = {
         "trotterized": True,
         "swap": False,
@@ -145,7 +161,10 @@ class BackendCircuitQiskit(BackendCircuit):
     }
 
     numbering = BitNumbering.LSB
-            
+
+    supports_sampling_initialization = True
+    supports_generic_initialization = True
+
     def __init__(self, abstract_circuit: QCircuit, variables, qubit_map=None, noise=None,
                  device=None, *args, **kwargs):
         """
@@ -188,8 +207,9 @@ class BackendCircuitQiskit(BackendCircuit):
         if qubit_map is None:
             qubit_map = {q: i for i, q in enumerate(abstract_circuit.qubits)}
         else:
-            warnings.warn("reveived custom qubit_map = {}\n"
-                          "This is not fully integrated with qiskit and might result in unexpected behaviour".format(qubit_map), TequilaWarning)
+            warnings.warn(f"reveived custom qubit_map = {qubit_map}\n"
+                          "This is not fully integrated with qiskit and might result in unexpected behaviour",
+                          TequilaWarning)
 
         n_qubits = max(qubit_map.values()) + 1
 
@@ -201,7 +221,7 @@ class BackendCircuitQiskit(BackendCircuit):
 
         self.classical_map = self.make_classical_map(qubit_map=self.qubit_map)
 
-        if noise != None:
+        if noise is not None:
             self.noise_lookup = {
                 'phase damp': qiskitnoise.phase_damping_error,
                 'amplitude damp': qiskitnoise.amplitude_damping_error,
@@ -211,12 +231,12 @@ class BackendCircuitQiskit(BackendCircuit):
                 'depolarizing': qiskitnoise.depolarizing_error
             }
 
-            if isinstance(noise, str): #string noise means "use the same noise as the device I tell you to get."
+            if isinstance(noise, str):  # string noise means "use the same noise as the device I tell you to get."
                 try:
                     self.check_device(noise)
                     self.noise_model = qiskitnoise.NoiseModel.from_backend(noise)
                 except TequilaQiskitException:
-                    raise TequilaException("noise init from string requires that noise names a device. Got {}".format(noise))
+                    raise TequilaException(f"noise init from string requires that noise names a device. Got {noise}")
 
             else:
                 self.noise_model = self.noise_model_converter(noise)
@@ -235,7 +255,7 @@ class BackendCircuitQiskit(BackendCircuit):
         qubit_map = super().make_qubit_map(qubits=qubits)
         mapped_qubits = [q.number for q in qubit_map.values()]
         for k, v in qubit_map.items():
-            qubit_map[k].instance = self.q [v.number]
+            qubit_map[k].instance = self.q[v.number]
 
         return qubit_map
 
@@ -247,6 +267,20 @@ class BackendCircuitQiskit(BackendCircuit):
 
         return classical_map
 
+    def add_state_init(self, circuit: QuantumCircuit, initial_state: Union[int, QubitWaveFunction]) -> QuantumCircuit:
+        if initial_state == 0:
+            return circuit
+
+        if isinstance(initial_state, QubitWaveFunction):
+            statevector = initial_state.to_array(self.numbering)
+        else:
+            statevector = np.zeros(2 ** self.n_qubits)
+            statevector[reverse_int_bits(initial_state, self.n_qubits)] = 1.0
+
+        init_circuit = qiskit.QuantumCircuit(self.q, self.c)
+        init_circuit.set_statevector(statevector)
+        return init_circuit.compose(circuit)
+
     def do_simulate(self, variables, initial_state=0, *args, **kwargs) -> QubitWaveFunction:
         """
         Helper function for performing simulation.
@@ -266,10 +300,12 @@ class BackendCircuitQiskit(BackendCircuit):
         """
         if self.noise_model is None:
             if self.device is None:
-                qiskit_backend = self.retrieve_device('statevector_simulator')
+                qiskit_backend = self.retrieve_device(self.STATEVECTOR_DEVICE_NAME)
             else:
                 if 'statevector' not in str(self.device):
-                    raise TequilaException('For simulation, only state vector simulators are supported; recieved device={}, you might have forgoten to set the samples keyword - e.g. (device={}, samples=1000). If not set, tequila assumes that full wavefunction simualtion is demanded which is not compatible with qiskit devices or fake devices except for device=statevector'.format(self.device, self.device))
+                    raise TequilaException(
+                        'For simulation, only state vector simulators are supported; recieved device={}, you might have forgoten to set the samples keyword - e.g. (device={}, samples=1000). If not set, tequila assumes that full wavefunction simualtion is demanded which is not compatible with qiskit devices or fake devices except for device=statevector'.format(
+                            self.device, self.device))
                 else:
                     qiskit_backend = self.retrieve_device(self.device)
         else:
@@ -279,22 +315,16 @@ class BackendCircuitQiskit(BackendCircuit):
         if "optimization_level" in kwargs:
             optimization_level = kwargs['optimization_level']
 
-        opts = {}
-        if initial_state != 0:
-            array = numpy.zeros(shape=[2 ** self.n_qubits])
-            i = BitStringLSB.from_binary(BitString.from_int(integer=initial_state, nbits=self.n_qubits).binary)
-            print(initial_state, " -> ", i)
-            array[i.integer] = 1.0
-            opts = {"initial_statevector": array}
-
-        circuit = self.circuit.bind_parameters(self.resolver)
+        circuit = self.circuit.assign_parameters(self.resolver)
+        circuit = self.add_state_init(circuit, initial_state)
+        circuit.save_statevector()
+        circuit = transpile(circuit, qiskit_backend)
+        backend_result = qiskit_backend.run(circuit, optimization_level=optimization_level).result()
 
-        qiskit_job = qiskit_backend.run(circuit,optimization_level=optimization_level,**opts)
+        return QubitWaveFunction.from_array(array=backend_result.get_statevector(circuit).data, numbering=self.numbering)
 
-        backend_result = qiskit_job.result()
-        return QubitWaveFunction.from_array(arr=backend_result.get_statevector(circuit), numbering=self.numbering)
-
-    def do_sample(self, circuit: qiskit.QuantumCircuit, samples: int, read_out_qubits, *args, **kwargs) -> QubitWaveFunction:
+    def do_sample(self, circuit: qiskit.QuantumCircuit, samples: int, read_out_qubits, initial_state=0, *args,
+                  **kwargs) -> QubitWaveFunction:
         """
         Helper function for performing sampling.
         Parameters
@@ -303,6 +333,8 @@ class BackendCircuitQiskit(BackendCircuit):
             the circuit from which to sample.
         samples:
             the number of samples to take.
+        initial_state:
+            initial state of the circuit
         args
         kwargs
 
@@ -315,27 +347,28 @@ class BackendCircuitQiskit(BackendCircuit):
         if 'optimization_level' in kwargs:
             optimization_level = kwargs['optimization_level']
         if self.device is None:
-            qiskit_backend = self.retrieve_device('aer_simulator')
+            qiskit_backend = self.retrieve_device(self.STATEVECTOR_DEVICE_NAME)
         else:
             qiskit_backend = self.retrieve_device(self.device)
 
-        if isinstance(qiskit_backend,IBMQBackend):
+        if HAS_IBMQ and isinstance(qiskit_backend, IBMBackend):
             if self.noise_model is not None:
-                raise TequilaException('Cannot combine backend {} with custom noise models.'.format(str(qiskit_backend)))
-            circuit = circuit.bind_parameters(self.resolver)  # this is necessary in spite of qiskit "fixing" it
+                raise TequilaException(
+                    'Cannot combine backend {} with custom noise models.'.format(str(qiskit_backend)))
+            circuit = circuit.assign_parameters(self.resolver)  # this is necessary in spite of qiskit "fixing" it
             circuit = qiskit.transpile(circuit, qiskit_backend)
-            return self.convert_measurements(qiskit_backend.run(circuit,shots=samples,
-                                                            optimization_level=optimization_level),
+            return self.convert_measurements(qiskit_backend.run(circuit, shots=samples,
+                                                                optimization_level=optimization_level),
                                              target_qubits=read_out_qubits)
         else:
-            if isinstance(qiskit_backend, qiskit.test.mock.FakeBackend):
-                circuit = circuit.bind_parameters(self.resolver)  # this is necessary in spite of qiskit "fixing" it
+            if isinstance(qiskit_backend, qiskit.providers.fake_provider.FakeBackend):
+                circuit = circuit.assign_parameters(self.resolver)  # this is necessary in spite of qiskit "fixing" it
                 coupling_map = qiskit_backend.configuration().coupling_map
                 from_back = qiskitnoise.NoiseModel.from_backend(qiskit_backend)
                 if self.noise_model is not None:
                     from_back = self.noise_model
                 basis = from_back.basis_gates
-                use_backend = self.retrieve_device('aer_simulator')
+                use_backend = self.retrieve_device(self.STATEVECTOR_DEVICE_NAME)
                 use_backend.set_options(noise_model=from_back)
                 circuit = qiskit.transpile(circuit, backend=use_backend,
                                            basis_gates=basis,
@@ -343,23 +376,23 @@ class BackendCircuitQiskit(BackendCircuit):
                                            optimization_level=optimization_level
                                            )
 
-                job=qiskit_backend.run(circuit, shots=samples)
-                return self.convert_measurements(job,target_qubits=read_out_qubits)
+                job = qiskit_backend.run(circuit, shots=samples)
+                return self.convert_measurements(job, target_qubits=read_out_qubits)
             else:
                 if self.noise_model is not None:
                     qiskit_backend.set_options(noise_model=self.noise_model)  # fits better with our methodology.
                     use_basis = full_basis
                 else:
                     use_basis = qiskit_backend.configuration().basis_gates
-                circuit = circuit.bind_parameters(self.resolver)  # this is necessary -- see qiskit-aer issue 1346
+                circuit = circuit.assign_parameters(self.resolver)  # this is necessary -- see qiskit-aer issue 1346
+                circuit = self.add_state_init(circuit, initial_state)
                 circuit = qiskit.transpile(circuit, backend=qiskit_backend,
                                            basis_gates=use_basis,
                                            optimization_level=optimization_level
                                            )
 
                 job = qiskit_backend.run(circuit, shots=samples)
-                return self.convert_measurements(job,
-                                                 target_qubits=read_out_qubits)
+                return self.convert_measurements(job, target_qubits=read_out_qubits)
 
     def convert_measurements(self, backend_result, target_qubits=None) -> QubitWaveFunction:
         """
@@ -374,16 +407,17 @@ class BackendCircuitQiskit(BackendCircuit):
             measurements converted into wave function form.
         """
         qiskit_counts = backend_result.result().get_counts()
-        result = QubitWaveFunction()
+        result = QubitWaveFunction(self.n_qubits, self.numbering)
         # todo there are faster ways
         for k, v in qiskit_counts.items():
-            converted_key = BitString.from_bitstring(other=BitStringLSB.from_binary(binary=k))
-            result._state[converted_key] = v
+            # Qiskit uses LSB bitstrings, but from_binary expects MSB
+            converted_key = BitString.from_binary(k[::-1])
+            result[converted_key] = v
         if target_qubits is not None:
             mapped_target = [self.qubit_map[q].number for q in target_qubits]
             mapped_full = [self.qubit_map[q].number for q in self.abstract_qubits]
             keymap = KeyMapRegisterToSubregister(subregister=mapped_target, register=mapped_full)
-            result = result.apply_keymap(keymap=keymap)
+            result = QubitWaveFunction.from_wavefunction(result, keymap, n_qubits=len(target_qubits))
 
         return result
 
@@ -436,7 +470,8 @@ class BackendCircuitQiskit(BackendCircuit):
             par = float(gate.parameter)
         if gate.is_controlled():
             if len(gate.control) > 2:
-                raise TequilaQiskitException("multi-controls beyond 2 not yet supported for the qiskit backend. Gate was:\n{}".format(gate) )
+                raise TequilaQiskitException(
+                    "multi-controls beyond 2 not yet supported for the qiskit backend. Gate was:\n{}".format(gate))
             ops[1](circuit)(par, self.qubit(gate.control[0]), self.qubit(gate.target[0]))
         else:
             ops[0](circuit)(par, self.qubit(gate.target[0]))
@@ -590,7 +625,7 @@ class BackendCircuitQiskit(BackendCircuit):
         if device is None:
             return
 
-        elif isinstance(device,qiskit.providers.Backend):
+        elif isinstance(device, qiskit.providers.Backend):
             return
 
         elif isinstance(device, dict):

tequila/simulators/simulator_qiskit_gpu.py

@@ -0,0 +1,9 @@
+from tequila.simulators.simulator_qiskit import BackendCircuitQiskit, BackendExpectationValueQiskit
+
+
+class BackendCircuitQiskitGpu(BackendCircuitQiskit):
+    STATEVECTOR_DEVICE_NAME = "aer_simulator_statevector_gpu"
+
+
+class BackendExpectationValueQiskitGpu(BackendExpectationValueQiskit):
+    BackendCircuitType = BackendCircuitQiskitGpu

tequila/simulators/simulator_qlm.py

@@ -395,10 +395,10 @@ class BackendCircuitQLM(BackendCircuit):
         if MY_QLM:
             result = PyLinalg().submit(job)
             statevector = get_statevector(result)
-            return QubitWaveFunction.from_array(arr=statevector, numbering=self.numbering)
+            return QubitWaveFunction.from_array(array=statevector, numbering=self.numbering)
 
         result = LinAlg().submit(job)
-        return QubitWaveFunction.from_array(arr=result.statevector, numbering=self.numbering)
+        return QubitWaveFunction.from_array(array=result.statevector, numbering=self.numbering)
 
     def update_variables(self, variables):
         """
@@ -431,7 +431,7 @@ class BackendCircuitQLM(BackendCircuit):
         QubitWaveFunction:
             measurements converted into wave function form.
         """
-        result = QubitWaveFunction()
+        result = QubitWaveFunction(self.n_qubits, self.numbering)
         shots = int(backend_result.meta_data["nbshots"])
         nbits = backend_result[0].qregs[0].length
         for sample in backend_result:

tequila/simulators/simulator_qulacs.py

@@ -1,9 +1,11 @@
+from typing import Union
+
 import qulacs
 import numbers, numpy
 import warnings
 
 from tequila import TequilaException, TequilaWarning
-from tequila.utils.bitstrings import BitNumbering, BitString, BitStringLSB
+from tequila.utils.bitstrings import BitNumbering, BitString, BitStringLSB, reverse_int_bits
 from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
 from tequila.simulators.simulator_base import BackendCircuit, BackendExpectationValue, QCircuit, change_basis
 from tequila.utils.keymap import KeyMapRegisterToSubregister
@@ -63,6 +65,11 @@ class BackendCircuitQulacs(BackendCircuit):
 
     numbering = BitNumbering.LSB
 
+    quantum_state_class = qulacs.QuantumState
+
+    supports_sampling_initialization = True
+    supports_generic_initialization = True
+
     def __init__(self, abstract_circuit, noise=None, *args, **kwargs):
         """
 
@@ -110,10 +117,17 @@ class BackendCircuitQulacs(BackendCircuit):
 
             self.circuit=self.add_noise_to_circuit(noise)
 
-    def initialize_state(self, n_qubits:int=None) -> qulacs.QuantumState:
+    def initialize_state(self, n_qubits: int = None, initial_state: Union[int, QubitWaveFunction] = None) -> qulacs.QuantumState:
         if n_qubits is None:
             n_qubits = self.n_qubits
-        return qulacs.QuantumState(n_qubits)
+
+        state = self.quantum_state_class(n_qubits)
+        if isinstance(initial_state, int):
+            state.set_computational_basis(reverse_int_bits(initial_state, self.n_qubits))
+        elif isinstance(initial_state, QubitWaveFunction):
+            state.load(initial_state.to_array(self.numbering))
+
+        return state
 
     def update_variables(self, variables):
         """
@@ -130,7 +144,7 @@ class BackendCircuitQulacs(BackendCircuit):
         for k, angle in enumerate(self.variables):
             self.circuit.set_parameter(k, angle(variables))
 
-    def do_simulate(self, variables, initial_state, *args, **kwargs):
+    def do_simulate(self, variables, initial_state: Union[int, QubitWaveFunction], *args, **kwargs):
         """
         Helper function to perform simulation.
 
@@ -148,12 +162,10 @@ class BackendCircuitQulacs(BackendCircuit):
         QubitWaveFunction:
             QubitWaveFunction representing result of the simulation.
         """
-        state = self.initialize_state(self.n_qubits)
-        lsb = BitStringLSB.from_int(initial_state, nbits=self.n_qubits)
-        state.set_computational_basis(BitString.from_binary(lsb.binary).integer)
+        state = self.initialize_state(self.n_qubits, initial_state)
         self.circuit.update_quantum_state(state)
 
-        wfn = QubitWaveFunction.from_array(arr=state.get_vector(), numbering=self.numbering)
+        wfn = QubitWaveFunction.from_array(array=state.get_vector(), numbering=self.numbering)
         return wfn
 
     def convert_measurements(self, backend_result, target_qubits=None) -> QubitWaveFunction:
@@ -170,22 +182,17 @@ class BackendCircuitQulacs(BackendCircuit):
             results transformed to tequila native QubitWaveFunction
         """
 
-        result = QubitWaveFunction()
+        result = QubitWaveFunction(self.n_qubits, self.numbering)
         # todo there are faster ways
 
-
         for k in backend_result:
-            converted_key = BitString.from_binary(BitStringLSB.from_int(integer=k, nbits=self.n_qubits).binary)
-            if converted_key in result._state:
-                result._state[converted_key] += 1
-            else:
-                result._state[converted_key] = 1
+            result[k] += 1
 
         if target_qubits is not None:
             mapped_target = [self.qubit_map[q].number for q in target_qubits]
             mapped_full = [self.qubit_map[q].number for q in self.abstract_qubits]
             keymap = KeyMapRegisterToSubregister(subregister=mapped_target, register=mapped_full)
-            result = result.apply_keymap(keymap=keymap)
+            result = QubitWaveFunction.from_wavefunction(result, keymap, n_qubits=len(target_qubits))
 
         return result
 
@@ -211,9 +218,7 @@ class BackendCircuitQulacs(BackendCircuit):
         QubitWaveFunction:
             the results of sampling, as a Qubit Wave Function.
         """
-        state = self.initialize_state(self.n_qubits)
-        lsb = BitStringLSB.from_int(initial_state, nbits=self.n_qubits)
-        state.set_computational_basis(BitString.from_binary(lsb.binary).integer)
+        state = self.initialize_state(self.n_qubits, initial_state)
         circuit.update_quantum_state(state)
         sampled = state.sampling(samples)
         return self.convert_measurements(backend_result=sampled, target_qubits=self.measurements)
@@ -424,13 +429,15 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
     use_mapping = True
     BackendCircuitType = BackendCircuitQulacs
 
-    def simulate(self, variables, *args, **kwargs) -> numpy.array:
+    def simulate(self, variables, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs) -> numpy.array:
         """
         Perform simulation of this expectationvalue.
         Parameters
         ----------
         variables:
             variables, to be supplied to the underlying circuit.
+        initial_state: int or QubitWaveFunction:
+            the initial state of the circuit
         args
         kwargs
 
@@ -448,7 +455,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             return numpy.asarray[self.H]
 
         self.U.update_variables(variables)
-        state = self.U.initialize_state(self.n_qubits)
+        state = self.U.initialize_state(self.n_qubits, initial_state)
         self.U.circuit.update_quantum_state(state)
         result = []
         for H in self.H:
@@ -490,7 +497,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             result.append(qulacs_H)
         return result
 
-    def sample(self, variables, samples, *args, **kwargs) -> numpy.array:
+    def sample(self, variables, samples, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs) -> numpy.array:
         """
         Sample this Expectation Value.
         Parameters
@@ -499,6 +506,8 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             variables, to supply to the underlying circuit.
         samples: int:
             the number of samples to take.
+        initial_state: int or QubitWaveFunction:
+            the initial state of the circuit
         args
         kwargs
 
@@ -508,13 +517,13 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             the result of sampling as a number.
         """
         self.update_variables(variables)
-        state = self.U.initialize_state(self.n_qubits)
+        state = self.U.initialize_state(self.n_qubits, initial_state)
         self.U.circuit.update_quantum_state(state)
         result = []
-        for H in self._reduced_hamiltonians: # those are the hamiltonians which where non-used qubits are already traced out
+        for H in self._reduced_hamiltonians:  # those are the hamiltonians which where non-used qubits are already traced out
             E = 0.0
             if H.is_all_z() and not self.U.has_noise:
-                E = super().sample(samples=samples, variables=variables, *args, **kwargs)
+                E = super().sample(samples=samples, variables=variables, initial_state=initial_state, *args, **kwargs)
             else:
                 for ps in H.paulistrings:
                     # change basis, measurement is destructive so the state will be copied
@@ -525,8 +534,8 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
                     qbc = self.U.create_circuit(abstract_circuit=bc, variables=None)
                     Esamples = []
                     for sample in range(samples):
-                        if self.U.has_noise and sample>0:
-                            state = self.U.initialize_state(self.n_qubits)
+                        if self.U.has_noise and sample > 0:
+                            state = self.U.initialize_state(self.n_qubits, initial_state)
                             self.U.circuit.update_quantum_state(state)
                             state_tmp = state
                         else:
@@ -535,7 +544,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
                             qbc.update_quantum_state(state_tmp)
                         ps_measure = 1.0
                         for idx in ps.keys():
-                            assert idx in self.U.abstract_qubits # assert that the hamiltonian was really reduced
+                            assert idx in self.U.abstract_qubits  # assert that the hamiltonian was really reduced
                             M = qulacs.gate.Measurement(self.U.qubit(idx), self.U.qubit(idx))
                             M.update_quantum_state(state_tmp)
                             measured = state_tmp.get_classical_value(self.U.qubit(idx))

tequila/simulators/simulator_qulacs_gpu.py

@@ -1,16 +1,18 @@
 import qulacs
+from qulacs_core import QuantumStateGpu
+
 from tequila import TequilaException
 from tequila.simulators.simulator_qulacs import BackendCircuitQulacs, BackendExpectationValueQulacs
 
+
 class TequilaQulacsGpuException(TequilaException):
     def __str__(self):
         return "Error in qulacs gpu backend:" + self.message
 
+
 class BackendCircuitQulacsGpu(BackendCircuitQulacs):
-    def initialize_state(self, n_qubits:int=None) -> qulacs.QuantumState:
-        if n_qubits is None:
-            n_qubits = self.n_qubits
-        return qulacs.QuantumStateGpu(n_qubits)
+    quantum_state_class = QuantumStateGpu
+
 
 class BackendExpectationValueQulacsGpu(BackendExpectationValueQulacs):
     BackendCircuitType = BackendCircuitQulacsGpu