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

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
 
-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,18 @@ 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.assign_parameters(self.resolver)
 
-        circuit = self.circuit.bind_parameters(self.resolver)
+        circuit = self.add_state_init(circuit, initial_state)
 
-        qiskit_job = qiskit_backend.run(circuit,optimization_level=optimization_level,**opts)
+        circuit.save_statevector()
 
-        backend_result = qiskit_job.result()
-        return QubitWaveFunction.from_array(arr=backend_result.get_statevector(circuit), numbering=self.numbering)
+        backend_result = qiskit_backend.run(circuit, optimization_level=optimization_level).result()
 
-    def do_sample(self, circuit: qiskit.QuantumCircuit, samples: int, read_out_qubits, *args, **kwargs) -> QubitWaveFunction:
+        return QubitWaveFunction.from_array(array=backend_result.get_statevector(circuit).data, numbering=self.numbering)
+
+    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 +335,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
 
@@ -319,17 +353,18 @@ class BackendCircuitQiskit(BackendCircuit):
         else:
             qiskit_backend = self.retrieve_device(self.device)
 
-        if isinstance(qiskit_backend,IBMQBackend):
+        if 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:
@@ -343,23 +378,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 +409,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 +472,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 +627,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)

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

tequila/simulators/simulator_symbolic.py

@@ -42,37 +42,30 @@ class BackendCircuitSymbolic(BackendCircuit):
 
     @classmethod
     def apply_gate(cls, state: QubitWaveFunction, gate: QGate, qubits: dict, variables) -> QubitWaveFunction:
-        result = QubitWaveFunction()
         n_qubits = len(qubits.keys())
+        result = sympy.Integer(1) * QubitWaveFunction(n_qubits)
         for s, v in state.items():
-            s.nbits = n_qubits
-            result += v * cls.apply_on_standard_basis(gate=gate, basisfunction=s, qubits=qubits, variables=variables)
+            result += v * cls.apply_on_standard_basis(gate=gate, basis_state=s, qubits=qubits, variables=variables)
         return result
 
     @classmethod
-    def apply_on_standard_basis(cls, gate: QGate, basisfunction: BitString, qubits:dict, variables) -> QubitWaveFunction:
-
-        basis_array = basisfunction.array
-        if gate.is_controlled():
-            do_apply = True
-            check = [basis_array[qubits[c]] == 1 for c in gate.control]
-            for c in check:
-                if not c:
-                    do_apply = False
-            if not do_apply:
-                return QubitWaveFunction.from_int(basisfunction)
+    def apply_on_standard_basis(cls, gate: QGate, basis_state: BitString, qubits:dict, variables) -> QubitWaveFunction:
+        n_qubits = len(qubits.keys())
+        basis_array = basis_state.array
+        if gate.is_controlled() and not all(basis_array[qubits[c]] == 1 for c in gate.control):
+            return QubitWaveFunction.from_basis_state(n_qubits, basis_state)
 
         if len(gate.target) > 1:
             raise Exception("Multi-targets not supported for symbolic simulators")
 
-        result = QubitWaveFunction()
+        result = sympy.Integer(1) * QubitWaveFunction(n_qubits)
         for tt in gate.target:
             t = qubits[tt]
             qt = basis_array[t]
             a_array = copy.deepcopy(basis_array)
             a_array[t] = (a_array[t] + 1) % 2
-            current_state = QubitWaveFunction.from_int(basisfunction)
-            altered_state = QubitWaveFunction.from_int(BitString.from_array(a_array))
+            current_state = QubitWaveFunction.from_basis_state(n_qubits, basis_state)
+            altered_state = QubitWaveFunction.from_basis_state(n_qubits, BitString.from_array(a_array))
 
             fac1 = None
             fac2 = None
@@ -115,22 +108,21 @@ class BackendCircuitSymbolic(BackendCircuit):
         count = 0
         for q in self.abstract_circuit.qubits:
             qubits[q] = count
-            count +=1
+            count += 1
 
         n_qubits = len(self.abstract_circuit.qubits)
 
         if initial_state is None:
-            initial_state = QubitWaveFunction.from_int(i=0, n_qubits=n_qubits)
-        elif isinstance(initial_state, int):
-            initial_state = QubitWaveFunction.from_int(initial_state, n_qubits=n_qubits)
+            initial_state = 0
+        initial_state = QubitWaveFunction.from_basis_state(n_qubits, initial_state)
 
         result = initial_state
         for g in self.abstract_circuit.gates:
             result = self.apply_gate(state=result, gate=g, qubits=qubits, variables=variables)
 
-        wfn = QubitWaveFunction()
+        wfn = QubitWaveFunction(n_qubits)
         if self.convert_to_numpy:
-            for k,v in result.items():
+            for k, v in result.items():
                 wfn[k] = complex(v)
         else:
             wfn = result

tequila/utils/bitstrings.py

@@ -1,6 +1,7 @@
 from enum import Enum
 from typing import List
 from functools import total_ordering
+from math import ceil, log2
 
 
 class BitNumbering(Enum):
@@ -35,7 +36,7 @@ class BitString:
 
     def update_nbits(self):
         current = self.nbits
-        min_needed = len(format(self._value, 'b'))
+        min_needed = ceil(log2(self._value + 1))
         self._nbits = max(current, min_needed)
         return self
 
@@ -177,15 +178,28 @@ class BitStringLSB(BitString):
         return BitNumbering.LSB
 
 
+def reverse_int_bits(x: int, nbits: int) -> int:
+    if nbits is None:
+        nbits = x.bit_length()
+    assert nbits <= 32
+
+    x = ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1)
+    x = ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2)
+    x = ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4)
+    x = ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >> 8)
+    x = ((x & 0x0000FFFF) << 16) | ((x & 0xFFFF0000) >> 16)
+    return x >> (32 - nbits)
+
+
 def initialize_bitstring(integer: int, nbits: int = None, numbering_in: BitNumbering = BitNumbering.MSB,
-                         numbering_out: BitNumbering = BitNumbering.MSB):
-    if numbering_in == BitNumbering.MSB:
-        if numbering_out == BitNumbering.MSB:
-            return BitString.from_int(integer=integer, nbits=nbits)
-        else:
-            return BitString.from_binary(binary=BitStringLSB.from_int(integer=integer, nbits=nbits).binary, nbits=nbits)
+                         numbering_out: BitNumbering = None):
+    if numbering_out is None:
+        numbering_out = numbering_in
+
+    if numbering_in != numbering_out:
+        integer = reverse_int_bits(integer, nbits)
+
+    if numbering_out == BitNumbering.MSB:
+        return BitString.from_int(integer=integer, nbits=nbits)
     else:
-        if numbering_out == BitNumbering.LSB:
-            return BitStringLSB.from_int(integer=integer, nbits=nbits)
-        else:
-            return BitStringLSB.from_binary(binary=BitString.from_int(integer=integer, nbits=nbits).binary, nbits=nbits)
+        return BitStringLSB.from_int(integer=integer, nbits=nbits)

tequila/version.py

@@ -1,2 +1,2 @@
-__version__ = "1.9.6"
+__version__ = "1.9.8"
 __author__ = "Tequila Developers "