Acasă/Simulatoare

Simulatoare cuantice gratuite

Rulează circuite cuantice pe simulatoare puternice — local pe mașina ta sau în cloud. Toate opțiunile de mai jos sunt complet gratuite.

Toate gratuiteLocal și cloudAccelerat de GPU (unele)

⬛

Qiskit Aer

GratuitLocalPână la 30+ qubiți

Simulatorul de circuite cuantice de înaltă performanță al IBM. Aer include mai multe metode de simulare: vector de stare, stabilizator, matrice de densitate, MPS și stabilizator extins. Accelerare GPU disponibilă prin AerCuda.

Qubiți max

30+ (vector de stare)

Backend

CPU / GPU

Cost

Gratuit

Platformă

Local

bash

pip install qiskit-aer        # CPU
pip install qiskit-aer-gpu    # GPU (CUDA)

python

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
print(result.get_counts())  # {'00': 501, '11': 499}

Platformă deschisă Ghid SDK

☁️

IBM Quantum (simulatoare cloud)

GratuitCloudPână la 5000 qubiți

Platforma IBM Quantum oferă gratuit simulatoare găzduite în cloud. Simulatorul ibmq_qasm_simulator poate simula până la 32 de qubiți, în timp ce simulatorul Statevector gestionează circuite mari. Înregistrează-te pentru un cont IBM Quantum gratuit.

Qubiți max

5000 (mod MPS)

Backend

IBM Cloud

Cost

Nivel gratuit

Cont

Necesar

bash

pip install qiskit
pip install qiskit-ibm-runtime

python

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler

# Free IBM Quantum account needed
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.least_busy(simulator=True)

sampler = Sampler(mode=backend)
job = sampler.run([qc])
result = job.result()

Platformă deschisă Ghid SDK

🔵

Google Cirq (simulator)

GratuitLocalVector de stare

Simulatorul integrat al Cirq oferă simulare exactă a vectorului de stare și a matricei de densitate local. cirq.Simulator și cirq.DensityMatrixSimulator sunt simple de utilizat, iar cirq.CliffordSimulator gestionează eficient circuitele stabilizatoare.

Qubiți max

~25 (vector de stare)

Backend

CPU (NumPy)

Cost

Gratuit

Platformă

Local

bash

pip install cirq

python

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, q1, key='result')
)

sim = cirq.Simulator()
result = sim.run(circuit, repetitions=1000)
print(result.histogram(key='result'))

Platformă deschisă Ghid SDK

🪙

PennyLane (default.qubit)

GratuitLocalJAX/PyTorchDiferențiabil

default.qubit de la PennyLane este un simulator pur NumPy, ideal pentru cercetarea în ML cuantic. Folosește lightning.qubit pentru accelerare C++ sau lightning.gpu pentru accelerare GPU NVIDIA. Toate sunt gratuite, locale și diferențiabile.

Qubiți max

20+ (default.qubit)

Backend

NumPy / C++ / GPU

Cost

Gratuit

Platformă

Local

bash

pip install pennylane              # default.qubit
pip install pennylane-lightning     # lightning.qubit (C++)
pip install pennylane-lightning-gpu  # GPU

python

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=2)
# For GPU: qml.device("lightning.gpu", wires=2)

@qml.qnode(dev)
def bell_state():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.probs(wires=[0, 1])

print(bell_state())  # [0.5, 0., 0., 0.5]

Platformă deschisă Ghid SDK

🟢

NVIDIA CUDA-Q

GratuitGPUCPUMulti-GPU

Platforma de calcul cuantic open source a NVIDIA. CUDA-Q oferă simulare accelerată de GPU care poate gestiona circuite de peste 30 de qubiți cu ordine de mărime mai rapid decât simulatoarele CPU. Rulează gratuit local pe orice GPU NVIDIA.

Qubiți max

34+ (un singur GPU)

Backend

GPU NVIDIA

Cost

Gratuit (open source)

Accelerare

100-10000× vs CPU

bash

pip install cudaq  # Requires CUDA-capable GPU
# Or use Docker: nvcr.io/nvidia/nightly/cuda-quantum

python

import cudaq

@cudaq.kernel
def bell_state():
    qvec = cudaq.qvector(2)
    h(qvec[0])
    cx(qvec[0], qvec[1])
    mz(qvec)

counts = cudaq.sample(bell_state, shots_count=1000)
print(counts)  # { 00:507 11:493 }

Platformă deschisă Ghid SDK

🟠

Amazon Braket (simulatoare cloud)

GratuitCloudSV1 / DM1 / TN1

AWS Braket oferă trei simulatoare cloud gestionate: SV1 (vector de stare, până la 34 qubiți), DM1 (matrice de densitate, până la 17 qubiți) și TN1 (rețea tensorială, până la 50 qubiți). Simulatorul local este complet gratuit; simulatoarele cloud costă ~0,075 $/sarcină + calcul.

Qubiți max SV1

Qubiți max TN1

Sim locală

Gratuit (nelimitat)

Sim cloud

~0,075 $/sarcină

bash

pip install amazon-braket-sdk

python

from braket.circuits import Circuit
from braket.devices import LocalSimulator

# Completely free local simulator
device = LocalSimulator()

circuit = Circuit().h(0).cnot(0, 1)
task = device.run(circuit, shots=1000)
result = task.result()
print(result.measurement_counts)

Platformă deschisă Ghid SDK

💡

Folosește HLQuantum pentru a viza orice simulator

În loc să înveți separat API-ul de simulator al fiecărui SDK, folosește HLQuantum pentru a scrie un singur circuit și a comuta între Qiskit Aer, Cirq, PennyLane, CUDA-Q și altele cu un singur parametru.

python

hlq.run(qc, backend="qiskit") # Qiskit Aer hlq.run(qc, backend="cirq") # Cirq simulator hlq.run(qc, backend="cudaq") # NVIDIA GPU sim hlq.run(qc, backend="pennylane") # Lightning.qubit

Ghid HLQuantum