Here are the different "Hello World"-type initialization scripts to run on various quantum computing backends. As listed via Oak Ridge National Labs.

IBM Backends:

from qiskit import QuantumCircuit, transpile
from qiskit_ibm_runtime import QiskitRuntimeService, Session, SamplerV2 as Sampler
import time

# Save / Load Credentials (csc431 used as example project)
QiskitRuntimeService.save_account(channel="ibm_quantum", token="API TOKEN GOES HERE", overwrite=True)
service = QiskitRuntimeService(channel="ibm_quantum", instance="ibm-q-ornl/ornl/csc431")

# Get backend (csc431 used as example project)
#backend = service.backend("backend_name_here", instance="ibm-q-ornl/ornl/csc431")
backend = service.least_busy(simulator=False, operational=True)

# Build circuit
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0,1], [0,1])
compiled_circuit = transpile(circuit, backend)

# Submit job
sampl = Sampler(mode=backend)
job = sampl.run([compiled_circuit],shots=1000)

# Wait for job to complete
while str(job.status()) != "DONE":
    print("Job status is", job.status() )
    time.sleep(30)
print("Job status is", job.status() )

# Gather results
result = job.result()
probs = result[0].data.c.get_counts()

print('PubResult: ',result[0])
print("\nProbabilities for 00 and 11 are:",probs)

# Draw the circuit
print(circuit.draw())

Output:

Probabilities for 00 and 11 are: [{0: 0.51, 3: 0.49}]
     ┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1


from pytket.circuit import Circuit
from pytket.extensions.quantinuum import QuantinuumBackend
from pytket.backends import ResultHandle
from pytket.backends.backendresult import BackendResult
import json
import time

# Build the circuit
circuit = Circuit(2, name="Bell Test")
circuit.H(0)
circuit.CX(0, 1)
circuit.measure_all()

# Choose your machine and login (e.g., H1-1E and CSC431 group)
machine = "H1-1E"
backend = QuantinuumBackend(device_name=machine, group="CSC431")
backend.login()

# Status of desired machine
print(machine, "status:", QuantinuumBackend.device_state(device_name=machine))

# List available devices
print([x.device_name for x in QuantinuumBackend.available_devices()])

# Compile circuit
compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=0)
n_shots = 100

# Estimate the cost (H1-1SC, H2-1SC are syntax checkers for H1-1 and H2-1)
# Causes problems when on an HPC compute node w/ proxy settings -- advised to run separately on login node w/o proxy
#backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker="H1-1SC")

# Run the circuit
handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)
print(handle)

# Save your job handle
with open("pytket_example_job_handle.json", "w") as file:
    json.dump(str(handle), file)

# Check status of job (loop is necessary on an HPC compute node w/ proxy settings or else timeouts occur)
while str( backend.circuit_status(handle).status ) != "StatusEnum.COMPLETED":
    status = backend.circuit_status(handle)
    print("Job status is", status.status )
    time.sleep(10)
status = backend.circuit_status(handle)
print("Job status is", status )

# Retrieve and print results
with open("pytket_example_job_handle.json") as file:
    handle_str = json.load(file)
handle = ResultHandle.from_str(handle_str)
result = backend.get_result(handle)
print(result.get_distribution())
print(result.get_counts())

# Save results
with open("pytket_example.json", "w") as file:
    json.dump(result.to_dict(), file)

# Not necesary here, but including syntax
# Load results
with open("pytket_example.json") as file:
    data = json.load(file)
result = BackendResult.from_dict(data)

output:

{(0, 0): 0.57, (1, 1): 0.43}
Counter({(0, 0): 57, (1, 1): 43})

IonQ Backends:

from qiskit import QuantumCircuit
from qiskit_ionq import IonQProvider
import os

# Set your credentials (can also set this externally)
os.environ["IONQ_API_KEY"] = "API KEY GOES HERE"

# Load your IonQ credentials and list backends
provider = IonQProvider()
print(provider.backends())

# Run on "ionq_simulator", "ionq_qpu", "simulator", "qpu.harmony", "qpu.aria-1", "qpu.aria-2"
backend = provider.get_backend("simulator")

# Create a basic Bell State circuit:
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# Run the circuit on IonQ's platform:
job = backend.run(qc, shots=10000)

# Print results
print(job.get_counts())
print(job.get_probabilities())

Output:

{'00': 4933, '11': 5067}
{'00': 0.5, '11': 0.5}

Rigetti

PyQuil allows you to build and execute Quil programs to run on Rigetti QPUs and QVMs. To target QPUs/QVMs locally in a scripting environment, you’ll need to install the Quil SDK locally. An example of how to install the Quil SDK at OLCF in an HPC environment is shown on our Quantum Software on HPC Systems Page.

---> Check out Software on HPC Systems next.

QCUP Hello World Scripts

Rigetti