Cirq documentation + format

Author: JulienCalistoTD

docs/execution-extras.rst

@@ -10,6 +10,7 @@ for you are most likely:
 - IBM's :func:`get_all_job_ids<mpqp.execution.connection.ibm_connection.get_all_job_ids>`;
 - Eviden's :func:`get_all_job_ids<mpqp.execution.connection.qlm_connection.get_all_job_ids>`;
 - AWS's :func:`get_all_task_ids<mpqp.execution.connection.aws_connection.get_all_task_ids>`;
+- Google's :func:`get_all_task_ids<mpqp.execution.connection.google_connection.get_all_task_ids>`;
 - The :ref:`con-setup` section.
 
 Provider specifics
@@ -49,16 +50,29 @@ __________
 AWS
 ^^^
 
+Connection
+__________
+
+.. automodule:: mpqp.execution.connection.aws_connection
+
+Execution
+__________
+
 .. automodule:: mpqp.execution.providers.aws
 
+Google
+^^^^^^
+
 Connection
 __________
 
-.. automodule:: mpqp.execution.connection.aws_connection
+.. automodule:: mpqp.execution.connection.google_connection
 
 Execution
 __________
 
+.. automodule:: mpqp.execution.providers.google
+
 .. _con-setup:
 
 Connection setup script 
@@ -70,3 +84,4 @@ On disk configuration manager
 -----------------------------
 
 .. automodule:: mpqp.execution.connection.env_manager
+

docs/qasm.rst

@@ -130,13 +130,17 @@ OpenQASM 2.0 code. This feature enables users to seamlessly transition
 their quantum circuits from OpenQASM to Cirq, leveraging Cirq's capabilities
 and features.
 
-At present, the Cirq parser lacks native support for certain OpenQASM 2.0 
-operations such as ``cu1``, ``crz``, ``cu3``, ``reset``, and ``u0``. 
+the Cirq parser lacks native support for certain OpenQASM 2.0 operations such as
+``cu1``, ``crz``, ``cu3``, ``reset``, ``u0``, ``p``, ``cp``, ``u``, ``rzz``, 
+``rxx`` and custom ``gate``. 
 To address this limitation, we've temporarily incorporated these gates directly 
-into the parser. This ensures seamless generation of circuits from QASM code 
+into the parser and for the custom gate we replace directly by native gate in 
+the qasm str. This ensures seamless generation of circuits from QASM code 
 using the qasm2_to_cirq_Circuit function.
 
 :func:`qasm2_to_cirq_Circuit<mpqp.qasm.qasm_to_cirq.qasm2_to_cirq_Circuit>` to generate
 the circuit from the qasm code.
 
 .. autofunction:: mpqp.qasm.qasm_to_cirq.qasm2_to_cirq_Circuit
+
+:func:`replace_custom_gates<mpqp.qasm.remplace_custom_gates.replace_custom_gates>` t Replaces instances of custom gates with their definitions in QASM code.

examples/scripts/observable_paulistring.py

@@ -5,9 +5,9 @@
 from mpqp import QCircuit
 from mpqp.execution import run
 from mpqp.measures import ExpectationMeasure, Observable
-from mpqp.execution.devices import ATOSDevice, IBMDevice, AWSDevice
+from mpqp.execution.devices import IBMDevice, AWSDevice, ATOSDevice, GOOGLEDevice
 
-from mpqp.core.instruction.measurement.pauli_string import I, X, Y, Z, PauliString
+from mpqp.core.instruction.measurement.pauli_string import I, X, Y, Z
 
 obs = Observable(
     np.array(
@@ -23,8 +23,7 @@
 
 ps_obs = Observable(1 * I @ Z + 1 * I @ I)
 
-obs = ps_obs.matrix
-
+print("obs == ps_obs:", obs.pauli_string == ps_obs.pauli_string)
 print(obs)
 print(ps_obs)
 
@@ -38,5 +37,14 @@
 print(circuit)
 
 # Running the computation on myQLM and on Aer simulator, then retrieving the results
-results = run(circuit, [AWSDevice.BRAKET_LOCAL_SIMULATOR])
+results = run(
+    circuit,
+    [
+        ATOSDevice.MYQLM_PYLINALG,
+        ATOSDevice.MYQLM_CLINALG,
+        IBMDevice.AER_SIMULATOR,
+        AWSDevice.BRAKET_LOCAL_SIMULATOR,
+        GOOGLEDevice.CIRQ_LOCAL_SIMULATOR,
+    ],
+)
 print(results)

mpqp/execution/connection/google_connection.py

@@ -7,6 +7,12 @@
 
 
 def test_ionq_connection() -> bool:
+    """
+    Test the connection to the IonQ service.
+    
+    Returns:
+        bool: True if the connection is successful, False otherwise.
+    """
     service = ionq.Service(default_target="simulator")
     try:
         service.list_jobs()
@@ -17,6 +23,12 @@ def test_ionq_connection() -> bool:
 
 
 def config_ionq_account():
+    """
+    Configure the IonQ account by setting the API token.
+    
+    Returns:
+        tuple: A message indicating the result of the configuration and an empty list.
+    """
     was_configured = get_env_variable("GOOGLE_IONQ_CONFIGURED") == "True"
 
     if was_configured:
@@ -46,6 +58,18 @@ def config_ionq_account():
 
 
 def get_google_account_info() -> str:
+    """
+    Get the IonQ API key from the environment variables.
+    
+    Returns:
+        str: A string containing the IonQ API key.
+    """
     ionq_api_key = get_env_variable("IONQ_API_KEY")
 
     return f"""   IONQ_api_key : '{ionq_api_key}'"""
+
+def get_all_job_ids() -> list[str]:
+    # TODO: This function should return a list of all the jobs ids
+
+    #list_jobs : https://quantumai.google/reference/python/cirq_google/engine/Engine#list_jobs
+    return [""]

mpqp/execution/providers/google.py

@@ -49,80 +49,16 @@ def run_google(job: Job) -> Result:
     Returns:
         A Result after submission and execution of the 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)
+    return run_local(job) if not job.device.is_remote() else run_google_remote(job)
 
 
 @typechecked
 def run_google_remote(job: Job) -> Result:
 
-    if type(job.device) != GOOGLEDevice:
-        raise ValueError("Job device must be GOOGLEDevice")
+    assert type(job.device) == GOOGLEDevice
 
     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")
+    assert isinstance(job_cirq_circuit, Cirq_circuit)
 
     if job.device.is_ionq():
         if job.job_type != JobType.SAMPLE:
@@ -151,8 +87,7 @@ def run_google_remote(job: Job) -> Result:
             f" does not handle {job.device} for the moment only ionq is supported"
         )
 
-    result = extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
-    return result
+    return extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
 
 
 @typechecked
@@ -169,22 +104,22 @@ def run_local(job: Job) -> Result:
     Raises:
         ValueError: If the job device is not GOOGLEDevice.
     """
-    if type(job.device) != GOOGLEDevice:
-        raise ValueError("Job device must be GOOGLEDevice")
+    assert type(job.device) == GOOGLEDevice
 
-    job_cirq_circuit = job.circuit.to_other_language(Language.CIRQ)
+    if job.device.is_processor():
+        return run_local_processor(job)
 
-    if not isinstance(job_cirq_circuit, Cirq_circuit):
-        raise ValueError("Circuit must be Cirq_circuit")
+    job_cirq_circuit = job.circuit.to_other_language(Language.CIRQ)
+    assert isinstance(job_cirq_circuit, Cirq_circuit)
 
-    sim = Simulator()
+    simulator = Simulator()
 
     if job.job_type == JobType.STATE_VECTOR:
-        result_sim = sim.simulate(job_cirq_circuit)
+        result_sim = simulator.simulate(job_cirq_circuit)
     elif job.job_type == JobType.SAMPLE:
         assert isinstance(job.measure, BasisMeasure)
         if isinstance(job.measure.basis, ComputationalBasis):
-            result_sim = sim.run(job_cirq_circuit, repetitions=job.measure.shots)
+            result_sim = simulator.run(job_cirq_circuit, repetitions=job.measure.shots)
         else:
             raise NotImplementedError(
                 "Does not handle other basis than the ComputationalBasis for the moment"
@@ -195,23 +130,77 @@ def run_local(job: Job) -> Result:
         cirq_obs = job.measure.observable.to_other_language(
             language=Language.CIRQ, circuit=job_cirq_circuit
         )
-
-        if type(cirq_obs) != Cirq_PauliSum:
-            raise ValueError("cirq_obs must be a Cirq_PauliSum object")
+        assert type(cirq_obs) == Cirq_PauliSum
 
         if job.measure.shots == 0:
-            result_sim = sim.simulate_expectation_values(
+            result_sim = simulator.simulate_expectation_values(
                 job_cirq_circuit, observables=cirq_obs
             )
         else:
             result_sim = measure_observables(
                 job_cirq_circuit,
                 cirq_obs,  # type: ignore[reportArgumentType]
-                sim,
+                simulator,
                 stopping_criteria=RepetitionsStoppingCriteria(job.measure.shots),
             )
     else:
         raise ValueError(f"Job type {job.job_type} not handled")
+
+    return extract_result(result_sim, job, GOOGLEDevice.CIRQ_LOCAL_SIMULATOR)
+
+
+@typechecked
+def run_local_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.
+    """
+    calibration = 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)
+
+    simulator = QSimSimulator(noise=None)
+    sim_processor = SimulatedLocalProcessor(
+        processor_id=job.device.value,
+        sampler=simulator,
+        device=device,
+        calibrations={calibration.timestamp // 1000: calibration},
+    )
+    simulator = SimulatedLocalEngine([sim_processor])
+
+    job_cirq_circuit = job.circuit.to_other_language(
+        Language.CIRQ, processor_id=job.device.value
+    )
+    assert isinstance(job_cirq_circuit, 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 = simulator.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)
 
 
@@ -246,19 +235,19 @@ def extract_result(
         if job.job_type == JobType.SAMPLE:
             if not isinstance(result, cirq_result):
                 raise ValueError(
-                    f"result must be a cirq_result for job type {job.job_type}"
+                    f"result: {type(result)}, must be a cirq_result for job type {job.job_type}"
                 )
             return extract_result_SAMPLE(result, job, device)
         elif job.job_type == JobType.STATE_VECTOR:
             if not isinstance(result, StateVectorTrialResult):
                 raise ValueError(
-                    f"result must be a cirq_result for job type {job.job_type}"
+                    f"result: {type(result)}, must be a cirq_result for job type {job.job_type}"
                 )
             return extract_result_STATE_VECTOR(result, job, device)
         elif job.job_type == JobType.OBSERVABLE:
             if isinstance(result, cirq_result):
                 raise ValueError(
-                    f"result must be a list[float] | list[ObservableMeasuredResult] for job type {job.job_type}"
+                    f"result: {type(result)}, must be a list[float] | list[ObservableMeasuredResult] for job type {job.job_type}"
                 )
             return extract_result_OBSERVABLE(result, job, device)
         else:

mpqp/execution/providers/ibm.py

@@ -78,8 +78,7 @@ def compute_expectation_value(
         )
     nb_shots = job.measure.shots
     qiskit_observable = job.measure.observable.to_other_language(Language.QISKIT)
-    if not isinstance(qiskit_observable, Operator):
-            raise ValueError("qiskit_observable must be an Operator")
+    assert isinstance(qiskit_observable, Operator)
 
     if nb_shots != 0:
         assert ibm_backend is not None
@@ -253,8 +252,7 @@ def submit_ibmq(job: Job) -> tuple[str, RuntimeJob | IBMJob]:
         assert isinstance(job.measure, ExpectationMeasure)
         estimator = Runtime_Estimator(session=session)
         qiskit_observable = job.measure.observable.to_other_language(Language.QISKIT)
-        if not isinstance(qiskit_observable, Operator):
-            raise ValueError("qiskit_observable must be an Operator")
+        assert isinstance(qiskit_observable, Operator)
 
         ibm_job = estimator.run(
             qiskit_circuit, qiskit_observable, shots=job.measure.shots