uniqc.backend_adapter.task.adapters.dummy_adapter module

Dummy adapter for local simulation without real quantum hardware.

This adapter provides a drop-in replacement for cloud backends using local simulation. It’s useful for: - Development and testing without cloud access - Offline development - Quick prototyping and debugging - Running circuits when API tokens are not available

The dummy adapter uses the built-in OriginIR simulator to execute circuits and returns results in the same format as cloud backends.

Usage:

from uniqc.backend_adapter.task.adapters.dummy_adapter import DummyAdapter

# Create adapter with default settings (perfect simulator) adapter = DummyAdapter()

# Noisy simulation from chip characterization from uniqc.backend_adapter.task.adapters.originq_adapter import OriginQAdapter originq = OriginQAdapter() chip = originq.get_chip_characterization(“origin:wuyuan:d5”) adapter = DummyAdapter(chip_characterization=chip)

# Explicit noise model adapter = DummyAdapter(noise_model={‘depol_1q’: 0.01, ‘depol_2q’: 0.05})

# Submit and query (results are immediately available) task_id = adapter.submit(originir_circuit, shots=1000) result = adapter.query(task_id)

Activate dummy mode by using a backend name prefixed with dummy (e.g. dummy, dummy:originq:WK_C180).

class uniqc.backend_adapter.task.adapters.dummy_adapter.DummyAdapter(noise_model=None, available_qubits=None, available_topology=None, chip_characterization=None, backend_id='dummy', simulator_kind='default', simulator_kwargs=None)

Bases: QuantumAdapter

Local simulator adapter that mimics cloud backends.

This adapter executes circuits locally using the built-in OriginIR simulator instead of submitting to real quantum hardware. It provides the same interface as cloud adapters, making it a drop-in replacement.

Features: - Immediate result availability (no waiting for queue) - Optional noise simulation from chip characterization or explicit model - Same result format as cloud backends - Deterministic task IDs (based on circuit hash)

Variables:

• name (str) – Adapter identifier (‘dummy’).

• chip_characterization – Optional chip characterization for realistic noise.

• noise_model – Optional explicit noise configuration dict.

• available_qubits – List of qubit indices available for simulation.

Parameters:

• noise_model (dict[str, Any] | None)

• available_qubits (list[int] | int | None)

• available_topology (list[list[int]] | None)

• chip_characterization (ChipCharacterization | None)

• backend_id (str)

• simulator_kind (str)

• simulator_kwargs (dict[str, Any] | None)

Example

>>> from uniqc.backend_adapter.task.adapters.originq_adapter import OriginQAdapter
>>> originq = OriginQAdapter()
>>> chip = originq.get_chip_characterization("origin:wuyuan:d5")
>>> adapter = DummyAdapter(chip_characterization=chip)
>>> task_id = adapter.submit("QINIT 2\nH q[0]\nCNOT q[0] q[1]\nMEASURE")
>>> result = adapter.query(task_id)
>>> print(result['status'])
'success'

clear_cache()

Clear the internal result cache.

Return type:

None

dry_run(originir, *, shots=1000, **kwargs)

Dry-run validation for the dummy local simulator.

For simulator_kind='default' the dummy adapter always succeeds — it accepts any valid OriginIR string and simulates it locally. For simulator_kind='mps' we additionally enforce nearest-neighbour 2-qubit gates, surfaced here rather than at submit time so cloud- style workflows fail fast.

Note

Any dry-run success followed by actual submission failure is a critical bug. Please report it at the UnifiedQuantum issue tracker.

Parameters:

• originir (str)

• shots (int)

• kwargs (Any)

Return type:

DryRunResult

is_available()

Check if the dummy adapter is available.

Returns:

True if the C++ simulation backend is available (or the MPS path is selected, which has no C++ requirement).

Return type:

bool

name: str = 'dummy'

query(taskid)

Retrieve the cached result for a task.

Since dummy tasks are executed immediately on submission, results are always available instantly.

Parameters:

taskid (str) – Task identifier.

Returns:

Result dict with ‘status’ and ‘result’ (or ‘error’) keys.

Return type:

dict[str, Any]

query_batch(taskids)

Query multiple tasks and merge results.

Parameters:

taskids (list[str]) – List of task identifiers.

Returns:

Combined result dict with overall status and merged results.

Return type:

dict[str, Any]

simulate_pmeasure(originir)

Return exact measurement probabilities (noiseless or noisy).

Unlike _simulate (which uses shot sampling), this always returns the exact probability vector from simulate_pmeasure — no sampling noise. This is the correct method for fidelity computation where you compare two exact distributions.

For simulator_kind='mps' this materialises a dense vector and so is bounded to <= 24 measured qubits; route larger circuits through submit() (which calls _simulate() and uses MPS sampling).

Parameters:

originir (str) – Circuit in OriginIR format.

Returns:

List of probabilities (length = 2 ** measured_qubits).

Return type:

list[float]

submit(circuit, *, shots=1000, **kwargs)

Simulate a circuit locally and cache the result.

The circuit is executed immediately using the local simulator, and results are cached for later retrieval via query().

Parameters:

• circuit (str) – Circuit in OriginIR format (or pre-translated).

• shots (int) – Number of measurement shots.

• **kwargs (Any) – Additional parameters (ignored for dummy adapter).

Returns:

Task ID for result retrieval.

Return type:

str

submit_batch(circuits, *, shots=1000, **kwargs)

Simulate multiple circuits locally.

Parameters:

• circuits (list[str]) – List of circuits in OriginIR format.

• shots (int) – Number of measurement shots per circuit.

• **kwargs (Any) – Additional parameters (ignored).

Returns:

List of task IDs, one per circuit.

Return type:

list[str]

translate_circuit(originir)

Return the OriginIR string unchanged.

The dummy adapter accepts OriginIR directly, so no translation needed.

Parameters:

originir (str) – Circuit in OriginIR format.

Returns:

The same OriginIR string.

Return type:

str