GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

mirrored from https://github.com/microsoft/qdkAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
v1.18.0

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

qdk/source/pip/tests-integration/interop_qiskit/test_circuits

source/pip/tests-integration/interop_qiskit/test_circuits/test_circuits.py

666lines · modecode

RawDownload
Latest commit unavailable.
1# Copyright (c) Microsoft Corporation.
2# Licensed under the MIT License.
3
4import pytest
5
6import numpy as np
7from typing import Tuple, List
8
9from interop_qiskit import QISKIT_AVAILABLE, SKIP_REASON
10
11if QISKIT_AVAILABLE:
12 from qiskit.circuit import QuantumCircuit
13
14
15def random_bit() -> Tuple["QuantumCircuit", List[str]]:
16 """Expected result:
17 (?)
18 """
19 circuit = QuantumCircuit(1, 1)
20 circuit.name = "Single qubit random"
21 circuit.h(0)
22 circuit.measure(0, 0)
23
24 return circuit, ["0", "1"]
25
26
27def intrinsic_hixyz() -> Tuple["QuantumCircuit", List[str]]:
28 """Expected result:
29 (1, 1, 1, 1, 1, 1)
30 """
31 circuit = QuantumCircuit(6, 6)
32 circuit.name = "HIXYZ"
33
34 # h in qs is h in qiskit
35 circuit.h(0)
36 circuit.z(0)
37 circuit.h(0)
38 # mresetz == measure()
39 circuit.measure(0, 0)
40
41 # i target
42 circuit.x(1)
43 circuit.id(1)
44 # mresetz == measure()
45 circuit.measure(1, 1)
46
47 # x
48 circuit.x(2)
49 circuit.measure(2, 2)
50
51 # ya
52 circuit.y(3)
53 circuit.measure(3, 3)
54
55 # yb
56 circuit.h(4)
57 circuit.y(4)
58 circuit.h(4)
59 circuit.measure(4, 4)
60
61 # z
62 circuit.h(5)
63 circuit.z(5)
64 circuit.h(5)
65 circuit.measure(5, 5)
66
67 return circuit, ["111111"]
68
69
70def intrinsic_ccnot() -> Tuple["QuantumCircuit", List[str]]:
71 """Expected result:
72 (1, 1, 1, 0, 0, 1, 0, 0, 0)
73 """
74 circuit = QuantumCircuit(9, 9)
75 circuit.name = "_CCNOT"
76
77 circuit.ccx(0, 1, 2)
78
79 circuit.measure(0, 0)
80 circuit.measure(1, 1)
81 circuit.measure(2, 2)
82
83 circuit.x(3)
84 circuit.ccx(3, 4, 5)
85
86 circuit.measure(3, 3)
87 circuit.measure(4, 4)
88 circuit.measure(5, 5)
89
90 circuit.x(6)
91 circuit.x(7)
92 circuit.ccx(6, 7, 8)
93
94 circuit.measure(6, 6)
95 circuit.measure(7, 7)
96 circuit.measure(8, 8)
97
98 return circuit, ["111001000"]
99
100
101def intrinsic_cnot() -> Tuple["QuantumCircuit", List[str]]:
102 """Expected result:
103 (1, 1, 0, 0)
104 """
105 circuit = QuantumCircuit(4, 4)
106 circuit.name = "_CNOT"
107
108 circuit.cx(0, 1)
109
110 circuit.measure(0, 0)
111 circuit.measure(1, 1)
112
113 circuit.x(2)
114 circuit.cx(2, 3)
115
116 circuit.measure(2, 2)
117 circuit.measure(3, 3)
118
119 return circuit, ["1100"]
120
121
122def intrinsic_measure() -> Tuple["QuantumCircuit", List[str]]:
123 """Expected result:
124 (1, 0)
125 """
126 circuit = QuantumCircuit(2, 2)
127 circuit.name = "Intrinsic_M"
128
129 circuit.measure(0, 0)
130
131 circuit.x(1)
132
133 circuit.measure(1, 1)
134
135 return circuit, ["10"]
136
137
138def intrinsic_stswap() -> Tuple["QuantumCircuit", List[str]]:
139 """Expected result:
140 (1, 0, 1, 1)
141 """
142 circuit = QuantumCircuit(4, 4)
143 circuit.name = "STSWAP"
144
145 circuit.h(0)
146 circuit.s(0)
147 circuit.s(0)
148 circuit.h(0)
149 circuit.measure(0, 0)
150
151 circuit.h(1)
152 circuit.t(1)
153 circuit.t(1)
154 circuit.t(1)
155 circuit.t(1)
156 circuit.h(1)
157 circuit.measure(1, 1)
158
159 circuit.x(2)
160 circuit.swap(2, 3)
161 circuit.measure(2, 2)
162 circuit.measure(3, 3)
163
164 return circuit, ["1011"]
165
166
167def exercise_reset() -> Tuple["QuantumCircuit", List[str]]:
168 """Expected result:
169 (0, 0)
170 """
171 circuit = QuantumCircuit(2, 2)
172 circuit.name = "Test reset"
173
174 circuit.measure(0, 0)
175
176 circuit.x(1)
177 circuit.reset(1)
178 circuit.measure(1, 1)
179
180 return circuit, ["00"]
181
182
183def exercise_rx_ry_rz() -> Tuple["QuantumCircuit", List[str]]:
184 """Expected result:
185 (0, 0, 0)
186 """
187 # Create a quantum circuit with one qubit and one classical bit
188 circuit = QuantumCircuit(3, 3)
189 circuit.name = "Test_rx_ry_rz"
190
191 # Apply RX, RY, and RZ gates with some arbitrary angles
192 for _ in range(4):
193 circuit.rx(np.pi, 0) # Rotate around the X-axis by pi radians
194 circuit.ry(np.pi, 1) # Rotate around the Y-axis by pi radians
195 circuit.rz(np.pi, 2) # Rotate around the Z-axis by pi radians
196
197 circuit.measure(0, 0)
198 circuit.measure(1, 1)
199 circuit.measure(2, 2)
200
201 return circuit, ["000"]
202
203
204def exercise_tdg_sdg() -> Tuple["QuantumCircuit", List[str]]:
205 """Expected result:
206 (1, 1)
207 """
208 circuit = QuantumCircuit(2, 2)
209 circuit.name = "Test_tdg"
210
211 circuit.h(0) # changes to + state
212 circuit.tdg(0)
213 circuit.tdg(0)
214 circuit.tdg(0)
215 circuit.tdg(0)
216 circuit.h(0)
217 circuit.measure(0, 0)
218
219 circuit.h(1)
220 circuit.sdg(1)
221 circuit.sdg(1)
222 circuit.h(1)
223 circuit.measure(1, 1)
224
225 return circuit, ["11"]
226
227
228def exercise_rxx() -> Tuple["QuantumCircuit", List[str]]:
229 """Expected result:
230 (0, 1)
231 """
232 circuit = QuantumCircuit(2, 2)
233 circuit.name = "Test_rxx"
234
235 circuit.rxx(np.pi / 2, 0, 1)
236 circuit.measure([0, 1], [0, 1])
237
238 return circuit, ["00", "11"]
239
240
241def exercise_ryy() -> Tuple["QuantumCircuit", List[str]]:
242 """Expected result:
243 (0, 1)
244 """
245 circuit = QuantumCircuit(2, 2)
246 circuit.name = "Test_ryy"
247
248 circuit.ryy(np.pi / 2, 0, 1)
249 circuit.measure([0, 1], [0, 1])
250
251 return circuit, ["00", "11"]
252
253
254def exercise_rzz() -> Tuple["QuantumCircuit", List[str]]:
255 """Expected result:
256 (0, 1)
257 """
258 circuit = QuantumCircuit(2, 2)
259 circuit.name = "Test_rzz"
260
261 circuit.h(0)
262 circuit.h(1)
263 circuit.rzz(np.pi / 2, 0, 1)
264 circuit.h(0)
265 circuit.h(1)
266 circuit.measure([0, 1], [0, 1])
267
268 return circuit, ["00", "11"]
269
270
271def exercise_barrier_delay() -> Tuple["QuantumCircuit", List[str]]:
272 """Expected result:
273 (1)
274 """
275 circuit = QuantumCircuit(1, 1)
276 circuit.name = "Test_barrier_delay"
277
278 circuit.x(0)
279 circuit.barrier()
280 circuit.x(0)
281 circuit.barrier()
282 circuit.x(0)
283
284 circuit.delay(100, 0, unit="ns") # Introducing a delay of 100 nanoseconds
285
286 circuit.measure(0, 0)
287
288 return circuit, ["1"]
289
290
291def exercise_initialize_prepare_state() -> Tuple["QuantumCircuit", List[str]]:
292 """Expected result: The qubits are initialized to the state [1/√2, 1/√2, 0, 0]."""
293 circuit = QuantumCircuit(2, 2)
294 circuit.name = "Test initialize and prepare state"
295
296 # State vector to initialize: |ψ⟩ = (|0⟩ - |1⟩) / √2
297 circuit.initialize([1 / np.sqrt(2), -1 / np.sqrt(2)], 0)
298 circuit.h(0)
299 circuit.measure(0, 0)
300
301 circuit.prepare_state([1 / np.sqrt(2), -1 / np.sqrt(2)], 1)
302 circuit.h(1)
303 circuit.measure(1, 1)
304
305 return circuit, ["11"]
306
307
308def exercise_dcx() -> Tuple["QuantumCircuit", List[str]]:
309 """Expected result:
310 (0, 0) or (1, 1)
311 """
312 circuit = QuantumCircuit(2, 2)
313 circuit.name = "Test_DCX"
314
315 circuit.h(0)
316 circuit.dcx(0, 1)
317 circuit.h(1)
318 circuit.measure([0, 1], [0, 1])
319
320 return circuit, ["00"]
321
322
323def exercise_ecr() -> Tuple["QuantumCircuit", List[str]]:
324 """Expected result: Applying the ECR gate to qubits."""
325 circuit = QuantumCircuit(2, 2)
326 circuit.name = "Test_ECR"
327
328 circuit.ecr(0, 1)
329 circuit.measure([0, 1], [0, 1])
330
331 return circuit, ["01", "11"]
332
333
334def exercise_iswap() -> Tuple["QuantumCircuit", List[str]]:
335 """Expected result: Applying the iSwap gate to qubits."""
336 circuit = QuantumCircuit(2, 2)
337 circuit.name = "Test_iSwap"
338
339 circuit.x(0)
340 circuit.iswap(0, 1)
341 circuit.measure([0, 1], [0, 1])
342
343 return circuit, ["10"]
344
345
346def exercise_ms() -> Tuple["QuantumCircuit", List[str]]:
347 """Expected result: Applying the MSGate to qubits."""
348 circuit = QuantumCircuit(2, 2)
349 circuit.name = "Test_MS"
350
351 circuit = QuantumCircuit(2, 2)
352 circuit.ms(np.pi / 2, [0, 1])
353 circuit.measure([0, 1], [0, 1])
354
355 return circuit, ["00", "11"]
356
357
358def exercise_p() -> Tuple["QuantumCircuit", List[str]]:
359 """Expected result:
360 (1)
361 """
362 circuit = QuantumCircuit(1, 1)
363 circuit.name = "Test_Phase"
364
365 circuit.h(0)
366 circuit.p(np.pi, 0)
367 circuit.h(0)
368 circuit.measure(0, 0)
369
370 return circuit, ["1"]
371
372
373def exercise_pauli() -> Tuple["QuantumCircuit", List[str]]:
374 """Expected result:
375 (1, 1)
376 """
377 circuit = QuantumCircuit(2, 2)
378 circuit.name = "Test_Pauli"
379
380 circuit.h(0)
381 circuit.pauli("XZ", [0, 1])
382 circuit.h(0)
383 circuit.measure([0, 1], [0, 1])
384
385 return circuit, ["11"]
386
387
388def exercise_r_rccx_rcccx() -> Tuple["QuantumCircuit", List[str]]:
389 """Expected result: Applying the RC3XGate to qubits."""
390 circuit = QuantumCircuit(8, 8)
391 circuit.name = "Test_R_RCCX_RC3X"
392
393 circuit.r(np.pi, 0, 0)
394 circuit.measure(0, 0)
395
396 circuit.x(1)
397 circuit.x(2)
398 circuit.rccx(1, 2, 3)
399 circuit.measure([1, 2, 3], [1, 2, 3])
400
401 circuit.x(4)
402 circuit.x(5)
403 circuit.x(6)
404 circuit.rcccx(4, 5, 6, 7)
405 circuit.measure([4, 5, 6, 7], [4, 5, 6, 7])
406
407 return circuit, ["11111111"]
408
409
410def exercise_rzx() -> Tuple["QuantumCircuit", List[str]]:
411 """Expected result: Applying the RZXGate to qubits."""
412 circuit = QuantumCircuit(2, 2)
413 circuit.name = "Test_RZX"
414
415 circuit.rzx(np.pi / 2, 0, 1)
416 circuit.measure([0, 1], [0, 1])
417
418 return circuit, ["00", "10"]
419
420
421def exercise_sx_sxdg() -> Tuple["QuantumCircuit", List[str]]:
422 """Expected result:
423 (1)
424 """
425 circuit = QuantumCircuit(2, 2)
426 circuit.name = "Test_SX_SXDG"
427
428 circuit.sx(0)
429 circuit.sx(0)
430 circuit.measure(0, 0)
431
432 circuit.sxdg(1)
433 circuit.sxdg(1)
434 circuit.measure(1, 1)
435
436 return circuit, ["11"]
437
438
439def exercise_u() -> Tuple["QuantumCircuit", List[str]]:
440 """Expected result:
441 (0)
442 """
443 circuit = QuantumCircuit(1, 1)
444 circuit.name = "Test_U"
445
446 for _ in range(4):
447 circuit.u(np.pi, -np.pi / 2, np.pi / 2, 0)
448
449 circuit.measure(0, 0)
450
451 return circuit, ["0"]
452
453
454def exercise_unitary() -> Tuple["QuantumCircuit", List[str]]:
455 """Expected result:
456 (1)
457 """
458 circuit = QuantumCircuit(1, 1)
459 circuit.name = "Test_Unitary"
460
461 # this is the unitary matrix for the pauli x gate
462 unitary_matrix = np.array([[0, 1], [1, 0]])
463 circuit.unitary(unitary_matrix, [0])
464 circuit.measure(0, 0)
465
466 return circuit, ["1"]
467
468
469def exercise_ccz() -> Tuple["QuantumCircuit", List[str]]:
470 """Expected result: Applying the CCZGate to qubits."""
471 circuit = QuantumCircuit(3, 3)
472 circuit.name = "Test_CCZ"
473
474 circuit.x(0)
475 circuit.x(1)
476 circuit.h(2)
477 circuit.ccz(0, 1, 2)
478 circuit.h(2)
479 circuit.measure([0, 1, 2], [0, 1, 2])
480
481 return circuit, ["111"]
482
483
484def exercise_ch() -> Tuple["QuantumCircuit", List[str]]:
485 """Expected result: Applying the CHGate to qubits."""
486 circuit = QuantumCircuit(2, 2)
487 circuit.name = "Test_CH"
488
489 circuit.x(0)
490 circuit.h(1)
491 circuit.z(1)
492 circuit.ch(0, 1)
493 circuit.measure([0, 1], [0, 1])
494
495 return circuit, ["11"]
496
497
498def exercise_cp() -> Tuple["QuantumCircuit", List[str]]:
499 """Expected result: Applying the CPhaseGate to qubits."""
500 circuit = QuantumCircuit(2, 2)
501 circuit.name = "Test_CP"
502
503 circuit.x(0)
504 circuit.h(1)
505 circuit.cp(np.pi, 0, 1)
506 circuit.h(1)
507 circuit.measure([0, 1], [0, 1])
508
509 return circuit, ["11"]
510
511
512def exercise_crx_cry_crz() -> Tuple["QuantumCircuit", List[str]]:
513 """Expected result: Applying the CRXGate to qubits."""
514 circuit = QuantumCircuit(6, 6)
515 circuit.name = "Test_CRX_CRY_CRZ"
516
517 circuit.x(0)
518 circuit.crx(np.pi, 0, 1)
519 circuit.measure([0, 1], [0, 1])
520
521 circuit.x(2)
522 circuit.cry(np.pi, 2, 3)
523 circuit.measure([2, 3], [2, 3])
524
525 circuit.x(4)
526 circuit.h(5)
527 circuit.crz(np.pi, 4, 5)
528 circuit.h(5)
529 circuit.measure([4, 5], [4, 5])
530
531 return circuit, ["111111"]
532
533
534def exercise_cs_csdg() -> Tuple["QuantumCircuit", List[str]]:
535 """Expected result: Applying the CSGate and CSdgGate to qubits."""
536 circuit = QuantumCircuit(4, 4)
537 circuit.name = "Test_CS_CSdg"
538
539 circuit.x(0)
540 circuit.h(1)
541 circuit.cs(0, 1)
542 circuit.cs(0, 1)
543 circuit.h(1)
544 circuit.measure([0, 1], [0, 1])
545
546 circuit.x(2)
547 circuit.h(3)
548 circuit.csdg(2, 3)
549 circuit.csdg(2, 3)
550 circuit.h(3)
551 circuit.measure([2, 3], [2, 3])
552
553 return circuit, ["1111"]
554
555
556def exercise_cswap() -> Tuple["QuantumCircuit", List[str]]:
557 """Expected result: Applying the CSwapGate to qubits."""
558 circuit = QuantumCircuit(3, 3)
559 circuit.name = "Test_CSwap"
560
561 circuit.x(0)
562 circuit.x(1)
563 circuit.cswap(0, 1, 2)
564 circuit.measure([0, 1, 2], [0, 1, 2])
565
566 return circuit, ["101"]
567
568
569def exercise_csx() -> Tuple["QuantumCircuit", List[str]]:
570 """Expected result: Applying the CSXGate to qubits."""
571 circuit = QuantumCircuit(2, 2)
572 circuit.name = "Test_CSX"
573
574 circuit.x(0)
575 circuit.csx(0, 1)
576 circuit.csx(0, 1)
577 circuit.measure([0, 1], [0, 1])
578
579 return circuit, ["11"]
580
581
582def exercise_cu() -> Tuple["QuantumCircuit", List[str]]:
583 """Expected result: Applying the CUGate to qubits."""
584 circuit = QuantumCircuit(2, 2)
585 circuit.name = "Test_CU"
586
587 circuit.u(np.pi, -np.pi / 2, np.pi / 2, 0)
588 circuit.cu(np.pi, np.pi, -np.pi / 2, np.pi / 2, 0, 1)
589 circuit.measure([0, 1], [0, 1])
590
591 return circuit, ["11"]
592
593
594def exercise_cx_cy_cz() -> Tuple["QuantumCircuit", List[str]]:
595 """Expected result: Applying the CXGate to qubits."""
596 circuit = QuantumCircuit(6, 6)
597 circuit.name = "Test_CX_CY_CZ"
598
599 circuit.x(0)
600 circuit.cx(0, 1)
601 circuit.measure([0, 1], [0, 1])
602
603 circuit.x(2)
604 circuit.cy(2, 3)
605 circuit.measure([2, 3], [2, 3])
606
607 circuit.x(4)
608 circuit.h(5)
609 circuit.cz(4, 5)
610 circuit.h(5)
611 circuit.measure([4, 5], [4, 5])
612
613 return circuit, ["111111"]
614
615
616def exercise_mcp() -> Tuple["QuantumCircuit", List[str]]:
617 """Expected result: Applying the Multi-Controlled PhaseGate to qubits."""
618 circuit = QuantumCircuit(3, 3)
619 circuit.name = "Test_MCP"
620
621 circuit.x(0)
622 circuit.x(1)
623 circuit.h(2)
624 circuit.mcp(np.pi, [0, 1], 2)
625 circuit.h(2)
626 circuit.measure([0, 1, 2], [0, 1, 2])
627
628 return circuit, ["111"]
629
630
631def exercise_mcrx_mcry_mcrz() -> Tuple["QuantumCircuit", List[str]]:
632 """Expected result: Applying the Multi-Controlled RXGate to qubits."""
633 circuit = QuantumCircuit(9, 9)
634 circuit.name = "Test_MCRX_MCRY_MCRZ"
635
636 circuit.x(0)
637 circuit.x(1)
638 circuit.mcrx(np.pi, [0, 1], 2)
639 circuit.measure([0, 1, 2], [0, 1, 2])
640
641 circuit.x(3)
642 circuit.x(4)
643 circuit.mcry(np.pi, [3, 4], 5)
644 circuit.measure([3, 4, 5], [3, 4, 5])
645
646 circuit.x(6)
647 circuit.x(7)
648 circuit.h(8)
649 circuit.mcrz(np.pi, [6, 7], 8)
650 circuit.h(8)
651 circuit.measure([6, 7, 8], [6, 7, 8])
652
653 return circuit, ["111111111"]
654
655
656def exercise_mcx() -> Tuple["QuantumCircuit", List[str]]:
657 """Expected result: Applying the Multi-Controlled X gate to qubits."""
658 circuit = QuantumCircuit(3, 3)
659 circuit.name = "Test_MCX"
660
661 circuit.x(0)
662 circuit.x(1)
663 circuit.mcx([0, 1], 2)
664 circuit.measure([0, 1, 2], [0, 1, 2])
665
666 return circuit, ["111"]
667