qem code

Author: yutuer21

docs/source/tutorials/benchmark_circuits.ipynb

@@ -0,0 +1,18 @@
+from . import qem_methods
+
+zne_option = qem_methods.zne_option
+apply_zne = qem_methods.apply_zne
+
+
+apply_dd = qem_methods.apply_dd
+dd_option = qem_methods.dd_option
+
+apply_rc = qem_methods.apply_rc
+
+apply_gate = qem_methods.apply_gate
+rc_circuit = qem_methods.rc_circuit
+rc_candidates = qem_methods.rc_candidates
+
+use_qubits = qem_methods.use_qubits
+washcircuit = qem_methods.washcircuit
+add_dd = qem_methods.add_dd

docs/source/tutorials/error_mitigation.ipynb

@@ -0,0 +1,93 @@
+from mitiq.benchmarks import (
+    generate_ghz_circuit,
+    generate_mirror_circuit,
+    generate_quantum_volume_circuit,
+    generate_rb_circuits,
+    generate_w_circuit,
+)
+
+from mitiq.interface import (
+    CircuitConversionError,
+    convert_to_mitiq,
+    convert_from_mitiq,
+)
+
+
+from ... import Circuit
+
+
+def ghz_circuit(num_qubits):  # type: ignore
+    cirq = generate_ghz_circuit(num_qubits)
+    ideal = {"0" * num_qubits: 0.5, "1" * num_qubits: 0.5}
+    qisc = convert_from_mitiq(cirq, "qiskit")
+    circuit = Circuit.from_qiskit(qisc, qisc.num_qubits)
+    return circuit, ideal
+
+
+def w_circuit(num_qubits):  # type: ignore
+    # Efficient quantum algorithms for GHZ and W states https://arxiv.org/abs/1807.05572
+    # Werner-state with linear complexity  {'1000': 0.25, '0100': 0.25, '0010': 0.25, '0001': 0.25}
+    cirq = generate_w_circuit(num_qubits)
+
+    ideal = {}
+    for i in range(num_qubits):
+        bitstring = "0" * i + "1" + "0" * (num_qubits - i - 1)
+        ideal[bitstring] = 1 / num_qubits
+
+    qisc = convert_from_mitiq(cirq, "qiskit")
+    circuit = Circuit.from_qiskit(qisc, qisc.num_qubits)
+    return circuit, ideal
+
+
+def rb_circuit(num_qubits, depth):  # type: ignore
+    # num_qubits limited to 1 or 2
+    cirq = generate_rb_circuits(num_qubits, depth)[0]
+    ideal = {"0" * num_qubits: 1.0}
+    qisc = convert_from_mitiq(cirq, "qiskit")
+    circuit = Circuit.from_qiskit(qisc, qisc.num_qubits)
+    return circuit, ideal
+
+
+def mirror_circuit(  # type: ignore
+    depth, two_qubit_gate_prob, connectivity_graph, seed, two_qubit_gate_name="CNOT"
+):
+    # Measuring the Capabilities of Quantum Computers https://arxiv.org/pdf/2008.11294.pdf
+    cirq, bitstring_list = generate_mirror_circuit(
+        nlayers=depth,
+        two_qubit_gate_prob=two_qubit_gate_prob,
+        connectivity_graph=connectivity_graph,
+        two_qubit_gate_name=two_qubit_gate_name,
+        seed=seed,
+    )
+    ideal_bitstring = "".join(map(str, bitstring_list))
+    ideal = {ideal_bitstring: 1.0}
+    qisc = convert_from_mitiq(cirq, "qiskit")
+    circuit = Circuit.from_qiskit(qisc, qisc.num_qubits)
+    return circuit, ideal
+
+
+def QAOA_circuit(graph, weight, params):  # type: ignore
+    nlayers = len(params)
+
+    qlist = []
+    for i in range(len(graph)):
+        for j in range(2):
+            qlist.append(graph[i][j])
+    qlist = list(set(qlist))
+
+    nqubit = max(qlist) + 1
+
+    c = Circuit(nqubit)
+    for i in qlist:
+        c.h(i)  # type: ignore
+
+    for i in range(nlayers):
+        for e in range(len(graph)):
+            c.cnot(graph[e][0], graph[e][1])  # type: ignore
+            c.rz(graph[e][1], theta=params[i, 0] * weight[e])  # type: ignore
+            c.cnot(graph[e][0], graph[e][1])  # type: ignore
+
+        for k in qlist:
+            c.rx(k, theta=params[i, 1] * 2)  # type: ignore
+
+    return c