Correction: Custom Gate Parameter parser and Real Warning in Pauli String real

Author: JulienCalistoTD

mpqp/core/instruction/measurement/pauli_string.py

@@ -183,7 +183,7 @@ def round(self, round_off_till: int = 5) -> PauliString:
         """
         res = PauliString()
         for mono in self.monomials:
-            coef = float(round(mono.coef, round_off_till))
+            coef = float(np.round(float(mono.coef.real), round_off_till))
             if coef != 0:
                 res.monomials.append(PauliStringMonomial(coef, mono.atoms))
             if len(res.monomials) == 0:
@@ -244,7 +244,7 @@ def from_matrix(cls, matrix: Matrix) -> PauliString:
 
         pauli_list = PauliString()
         for i, mat in enumerate(basis):
-            coeff = np.trace(mat.to_matrix().dot(matrix)) / (2**num_qubits)
+            coeff = (np.trace(mat.to_matrix().dot(matrix)) / (2**num_qubits)).real
             if not np.isclose(coeff, 0, atol=atol, rtol=rtol):
                 mono = basis[i] * coeff
                 pauli_list += mono

mpqp/execution/providers/google.py

@@ -49,7 +49,69 @@ def run_google(job: Job) -> Result:
     Returns:
         A Result after submission and execution of the job.
     """
-    return run_local(job) if not job.device.is_remote() else run_google_remote(job)
+    if type(job.device) != GOOGLEDevice:
+        raise ValueError("Job device must be GOOGLEDevice")
+
+    if job.device.is_processor():
+        return run_processor(job)
+    elif job.device.is_remote():
+        return run_google_remote(job)
+    else:
+        return run_local(job)
+
+
+@typechecked
+def run_processor(job: Job) -> Result:
+    """
+    Executes the job locally on processor.
+
+    Args:
+        job : The job to be executed.
+
+    Returns:
+        Result: The result after submission and execution of the job..
+    """
+    cal = load_median_device_calibration(job.device.value)
+    device = create_device_from_processor_id(job.device.value)
+    # noise_props = noise_properties_from_calibration(cal)
+    # noise_model = NoiseModelFromGoogleNoiseProperties(noise_props)
+    sim = QSimSimulator(noise=None)
+    sim_processor = SimulatedLocalProcessor(
+        processor_id=job.device.value,
+        sampler=sim,
+        device=device,
+        calibrations={cal.timestamp // 1000: cal},
+    )
+    sim = SimulatedLocalEngine([sim_processor])
+
+    job_cirq_circuit = job.circuit.to_other_language(
+        Language.CIRQ, processor_id=job.device.value
+    )
+    if not isinstance(job_cirq_circuit, Cirq_circuit):
+        raise ValueError("Circuit must be Cirq_circuit")
+
+    if job.job_type == JobType.STATE_VECTOR:
+        raise NotImplementedError(
+            f"Does not handle {job.job_type} for processor for the moment"
+        )
+    elif job.job_type == JobType.OBSERVABLE:
+        raise NotImplementedError(
+            f"Does not handle {job.job_type} for processor for the moment"
+        )
+    elif job.job_type == JobType.SAMPLE:
+        assert isinstance(job.measure, BasisMeasure)
+        if isinstance(job.measure.basis, ComputationalBasis):
+            result_sim = sim.get_sampler(job.device.value).run(
+                job_cirq_circuit, repetitions=job.measure.shots
+            )
+        else:
+            raise NotImplementedError(
+                "Does not handle other basis than the ComputationalBasis for the moment"
+            )
+    else:
+        raise ValueError(f"Job type {job.job_type} not handled")
+
+    return extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
 
 
 @typechecked
@@ -110,53 +172,23 @@ def run_local(job: Job) -> Result:
     if type(job.device) != GOOGLEDevice:
         raise ValueError("Job device must be GOOGLEDevice")
 
-    if job.device.is_processor():
-        job_cirq_circuit = job.circuit.to_other_language(
-            Language.CIRQ, processor_id=job.device.value
-        )
-    else:
-        job_cirq_circuit = job.circuit.to_other_language(Language.CIRQ)
+    job_cirq_circuit = job.circuit.to_other_language(Language.CIRQ)
+
     if not isinstance(job_cirq_circuit, Cirq_circuit):
         raise ValueError("Circuit must be Cirq_circuit")
 
     sim = Simulator()
 
     if job.job_type == JobType.STATE_VECTOR:
-        if job.device.is_processor():
-            raise NotImplementedError(
-                f"Does not handle {job.job_type} for processor for the moment"
-            )
         result_sim = sim.simulate(job_cirq_circuit)
-        result = extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
     elif job.job_type == JobType.SAMPLE:
         assert isinstance(job.measure, BasisMeasure)
-
         if isinstance(job.measure.basis, ComputationalBasis):
-            if job.device.is_processor():
-                cal = load_median_device_calibration(job.device.value)
-                device = create_device_from_processor_id(job.device.value)
-                # noise_props = noise_properties_from_calibration(cal)
-                # noise_model = NoiseModelFromGoogleNoiseProperties(noise_props)
-                sim = QSimSimulator(noise=None)
-
-                sim_processor = SimulatedLocalProcessor(
-                    processor_id=job.device.value,
-                    sampler=sim,
-                    device=device,
-                    calibrations={cal.timestamp // 1000: cal},
-                )
-                sim = SimulatedLocalEngine([sim_processor])
-
-                result_sim = sim.get_sampler(job.device.value).run(
-                    job_cirq_circuit, repetitions=job.measure.shots
-                )
-            else:
-                result_sim = sim.run(job_cirq_circuit, repetitions=job.measure.shots)
+            result_sim = sim.run(job_cirq_circuit, repetitions=job.measure.shots)
         else:
             raise NotImplementedError(
                 "Does not handle other basis than the ComputationalBasis for the moment"
             )
-        result = extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
     elif job.job_type == JobType.OBSERVABLE:
         assert isinstance(job.measure, ExpectationMeasure)
 
@@ -178,10 +210,9 @@ def run_local(job: Job) -> Result:
                 sim,
                 stopping_criteria=RepetitionsStoppingCriteria(job.measure.shots),
             )
-        result = extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
     else:
         raise ValueError(f"Job type {job.job_type} not handled")
-    return result
+    return extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
 
 
 def extract_result(

mpqp/qasm/qasm_remplace_custom_gate.py

@@ -25,7 +25,9 @@ def parse_custom_gates(qasm_code: str) -> tuple[dict[str, str], str]:
             current_gate_name = line.split()[1]
             current_gate_definition = []
             current_gate_parameters = [
-                elem.replace(",", "") for elem in line.split()[2:][:-1]
+                elem.replace(",", "").replace("{", "")
+                for elem in line.split()[2:]
+                if elem.replace(",", "").replace("{", "")
             ]
             current_gate_definition.append(current_gate_parameters)
             replaced_code = replaced_code.replace(line, "")
@@ -49,7 +51,7 @@ def replace_custom_gates(qasm_code: str) -> str:
 
     Returns:
         str: The QASM code with custom gate calls replaced by their definitions.
-    
+
     Exemple:
         >>> qasm_str = \"\"\"gate MyGate a, b {
                 h a;
@@ -63,7 +65,7 @@ def replace_custom_gates(qasm_code: str) -> str:
 
             measure q -> c;\"\"\"
         >>> print(replace_custom_gates(qasm_str))
-        
+
         qreg q[3];
         creg c[2];
 

tests/qasm/test_qasm_to_cirq.py

@@ -64,10 +64,10 @@
             }
 
             qreg q[3];
-            creg c[2];
+            creg c[3];
 
             MyGate q[0], q[1];
-            MyGate2 q[0], q[1], q[3];
+            MyGate2 q[0], q[1], q[2];
 
             measure q -> c;""",
             [