Qiskit：设备发现、Target 与设备专属选项

import os
from pprint import pprint
from quantum_source_qiskit import QuantumSourceService

service = QuantumSourceService(
    base_url=os.environ["QUANTUM_SOURCE_API_URL"],
)
devices = service.backends(online=True)
print(devices)

# 查询平台目录中的在线真机。
online_qpus = service.backends(online=True, device_type="QPU", min_num_qubits=2)
print(online_qpus)

backend_code = input("填写列表中的设备 short_code：").strip()
backend = service.return_backend(backend_code)
print(type(backend).__name__)
print("设备：", backend.name)
print("线路导出格式：", backend.export_format)

details = service.scheduler.get_backend_class(backend_code)
pprint({
    "short_code": details.short_code,
    "type": details.type,
    "status": details.status,
    "supported_formats": list(details.supported_formats),
    "configuration_schema": dict(details.configuration_schema),
})

caps = backend.capabilities
pprint({
    "num_qubits": caps.num_qubits,
    "available_qubits": list(caps.available_qubits),
    "supported_formats": list(caps.supported_formats),
    "compilation_mode": caps.compilation_mode.value,
    "accepts_logical_circuit": caps.supports_execution_path("logical"),
    "accepts_compiled_physical_circuit": caps.supports_execution_path("physical"),
    "limits": caps.limits,
})

print("支持的输入门：")
pprint([gate.to_dict() for gate in caps.supported_ops])
print("原生门声明：")
pprint([gate.to_dict() for gate in caps.native_ops])
print("平台公布的拓扑边：", list(caps.topology.coupling_map))
print("边是否有方向：", caps.topology.is_directed)
print("Qiskit 实际编译连接：",
      None if backend.coupling_map is None else list(backend.coupling_map.get_edges()))

pprint({
    "timing": dict(caps.timing),
    "noise": dict(caps.noise),
    "features": sorted(caps.features),
    "reset": backend.allows_reset(),
    "mid_circuit_measure": backend.allows_mid_circuit_measure(),
    "dynamic_circuits": backend.allows_dynamic_circuits(),
    "physical_qubits": backend.allows_physical_qubits(),
    "custom_gates": backend.allows_custom_gates(),
})

schema = backend.configuration_schema
properties = schema.get("properties", {})
print("可设置的设备选项：", list(properties))
for option_name, definition in properties.items():
    print(option_name)
    pprint({key: definition[key]
            for key in ("title", "description", "type", "enum", "const", "default", "minimum", "maximum")
            if key in definition})

print("当前 Options：", backend.options)

# 从当前设备的 schema 中读取 mapping 说明。
if "mapping" in properties:
    pprint(properties["mapping"])
    print("是否进入 Options：", hasattr(backend.options, "mapping"))
else:
    print("当前设备没有声明 mapping 选项。")

target = backend.target
print("Target 类型：", type(target).__name__)
print("Target 宽度：", target.num_qubits)
print("Target dt（秒）：", target.dt)
print("Target 指令：", sorted(target.operation_names))
print("是否具备明确的客户端物理 Target：", caps.has_client_target)

# 查看设备已公布的指令位置。
if caps.has_client_target:
    for operation_name in sorted(target.operation_names):
        placements = target[operation_name]
        sample = list(placements.items())[:5]
        print(operation_name, "位置示例：", [qargs for qargs, _ in sample])
        for qargs, instruction_properties in sample:
            print("  ", qargs,
                  "duration(s)=", getattr(instruction_properties, "duration", None),
                  "error=", getattr(instruction_properties, "error", None))

mapping_definition = properties.get("mapping")
mapping_true_allowed = (
    isinstance(mapping_definition, dict)
    and mapping_definition.get("type") == "boolean"
    and ("enum" not in mapping_definition or True in mapping_definition["enum"])
    and ("const" not in mapping_definition or mapping_definition["const"] is True)
)

# A. 设置当前 backend 对象的后续默认值；只改本机对象。
if mapping_true_allowed and hasattr(backend.options, "mapping"):
    backend.set_options(mapping=True)
    print("mapping 默认已设为：", backend.options.mapping)
else:
    print("请使用当前设备 schema 中列出的选项。")

# B、C 的单次写法见下一节；此处只准备一个扁平字典。
task_configuration = {"mapping": True} if mapping_true_allowed else {}

from qiskit import QuantumCircuit

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

# B. 以扁平配置字典指定本次选项。
if mapping_true_allowed and caps.supports_execution_path("logical"):
    prepared = backend.prepare(
        qc,
        shots=128,
        configuration_data={"mapping": True},
    )
    pprint(prepared.quote.to_dict())
else:
    print("此设备不满足本节 mapping=True 的逻辑线路示例条件。")

# C. 替代 B：用匹配当前 schema 的动态关键字。
# 与 B 选择一种写法，准备并查看报价。
if mapping_true_allowed and caps.supports_execution_path("logical"):
    prepared = backend.prepare(qc, shots=128, mapping=True)
    pprint(prepared.quote.to_dict())

print("可用物理比特：", backend.available_qubits)
print("设备连接关系：", caps.topology.coupling_map)
physical_qubits = [
    int(value.strip())
    for value in input("输入两个已核对的物理比特编号（用逗号分隔）：").split(",")
]
if len(physical_qubits) != 2 or len(set(physical_qubits)) != 2:
    raise ValueError("请填写两个不同的物理比特编号。")
print("选中编号当前是否在可用集合：",
      set(physical_qubits).issubset(set(backend.available_qubits)))
print("是否声明物理路径：", caps.supports_execution_path("physical"))
print("是否有客户端物理 Target：", caps.has_client_target)
if caps.has_client_target:
    print("所选位置是否支持 CZ：",
          target.instruction_supported("cz", tuple(physical_qubits)))

physical_qc = QuantumCircuit(2, 2)
physical_qc.h(0)
physical_qc.h(1)
physical_qc.cz(0, 1)
physical_qc.h(1)
physical_qc.measure([0, 1], [0, 1])

# 清除本页前面为逻辑示例显式设置的选项默认。
# None 表示清除覆盖，恢复对应执行方式的默认值。
for option_name in ("mapping", "optimization"):
    if hasattr(backend.options, option_name):
        backend.set_options(**{option_name: None})

# 本地编译并检查布局。
physical = backend.transpile(
    physical_qc,
    initial_layout=physical_qubits,
    optimization_level=0,
)
print(physical.layout)

from quantum_source_qiskit import export_circuit_to_qasm

print("本对象选定格式：", backend.export_format)
print("目录支持格式：", caps.supported_formats)
# 使用上面已经定义、没有未绑定参数的逻辑 qc。
qasm_payload = export_circuit_to_qasm(qc, backend.export_format)
print(type(qasm_payload).__name__)
print(qasm_payload.decode("utf-8"))

# 完成所有查看与准备工作后关闭客户端。
service.close()