Qiskit 1.0

Reference: https://qiskit.org/ecosystem/aer/howtos/running_gpu.html

'''

from qiskit import QuantumCircuit, transpile

from qiskit import QuantumCircuit

from qiskit_aer import AerSimulator

from qiskit.circuit.library import QuantumVolume

from qiskit.execute_function import execute

from qiskit_ibm_runtime import SamplerV2 as Sampler

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

import argparse

import time

parser.add_argument("--gpumultiple", default=False, action='store_true', help="Use multiple GPUs for the backend of Aer simulator.")

args = parser.parse_args()

if args.gpu: sim = AerSimulator(method='statevector', device='GPU')

elif args.gpumultiple: sim = AerSimulator(method='statevector', device='GPU', blocking_enable=True, blocking_qubits=18)

else: sim = AerSimulator(method='statevector')

print(f'Simulator: {sim}')

if args.gpu: backend = AerSimulator(method='statevector', device='GPU')

elif args.gpumultiple: backend = AerSimulator(method='statevector', device='GPU', blocking_enable=True, blocking_qubits=18)

else: backend = AerSimulator(method='statevector')

print(f'Simulator: {backend}')

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)

qubits = args.NUM_QUBITS 

t = time.time()

circ = transpile(QuantumVolume(qubits, seed = 0))

circ.measure_all()

qc = QuantumVolume(qubits, seed = 0)

qc.measure_all()

elpsdt1 = time.time() - t

isa_circuit = pm.run(qc)

# setup Sampler

sampler = Sampler(backend)

t = time.time()

# if args.gpu: result = execute(circ, sim, shots=100, blocking_enable=True, blocking_qubits=23).result()

# else: result = execute(circ, sim, shots=100).result()

result = execute(circ, sim, shots=100).result()

# Run the job

job = sampler.run([isa_circuit])

# Grab results from the job

result = job.result()

elpsdt2 = time.time() - t

print(f'N qubits: {qubits}; GPU: {args.gpu}; multiple-GPU: {args.gpumultiple};\nTime elapsed 1:  {int(elpsdt1/60)} min {elpsdt1%60:.2f} sec\nTime elapsed 2:  {int(elpsdt2/60)} min {elpsdt2%60:.2f} sec')

import numpy as np

import time

import os

from qiskit import QuantumCircuit, transpile

from qiskit.providers.jobstatus import JobStatus

from qiskit import QuantumCircuit

from qiskit_ibm_runtime import SamplerV2 as Sampler

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

import argparse

parser = argparse.ArgumentParser()

backend_type = args.backend_type

# Choose the simulator or backend to run the quantum circuit

if backend_type=='ideal':

  # Using ideal simulator, Aer's qasm_simulator (works even without IBMQ account, don't have to wait in a queue)

  from qiskit.providers.aer import QasmSimulator

  backend = QasmSimulator()

    # Using ideal simulator, AerSimulator (works even without IBMQ account, don't have to wait in a queue)

    from qiskit_aer import AerSimulator

    backend = AerSimulator()

elif backend_type=='fake':

    # Using qiskit's fake provider (works even without IBMQ account, don't have to wait in a queue)

  from qiskit.providers import fake_provider

  backend = getattr(fake_provider, 'FakeNairobi')() #  FakePerth  FakeMumbai  FakeWashington

    from qiskit_ibm_runtime.fake_provider import FakeProviderForBackendV2  # or use FakeProvider for V1 fake backends - https://docs.quantum.ibm.com/api/qiskit-ibm-runtime/fake_provider

    backend = FakeProviderForBackendV2().backend("fake_sherbrooke")

elif backend_type=='real-ibm':

  # Using the latest qiskit_ibm_provider

    # Using the latest qiskit_ibm_runtime

    #### IF YOU HAVE AN IBMQ ACCOUNT (using an actual backend) #####

  from qiskit_ibm_provider import IBMProvider

    from qiskit_ibm_runtime import QiskitRuntimeService

  # save your IBMProvider accout for future loading

    # save your IBM accout for future loading

    API_KEY = os.getenv('IBMQ_API_KEY')

    instance = os.getenv('IBMQ_INSTANCE')

  IBMProvider.save_account(instance=instance, token=API_KEY, overwrite=True)

    # save your QiskitRuntimeService accout for future loading

    QiskitRuntimeService.save_account(

      token=API_KEY,

      overwrite=True

    )

  provider = IBMProvider()

  backend = provider.get_backend("simulator_statevector")  # ibm_nairobi  simulator_statevector

    service = QiskitRuntimeService()

    backend = service.backend("ibm_sherbrooke")

else:

    raise Exception(f'Backend type \'{backend_type}\' not implemented.')

######################################

# Create a Quantum Circuit acting on the q register

circuit = QuantumCircuit(2, 2)

circuit = QuantumCircuit(2)

# Add a H gate on qubit 0

circuit.h(0)

circuit.cx(0, 1)

# Map the quantum measurement to the classical bits

circuit.measure([0,1], [0,1])

circuit.measure_all()

# compile the circuit down to low-level QASM instructions

# supported by the backend (not needed for simple circuits)

compiled_circuit = transpile(circuit, backend)

# Execute the circuit on the qasm simulator

job = backend.run(compiled_circuit, shots=1000)

# Make a "waiting in queue" message

while job.status() is not JobStatus.DONE:

    print("Job status is", job.status() )

    time.sleep(30)

print("Job status is", job.status() )

# Circuits must obey the ISA of the backend.

# Convert to ISA circuits

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)

isa_circuit = pm.run(circuit)

# setup Sampler

sampler = Sampler(backend)

# Run the job

job = sampler.run([isa_circuit])

# Grab results from the job

result = job.result()

# Returns counts

counts = result.get_counts(compiled_circuit)

print("\nTotal count for 00 and 11 are:",counts)

print(f"\nTotal count for 00 and 11 are: {result[0].data.meas.get_counts()}")

# Draw the circuit

print(circuit.draw())