further small performance upgrades

Author: positr0nium

src/qrisp/arithmetic/adders/adder_tools.py

@@ -161,7 +161,7 @@ def ammended_adder(qf2, qf1, *args, ignore_rounding_error = False, ignore_overfl
         elif isinstance(qf2, (list, QuantumVariable)):
 
             if len(qf2) < len(qf1):
-                ancilla_var = QuantumVariable(len(qf1)-len(qf2))
+                ancilla_var = QuantumVariable(len(qf1)-len(qf2), name = "add_ammend_anc*", qs = qf1[0].qs())
                 qf2 = list(qf2) + list(ancilla_var)
 
             raw_inpl_adder(qf2, qf1, *args, **kwargs)
@@ -173,7 +173,7 @@ def ammended_adder(qf2, qf1, *args, ignore_rounding_error = False, ignore_overfl
 
         elif isinstance(qf2, int) and ammend_cl_int:
 
-            ancilla_var = QuantumFloat(len(qf1))
+            ancilla_var = QuantumFloat(len(qf1), name = "add_ammend_anc*", qs = qf1[0].qs())
 
             ancilla_var.encode(qf2 % 2**len(qf1))
 

src/qrisp/arithmetic/adders/gidney/cq_gidney_adder.py

@@ -42,7 +42,7 @@ def cq_gidney_adder(a, b, c_in = None, c_out = None, ctrl = None):
     # (doesn't happen automatically with fast_append = 3)
     merge(b[0].qs())
 
-    with fast_append(1):
+    with fast_append(3):
 
         if isinstance(a, int):
             a = bin_rep(a%2**len(b), len(b))[::-1]

src/qrisp/arithmetic/modular_arithmetic/modular_multiplication.py

@@ -317,21 +317,23 @@ def semi_cl_inpl_mult(a, X, ctrl = None, treat_invalid = False):
     if X == 1:
         return a
 
-    # Create the temporary value    
-    tmp = a.duplicate(qs = a.qs)
 
-    # If treat_invalid is set to True, the function should leave the invalid values
-    # invariant. That is, values that are bigger than the modulus N.
-    
-    # We achieve this by computing a QuantumBool, which indicates wether the value is
-    # invalid and the controlling the multiplication on this QuantumBool.
-    if treat_invalid:
-        a.__class__ = QuantumFloat
-        reduced = a < a.modulus
-        a.__class__ = QuantumModulus
-        ctrl = [ctrl, reduced[0]]
-    
-    with fast_append():
+    with fast_append(3):
+        
+        # Create the temporary value    
+        tmp = a.duplicate(qs = a.qs)
+        
+        # If treat_invalid is set to True, the function should leave the invalid values
+        # invariant. That is, values that are bigger than the modulus N.
+        
+        # We achieve this by computing a QuantumBool, which indicates wether the value is
+        # invalid and the controlling the multiplication on this QuantumBool.
+        if treat_invalid:
+            a.__class__ = QuantumFloat
+            reduced = a < a.modulus
+            a.__class__ = QuantumModulus
+            ctrl = [ctrl, reduced[0]]
+        
         # If the controlled version of this function is required, we perform the swapping
         # strategy from above.
         if ctrl is not None:

src/qrisp/circuit/operation.py

@@ -93,13 +93,8 @@ def __init__(
             params = init_op.params
             definition = init_op.definition
 
-            try:
-                unitary = init_op.unitary
-            except AttributeError:
-                pass
-        else:
-            if name is None:
-                raise Exception("Tried to create a Operation object without name")
+        elif not isinstance(name, str):
+            raise Exception("Tried to create a Operation with name of type({type(name)} (required is str)")
 
         # Name of the operation - this is how the backend behind the interface will
         # identify the operation
@@ -114,9 +109,20 @@ def __init__(
         # List of parameters (also available behind the interface)
         self.params = []
 
-        # Find abstract parameters (ie. sympy expressions and log them)
-        self.abstract_params = set([])
+        # If a definition circuit is given, this means we are supposed to create a
+        # non-elementary operation
+        if definition is not None:
+            # Copy circuit in order to prevent modification
+            # self.definition = QuantumCircuit(init_qc = definition)
+            self.definition = definition
+
+            self.abstract_params = set(definition.abstract_params)
+        else:
+            self.definition = None
+            self.abstract_params = set()
+
 
+        # Find abstract parameters (ie. sympy expressions and log them)
         for par in params:
             if isinstance(par, (float, int, np.floating, np.int32)):
                 pass
@@ -129,20 +135,6 @@ def __init__(
 
             self.params.append(par)
 
-        # If a definition circuit is given, this means we are supposed to create a
-        # non-elementary operation
-        if definition is not None:
-            # Copy circuit in order to prevent modification
-            # self.definition = QuantumCircuit(init_qc = definition)
-            self.definition = definition
-
-            self.abstract_params = self.abstract_params.union(
-                definition.abstract_params
-            )
-
-        else:
-            self.definition = None
-
         # These attributes store some information for the uncomputation algorithm
         # Qfree basically means that the unitary is a permutation matrix
         # (up to local phase shifts). Permeability means that this gate commutes with

src/qrisp/circuit/quantum_circuit.py

@@ -213,17 +213,12 @@ def __init__(self, num_qubits=0, num_clbits=0, name=None):
         object.__setattr__(self, "qubits", [])
         object.__setattr__(self, "clbits", [])
 
-        self.abstract_params = set([])
-
-        if name is None:
-            self.name = "circuit_" + str(id(self))[-5:]
-        else:
-            self.name = name
+        self.abstract_params = set()
 
         if isinstance(num_qubits, int):
             for i in range(num_qubits):
-                self.qubit_index_counter[0] += 1
-                self.qubits.append(Qubit("qb_" + str(self.qubit_index_counter[0])))
+                self.qubits.append(Qubit("qb_" + str(self.qubit_index_counter[0]+i)))
+            self.qubit_index_counter[0] += num_qubits
         else:
             raise Exception(
                 f"Tried to initialize QuantumCircuit with type {type(num_qubits)}"
@@ -237,8 +232,6 @@ def __init__(self, num_qubits=0, num_clbits=0, name=None):
                 f"Tried to initialize QuantumCircuit with type {type(num_clbits)}"
             )
 
-        self.last_qubit_count = -1
-
     # Method to add qubit objects to the circuit
     def add_qubit(self, qubit=None):
         """
@@ -266,16 +259,19 @@ def add_qubit(self, qubit=None):
         """
 
         self.qubit_index_counter += 1
+        
         if qubit is None:
             qubit = Qubit("qb_" + str(self.qubit_index_counter[0]))
+            
+        if self.xla_mode < 2:
+            for qb in self.qubits:
+                if qb.identifier == qubit.identifier:
+                    raise Exception(f"Qubit name {qubit.identifier} already exists")
+        
 
         if not isinstance(qubit, Qubit):
             raise Exception(f"Tried to add type {type(qubit)} as a qubit")
 
-        for qb in self.qubits:
-            if qb.identifier == qubit.identifier:
-                raise Exception(f"Qubit name {qubit.identifier} already exists")
-
         self.qubits.append(qubit)
 
         return self.qubits[-1]
@@ -344,7 +340,7 @@ def to_op(self, name=None):
         """
 
         if name is None:
-            name = self.name
+            name = "circuit" + str(id(self))[:5]
 
         definition = self.copy()
         i = 0
@@ -508,8 +504,6 @@ def copy(self):
 
         return res
 
-        return QuantumCircuit(init_qc=self)
-
     # Returns a copy of self but with no instructions
     def clearcopy(self):
         """

src/qrisp/core/quantum_session.py

@@ -20,7 +20,7 @@
 
 import numpy as np
 
-from qrisp.circuit import Clbit, QuantumCircuit, Qubit, QubitAlloc, QubitDealloc
+from qrisp.circuit import Clbit, QuantumCircuit, Qubit, QubitAlloc, QubitDealloc, Instruction, Operation
 from qrisp.core.session_merging_tools import multi_session_merge
 from qrisp.misc import get_depth_dic
 
@@ -436,16 +436,17 @@ def logic_synth(self, input_qubits, output_qubits, tt, method="best", inv=False)
 
     def __eq__(self, other):
         return id(self.data) == id(other.data)
-
+    
     def append(self, operation_or_instruction, qubits=[], clbits=[]):
         # Check the type of the instruction/operation
-        from qrisp.circuit import Instruction, Operation
-
+        
+        
         if issubclass(operation_or_instruction.__class__, Instruction):
             instruction = operation_or_instruction
             self.append(instruction.op, instruction.qubits, instruction.clbits)
             return
-
+        
+        
         elif issubclass(operation_or_instruction.__class__, Operation):
             operation = operation_or_instruction
 
@@ -466,7 +467,7 @@ def append(self, operation_or_instruction, qubits=[], clbits=[]):
             if operation.name == "qb_dealloc":
                 qubits[0].allocated = False
             return
-
+        
         # Convert arguments (possibly integers) to list
         # The logic here is that the list structure gets preserved ie.
         # [[0, 1] ,2] ==> [[qubit_0, qubit_1], qubit_2]

src/qrisp/environments/custom_control_environment.py

@@ -18,7 +18,7 @@
 
 from qrisp.environments.quantum_environments import QuantumEnvironment
 from qrisp.environments.gate_wrap_environment import GateWrapEnvironment
-from qrisp.circuit import Operation, QuantumCircuit
+from qrisp.circuit import Operation, QuantumCircuit, Instruction
 from qrisp.environments.iteration_environment import IterationEnvironment
 
 def custom_control(func):
@@ -219,16 +219,14 @@ def __init__(self, init_op, targeting_control = False):
 
         if not targeting_control:
             definition = QuantumCircuit(init_op.num_qubits + 1, init_op.num_clbits)
-            definition.append(init_op, definition.qubits[1:], definition.clbits)
+            definition.data.append(Instruction(init_op, definition.qubits[1:], definition.clbits))
 
             Operation.__init__(self, name = "cusc_" + init_op.name, num_qubits = init_op.num_qubits + 1, num_clbits = init_op.num_clbits, definition = definition)
 
             self.init_op = init_op
 
-            self.permeability = {}
+            self.permeability = {i+1 : init_op.permeability[i] for i in range(init_op.num_qubits)}
             self.permeability[0] = True
-            for i in range(init_op.num_qubits):
-                self.permeability[i+1] = init_op.permeability[i]
 
             self.is_qfree = init_op.is_qfree
         else:

src/qrisp/environments/iteration_environment.py

@@ -147,7 +147,7 @@ def __enter__(self):
 
     def __exit__(self, exception_type, exception_value, traceback):
 
-        if set(self.env_qs.qv_list) != self.inital_qvs:
+        if set(self.env_qs.qv_list) != self.inital_qvs and self.iteration_amount > 1:
 
             if exception_value is None:
                 raise Exception(