0
# Quantum Circuits
1
2
Comprehensive quantum circuit construction, gate operations, observables, and measurement capabilities.
3
4
## Core Imports
5
6
```python { .api }
7
from braket.circuits import (
8
Circuit, Gate, AngledGate, DoubleAngledGate,
9
Instruction, CircuitDiagram, AsciiCircuitDiagram, UnicodeCircuitDiagram,
10
Qubit, QubitInput, QubitSet, QubitSetInput,
11
FreeParameter, FreeParameterExpression, Parameterizable,
12
Moments, MomentsKey
13
)
14
15
# Quantum Gates
16
from braket.circuits.gates import (
17
# Single-qubit gates
18
H, I, X, Y, Z, S, Si, T, Ti, V, Vi,
19
# Parameterized single-qubit gates
20
Rx, Ry, Rz, PhaseShift, U, GPhase, GPi, GPi2,
21
# Two-qubit gates
22
CNot, Swap, ISwap, PSwap, XY, CPhaseShift, CPhaseShift00, CPhaseShift01, CPhaseShift10,
23
CV, CY, CZ, ECR, XX, YY, ZZ, PRx, MS,
24
# Multi-qubit gates
25
CCNot, CSwap,
26
# Special gates
27
Unitary, PulseGate
28
)
29
30
# Observables
31
from braket.circuits.observables import (
32
H as ObsH, I as ObsI, X as ObsX, Y as ObsY, Z as ObsZ,
33
TensorProduct, Sum, Hermitian,
34
Observable, StandardObservable
35
)
36
37
# Result Types
38
from braket.circuits.result_types import (
39
StateVector, DensityMatrix, AdjointGradient, Amplitude,
40
Probability, Expectation, Sample, Variance,
41
ResultType, ObservableResultType
42
)
43
44
# Noise Models
45
from braket.circuits.noises import (
46
BitFlip, PhaseFlip, PauliChannel, Depolarizing, TwoQubitDepolarizing,
47
TwoQubitDephasing, TwoQubitPauliChannel, AmplitudeDamping,
48
GeneralizedAmplitudeDamping, PhaseDamping, Kraus,
49
Noise, NoiseModel, NoiseModelInstruction
50
)
51
52
# Compiler Directives
53
from braket.circuits.compiler_directives import StartVerbatimBox, EndVerbatimBox, CompilerDirective
54
```
55
56
## Circuit Construction
57
58
### Basic Circuit Creation
59
60
```python { .api }
61
from braket.circuits import Circuit
62
from braket.circuits.gates import H, CNot, Rx, Ry, Rz
63
import numpy as np
64
65
def create_basic_circuit() -> Circuit:
66
"""
67
Create a basic quantum circuit with common operations.
68
69
Returns:
70
Circuit: Basic quantum circuit with gates and measurements
71
"""
72
circuit = Circuit()
73
74
# Add Hadamard gate on qubit 0
75
circuit.h(0)
76
77
# Add CNOT gate with control=0, target=1
78
circuit.cnot(0, 1)
79
80
# Add rotation gates with parameters
81
circuit.rx(0, np.pi/4)
82
circuit.ry(1, np.pi/3)
83
circuit.rz(2, np.pi/2)
84
85
return circuit
86
87
def create_parameterized_circuit(theta: float, phi: float) -> Circuit:
88
"""
89
Create a parameterized quantum circuit.
90
91
Args:
92
theta: Rotation angle parameter
93
phi: Phase parameter
94
95
Returns:
96
Circuit: Parameterized quantum circuit
97
"""
98
circuit = Circuit()
99
100
# Parameterized gates
101
circuit.ry(0, theta)
102
circuit.rz(0, phi)
103
circuit.cnot(0, 1)
104
circuit.ry(1, theta/2)
105
106
return circuit
107
108
class Circuit:
109
"""Main quantum circuit construction interface."""
110
111
def __init__(self):
112
"""Initialize empty quantum circuit."""
113
pass
114
115
def add_instruction(self, instruction: Instruction) -> 'Circuit':
116
"""
117
Add instruction to circuit.
118
119
Args:
120
instruction: Quantum instruction to add
121
122
Returns:
123
Circuit: Self for method chaining
124
"""
125
pass
126
127
def h(self, target: QubitInput) -> 'Circuit':
128
"""
129
Add Hadamard gate.
130
131
Args:
132
target: Target qubit
133
134
Returns:
135
Circuit: Self for method chaining
136
"""
137
pass
138
139
def cnot(self, control: QubitInput, target: QubitInput) -> 'Circuit':
140
"""
141
Add CNOT gate.
142
143
Args:
144
control: Control qubit
145
target: Target qubit
146
147
Returns:
148
Circuit: Self for method chaining
149
"""
150
pass
151
152
def rx(self, target: QubitInput, angle: float) -> 'Circuit':
153
"""
154
Add X-rotation gate.
155
156
Args:
157
target: Target qubit
158
angle: Rotation angle in radians
159
160
Returns:
161
Circuit: Self for method chaining
162
"""
163
pass
164
165
def measure(self, target: QubitSetInput = None) -> 'Circuit':
166
"""
167
Add measurement operations.
168
169
Args:
170
target: Qubits to measure, defaults to all qubits
171
172
Returns:
173
Circuit: Self for method chaining
174
"""
175
pass
176
```
177
178
### Advanced Circuit Operations
179
180
```python { .api }
181
from braket.circuits import Circuit, FreeParameter, FreeParameterExpression
182
from braket.circuits.gates import U, Unitary
183
import numpy as np
184
185
def create_variational_circuit(layers: int = 3) -> Circuit:
186
"""
187
Create a variational quantum circuit with free parameters.
188
189
Args:
190
layers: Number of variational layers
191
192
Returns:
193
Circuit: Variational circuit with free parameters
194
"""
195
circuit = Circuit()
196
n_qubits = 4
197
198
# Initialize with Hadamard gates
199
for qubit in range(n_qubits):
200
circuit.h(qubit)
201
202
# Variational layers
203
for layer in range(layers):
204
# Parameterized single-qubit rotations
205
for qubit in range(n_qubits):
206
theta = FreeParameter(f"theta_{layer}_{qubit}")
207
phi = FreeParameter(f"phi_{layer}_{qubit}")
208
circuit.ry(qubit, theta)
209
circuit.rz(qubit, phi)
210
211
# Entangling gates
212
for qubit in range(n_qubits - 1):
213
circuit.cnot(qubit, qubit + 1)
214
215
return circuit
216
217
def add_custom_unitary(circuit: Circuit, matrix: np.ndarray, targets: list[int]) -> Circuit:
218
"""
219
Add custom unitary gate to circuit.
220
221
Args:
222
circuit: Quantum circuit
223
matrix: Unitary matrix
224
targets: Target qubits
225
226
Returns:
227
Circuit: Circuit with custom unitary added
228
"""
229
unitary_gate = Unitary(matrix)
230
circuit.add_instruction(Instruction(unitary_gate, targets))
231
return circuit
232
233
class FreeParameter:
234
"""Free parameter for parameterized circuits."""
235
236
def __init__(self, name: str):
237
"""
238
Initialize free parameter.
239
240
Args:
241
name: Parameter name
242
"""
243
self.name = name
244
245
def __add__(self, other) -> 'FreeParameterExpression':
246
"""Add operation for parameter expressions."""
247
pass
248
249
def __mul__(self, other) -> 'FreeParameterExpression':
250
"""Multiply operation for parameter expressions."""
251
pass
252
253
class FreeParameterExpression:
254
"""Mathematical expressions with free parameters."""
255
256
def __init__(self, expression: str):
257
"""
258
Initialize parameter expression.
259
260
Args:
261
expression: Mathematical expression string
262
"""
263
self.expression = expression
264
```
265
266
## Quantum Gates
267
268
### Single-Qubit Gates
269
270
```python { .api }
271
from braket.circuits.gates import H, I, X, Y, Z, S, Si, T, Ti, V, Vi
272
273
# Pauli gates
274
class X(Gate):
275
"""Pauli-X gate (bit flip)."""
276
277
def __init__(self):
278
"""Initialize Pauli-X gate."""
279
pass
280
281
class Y(Gate):
282
"""Pauli-Y gate."""
283
284
def __init__(self):
285
"""Initialize Pauli-Y gate."""
286
pass
287
288
class Z(Gate):
289
"""Pauli-Z gate (phase flip)."""
290
291
def __init__(self):
292
"""Initialize Pauli-Z gate."""
293
pass
294
295
# Clifford gates
296
class H(Gate):
297
"""Hadamard gate."""
298
299
def __init__(self):
300
"""Initialize Hadamard gate."""
301
pass
302
303
class S(Gate):
304
"""S gate (π/2 phase)."""
305
306
def __init__(self):
307
"""Initialize S gate."""
308
pass
309
310
class Si(Gate):
311
"""S† (S-dagger) gate."""
312
313
def __init__(self):
314
"""Initialize S-dagger gate."""
315
pass
316
317
class T(Gate):
318
"""T gate (π/4 phase)."""
319
320
def __init__(self):
321
"""Initialize T gate."""
322
pass
323
324
class Ti(Gate):
325
"""T† (T-dagger) gate."""
326
327
def __init__(self):
328
"""Initialize T-dagger gate."""
329
pass
330
331
# Usage examples
332
def apply_single_qubit_gates(circuit: Circuit) -> Circuit:
333
"""
334
Apply various single-qubit gates to circuit.
335
336
Args:
337
circuit: Target quantum circuit
338
339
Returns:
340
Circuit: Circuit with single-qubit gates applied
341
"""
342
# Pauli gates
343
circuit.x(0) # Bit flip
344
circuit.y(1) # Pauli-Y
345
circuit.z(2) # Phase flip
346
347
# Hadamard gate
348
circuit.h(0) # Superposition
349
350
# Phase gates
351
circuit.s(1) # S gate
352
circuit.si(2) # S-dagger
353
circuit.t(0) # T gate
354
circuit.ti(1) # T-dagger
355
356
return circuit
357
```
358
359
### Parameterized Single-Qubit Gates
360
361
```python { .api }
362
from braket.circuits.gates import Rx, Ry, Rz, PhaseShift, U, GPhase, GPi, GPi2
363
import numpy as np
364
365
class Rx(AngledGate):
366
"""X-axis rotation gate."""
367
368
def __init__(self, angle: float):
369
"""
370
Initialize X-rotation gate.
371
372
Args:
373
angle: Rotation angle in radians
374
"""
375
self.angle = angle
376
377
class Ry(AngledGate):
378
"""Y-axis rotation gate."""
379
380
def __init__(self, angle: float):
381
"""
382
Initialize Y-rotation gate.
383
384
Args:
385
angle: Rotation angle in radians
386
"""
387
self.angle = angle
388
389
class Rz(AngledGate):
390
"""Z-axis rotation gate."""
391
392
def __init__(self, angle: float):
393
"""
394
Initialize Z-rotation gate.
395
396
Args:
397
angle: Rotation angle in radians
398
"""
399
self.angle = angle
400
401
class PhaseShift(AngledGate):
402
"""Phase shift gate."""
403
404
def __init__(self, angle: float):
405
"""
406
Initialize phase shift gate.
407
408
Args:
409
angle: Phase shift angle in radians
410
"""
411
self.angle = angle
412
413
class U(Gate):
414
"""General single-qubit unitary gate."""
415
416
def __init__(self, theta: float, phi: float, lam: float):
417
"""
418
Initialize general unitary gate.
419
420
Args:
421
theta: Rotation angle
422
phi: Phase angle 1
423
lam: Phase angle 2
424
"""
425
self.theta = theta
426
self.phi = phi
427
self.lam = lam
428
429
# Usage examples
430
def apply_rotation_gates(circuit: Circuit, angles: dict) -> Circuit:
431
"""
432
Apply parameterized rotation gates.
433
434
Args:
435
circuit: Target quantum circuit
436
angles: Dictionary of rotation angles
437
438
Returns:
439
Circuit: Circuit with rotation gates applied
440
"""
441
# Rotation gates
442
circuit.rx(0, angles['rx'])
443
circuit.ry(1, angles['ry'])
444
circuit.rz(2, angles['rz'])
445
446
# Phase shift
447
circuit.phase_shift(0, angles['phase'])
448
449
# General unitary
450
circuit.u(1, angles['theta'], angles['phi'], angles['lam'])
451
452
return circuit
453
```
454
455
### Two-Qubit Gates
456
457
```python { .api }
458
from braket.circuits.gates import CNot, Swap, ISwap, CPhaseShift, CZ, ECR, XX, YY, ZZ
459
460
class CNot(Gate):
461
"""Controlled-NOT gate."""
462
463
def __init__(self):
464
"""Initialize CNOT gate."""
465
pass
466
467
class Swap(Gate):
468
"""SWAP gate."""
469
470
def __init__(self):
471
"""Initialize SWAP gate."""
472
pass
473
474
class ISwap(Gate):
475
"""iSWAP gate."""
476
477
def __init__(self):
478
"""Initialize iSWAP gate."""
479
pass
480
481
class CPhaseShift(AngledGate):
482
"""Controlled phase shift gate."""
483
484
def __init__(self, angle: float):
485
"""
486
Initialize controlled phase shift.
487
488
Args:
489
angle: Phase shift angle in radians
490
"""
491
self.angle = angle
492
493
class CZ(Gate):
494
"""Controlled-Z gate."""
495
496
def __init__(self):
497
"""Initialize controlled-Z gate."""
498
pass
499
500
class XX(AngledGate):
501
"""XX interaction gate."""
502
503
def __init__(self, angle: float):
504
"""
505
Initialize XX gate.
506
507
Args:
508
angle: Interaction angle in radians
509
"""
510
self.angle = angle
511
512
class YY(AngledGate):
513
"""YY interaction gate."""
514
515
def __init__(self, angle: float):
516
"""
517
Initialize YY gate.
518
519
Args:
520
angle: Interaction angle in radians
521
"""
522
self.angle = angle
523
524
class ZZ(AngledGate):
525
"""ZZ interaction gate."""
526
527
def __init__(self, angle: float):
528
"""
529
Initialize ZZ gate.
530
531
Args:
532
angle: Interaction angle in radians
533
"""
534
self.angle = angle
535
536
# Usage examples
537
def apply_two_qubit_gates(circuit: Circuit) -> Circuit:
538
"""
539
Apply various two-qubit gates.
540
541
Args:
542
circuit: Target quantum circuit
543
544
Returns:
545
Circuit: Circuit with two-qubit gates applied
546
"""
547
# Entangling gates
548
circuit.cnot(0, 1) # Controlled-NOT
549
circuit.cz(1, 2) # Controlled-Z
550
551
# SWAP operations
552
circuit.swap(0, 2) # SWAP
553
circuit.iswap(1, 2) # iSWAP
554
555
# Parameterized gates
556
circuit.xx(0, 1, np.pi/4) # XX interaction
557
circuit.yy(1, 2, np.pi/3) # YY interaction
558
circuit.zz(0, 2, np.pi/2) # ZZ interaction
559
560
# Controlled phase
561
circuit.cphaseshift(0, 1, np.pi/6)
562
563
return circuit
564
```
565
566
### Multi-Qubit Gates
567
568
```python { .api }
569
from braket.circuits.gates import CCNot, CSwap
570
571
class CCNot(Gate):
572
"""Toffoli (controlled-controlled-NOT) gate."""
573
574
def __init__(self):
575
"""Initialize Toffoli gate."""
576
pass
577
578
class CSwap(Gate):
579
"""Fredkin (controlled-SWAP) gate."""
580
581
def __init__(self):
582
"""Initialize Fredkin gate."""
583
pass
584
585
def apply_multi_qubit_gates(circuit: Circuit) -> Circuit:
586
"""
587
Apply multi-qubit gates.
588
589
Args:
590
circuit: Target quantum circuit
591
592
Returns:
593
Circuit: Circuit with multi-qubit gates applied
594
"""
595
# Toffoli gate (3-qubit)
596
circuit.ccnot(0, 1, 2) # controls: 0,1 target: 2
597
598
# Fredkin gate (3-qubit)
599
circuit.cswap(0, 1, 2) # control: 0 targets: 1,2
600
601
return circuit
602
```
603
604
## Observables and Measurements
605
606
### Observable Classes
607
608
```python { .api }
609
from braket.circuits.observables import X, Y, Z, H, I, TensorProduct, Sum, Hermitian
610
import numpy as np
611
612
class X(StandardObservable):
613
"""Pauli-X observable."""
614
615
def __init__(self):
616
"""Initialize Pauli-X observable."""
617
pass
618
619
class Y(StandardObservable):
620
"""Pauli-Y observable."""
621
622
def __init__(self):
623
"""Initialize Pauli-Y observable."""
624
pass
625
626
class Z(StandardObservable):
627
"""Pauli-Z observable."""
628
629
def __init__(self):
630
"""Initialize Pauli-Z observable."""
631
pass
632
633
class TensorProduct(Observable):
634
"""Tensor product of observables."""
635
636
def __init__(self, *observables):
637
"""
638
Initialize tensor product observable.
639
640
Args:
641
*observables: Observables to tensor together
642
"""
643
self.observables = observables
644
645
class Sum(Observable):
646
"""Sum of observables."""
647
648
def __init__(self, *observables):
649
"""
650
Initialize sum of observables.
651
652
Args:
653
*observables: Observables to sum
654
"""
655
self.observables = observables
656
657
class Hermitian(Observable):
658
"""Custom Hermitian matrix observable."""
659
660
def __init__(self, matrix: np.ndarray):
661
"""
662
Initialize Hermitian observable.
663
664
Args:
665
matrix: Hermitian matrix
666
"""
667
self.matrix = matrix
668
669
# Observable construction examples
670
def create_observables() -> dict:
671
"""
672
Create various quantum observables.
673
674
Returns:
675
dict: Collection of observables for measurements
676
"""
677
observables = {}
678
679
# Single-qubit Pauli observables
680
observables['pauli_x'] = X()
681
observables['pauli_y'] = Y()
682
observables['pauli_z'] = Z()
683
684
# Multi-qubit observables using tensor products
685
observables['zz'] = Z() @ Z() # Z⊗Z on qubits 0,1
686
observables['xx'] = X() @ X() # X⊗X on qubits 0,1
687
observables['xyz'] = X() @ Y() @ Z() # X⊗Y⊗Z on qubits 0,1,2
688
689
# Sum of observables (Hamiltonian)
690
observables['hamiltonian'] = (
691
0.5 * (Z() @ I()) + # Z on qubit 0
692
0.3 * (I() @ Z()) + # Z on qubit 1
693
0.1 * (X() @ X()) # XX interaction
694
)
695
696
# Custom Hermitian observable
697
custom_matrix = np.array([[1, 0], [0, -1]], dtype=complex)
698
observables['custom'] = Hermitian(custom_matrix)
699
700
return observables
701
```
702
703
### Result Types and Measurements
704
705
```python { .api }
706
from braket.circuits.result_types import (
707
StateVector, DensityMatrix, Expectation, Sample, Probability,
708
Variance, Amplitude, AdjointGradient
709
)
710
711
class StateVector(ResultType):
712
"""Full quantum state vector result."""
713
714
def __init__(self):
715
"""Initialize state vector result type."""
716
pass
717
718
class DensityMatrix(ResultType):
719
"""Density matrix result."""
720
721
def __init__(self, target: QubitSetInput = None):
722
"""
723
Initialize density matrix result type.
724
725
Args:
726
target: Target qubits, defaults to all qubits
727
"""
728
self.target = target
729
730
class Expectation(ObservableResultType):
731
"""Observable expectation value."""
732
733
def __init__(self, observable: Observable, target: QubitSetInput = None):
734
"""
735
Initialize expectation value result.
736
737
Args:
738
observable: Observable to measure
739
target: Target qubits
740
"""
741
self.observable = observable
742
self.target = target
743
744
class Sample(ObservableResultType):
745
"""Observable sampling result."""
746
747
def __init__(self, observable: Observable, target: QubitSetInput = None):
748
"""
749
Initialize sampling result.
750
751
Args:
752
observable: Observable to sample
753
target: Target qubits
754
"""
755
self.observable = observable
756
self.target = target
757
758
class Probability(ResultType):
759
"""Measurement probability result."""
760
761
def __init__(self, target: QubitSetInput = None):
762
"""
763
Initialize probability result.
764
765
Args:
766
target: Target qubits
767
"""
768
self.target = target
769
770
class Variance(ObservableResultType):
771
"""Observable variance result."""
772
773
def __init__(self, observable: Observable, target: QubitSetInput = None):
774
"""
775
Initialize variance result.
776
777
Args:
778
observable: Observable for variance calculation
779
target: Target qubits
780
"""
781
self.observable = observable
782
self.target = target
783
784
# Measurement examples
785
def add_measurements_to_circuit(circuit: Circuit) -> Circuit:
786
"""
787
Add various measurement result types to circuit.
788
789
Args:
790
circuit: Target quantum circuit
791
792
Returns:
793
Circuit: Circuit with measurements added
794
"""
795
# State vector (full quantum state)
796
circuit.state_vector()
797
798
# Density matrix for specific qubits
799
circuit.density_matrix([0, 1])
800
801
# Observable expectation values
802
circuit.expectation(observable=Z(), target=0)
803
circuit.expectation(observable=X() @ X(), target=[0, 1])
804
805
# Observable sampling
806
circuit.sample(observable=Z(), target=0)
807
808
# Measurement probabilities
809
circuit.probability([0, 1])
810
811
# Observable variance
812
circuit.variance(observable=Z(), target=0)
813
814
# Amplitude for specific computational basis states
815
circuit.amplitude(['00', '11']) # Bell state amplitudes
816
817
return circuit
818
```
819
820
## Noise Models
821
822
### Noise Channels
823
824
```python { .api }
825
from braket.circuits.noises import (
826
BitFlip, PhaseFlip, PauliChannel, Depolarizing,
827
AmplitudeDamping, PhaseDamping, Kraus
828
)
829
830
class BitFlip(Noise):
831
"""Bit flip noise channel."""
832
833
def __init__(self, probability: float):
834
"""
835
Initialize bit flip noise.
836
837
Args:
838
probability: Bit flip probability [0, 1]
839
"""
840
self.probability = probability
841
842
class PhaseFlip(Noise):
843
"""Phase flip noise channel."""
844
845
def __init__(self, probability: float):
846
"""
847
Initialize phase flip noise.
848
849
Args:
850
probability: Phase flip probability [0, 1]
851
"""
852
self.probability = probability
853
854
class Depolarizing(Noise):
855
"""Depolarizing noise channel."""
856
857
def __init__(self, probability: float):
858
"""
859
Initialize depolarizing noise.
860
861
Args:
862
probability: Depolarizing probability [0, 1]
863
"""
864
self.probability = probability
865
866
class AmplitudeDamping(Noise):
867
"""Amplitude damping noise channel."""
868
869
def __init__(self, gamma: float):
870
"""
871
Initialize amplitude damping.
872
873
Args:
874
gamma: Damping parameter [0, 1]
875
"""
876
self.gamma = gamma
877
878
class PhaseDamping(Noise):
879
"""Phase damping noise channel."""
880
881
def __init__(self, gamma: float):
882
"""
883
Initialize phase damping.
884
885
Args:
886
gamma: Damping parameter [0, 1]
887
"""
888
self.gamma = gamma
889
890
class Kraus(Noise):
891
"""Custom Kraus operator noise."""
892
893
def __init__(self, matrices: list[np.ndarray]):
894
"""
895
Initialize Kraus noise channel.
896
897
Args:
898
matrices: List of Kraus operator matrices
899
"""
900
self.matrices = matrices
901
902
# Noise application examples
903
def apply_noise_to_circuit(circuit: Circuit, noise_params: dict) -> Circuit:
904
"""
905
Apply various noise channels to circuit.
906
907
Args:
908
circuit: Target quantum circuit
909
noise_params: Noise parameter dictionary
910
911
Returns:
912
Circuit: Circuit with noise applied
913
"""
914
# Single-qubit noise
915
circuit.bit_flip(0, noise_params['bit_flip_prob'])
916
circuit.phase_flip(1, noise_params['phase_flip_prob'])
917
circuit.depolarizing(2, noise_params['depol_prob'])
918
919
# Damping noise
920
circuit.amplitude_damping(0, noise_params['amp_damp'])
921
circuit.phase_damping(1, noise_params['phase_damp'])
922
923
# Custom Kraus noise
924
kraus_matrices = [
925
np.array([[1, 0], [0, np.sqrt(1 - noise_params['custom'])]]),
926
np.array([[0, np.sqrt(noise_params['custom'])], [0, 0]])
927
]
928
circuit.kraus(2, kraus_matrices)
929
930
return circuit
931
```
932
933
### Noise Models
934
935
```python { .api }
936
from braket.circuits.noises import NoiseModel, NoiseModelInstruction
937
from braket.circuits.noise_model.criteria import GateCriteria
938
939
class NoiseModel:
940
"""Comprehensive noise model for quantum circuits."""
941
942
def __init__(self):
943
"""Initialize empty noise model."""
944
pass
945
946
def add_noise(self, noise: Noise, criteria: 'Criteria') -> 'NoiseModel':
947
"""
948
Add noise to model with application criteria.
949
950
Args:
951
noise: Noise channel to apply
952
criteria: Criteria for when to apply noise
953
954
Returns:
955
NoiseModel: Self for method chaining
956
"""
957
pass
958
959
def add_noise_to_gate(self, noise: Noise, gate_class: type) -> 'NoiseModel':
960
"""
961
Add noise after specific gate types.
962
963
Args:
964
noise: Noise channel to apply
965
gate_class: Gate class to target
966
967
Returns:
968
NoiseModel: Self for method chaining
969
"""
970
pass
971
972
def create_realistic_noise_model() -> NoiseModel:
973
"""
974
Create realistic noise model for NISQ devices.
975
976
Returns:
977
NoiseModel: Comprehensive noise model
978
"""
979
noise_model = NoiseModel()
980
981
# Single-qubit gate errors
982
single_qubit_error = 0.001
983
noise_model.add_noise_to_gate(
984
Depolarizing(single_qubit_error),
985
gate_class=Rx
986
)
987
noise_model.add_noise_to_gate(
988
Depolarizing(single_qubit_error),
989
gate_class=Ry
990
)
991
992
# Two-qubit gate errors (higher)
993
two_qubit_error = 0.01
994
noise_model.add_noise_to_gate(
995
Depolarizing(two_qubit_error),
996
gate_class=CNot
997
)
998
999
# Measurement errors
1000
readout_error = 0.02
1001
noise_model.add_noise_to_gate(
1002
BitFlip(readout_error),
1003
gate_class=type(None) # Apply to measurements
1004
)
1005
1006
# T1/T2 coherence effects
1007
t1_damping = AmplitudeDamping(0.0001) # T1 = 10ms
1008
t2_dephasing = PhaseDamping(0.0002) # T2 = 5ms
1009
1010
# Apply coherence noise to all operations
1011
for gate_type in [H, X, Y, Z, Rx, Ry, Rz, CNot]:
1012
noise_model.add_noise_to_gate(t1_damping, gate_type)
1013
noise_model.add_noise_to_gate(t2_dephasing, gate_type)
1014
1015
return noise_model
1016
```
1017
1018
## Circuit Analysis and Visualization
1019
1020
### Circuit Diagrams
1021
1022
```python { .api }
1023
from braket.circuits import AsciiCircuitDiagram, UnicodeCircuitDiagram, CircuitDiagram
1024
1025
class CircuitDiagram:
1026
"""Base class for circuit visualization."""
1027
1028
def __init__(self, circuit: Circuit):
1029
"""
1030
Initialize circuit diagram.
1031
1032
Args:
1033
circuit: Quantum circuit to visualize
1034
"""
1035
self.circuit = circuit
1036
1037
class AsciiCircuitDiagram(CircuitDiagram):
1038
"""ASCII-based circuit diagram."""
1039
1040
def __str__(self) -> str:
1041
"""
1042
Generate ASCII representation of circuit.
1043
1044
Returns:
1045
str: ASCII circuit diagram
1046
"""
1047
pass
1048
1049
class UnicodeCircuitDiagram(CircuitDiagram):
1050
"""Unicode-based circuit diagram with better symbols."""
1051
1052
def __str__(self) -> str:
1053
"""
1054
Generate Unicode representation of circuit.
1055
1056
Returns:
1057
str: Unicode circuit diagram
1058
"""
1059
pass
1060
1061
def visualize_circuit(circuit: Circuit) -> str:
1062
"""
1063
Create visual representation of quantum circuit.
1064
1065
Args:
1066
circuit: Quantum circuit to visualize
1067
1068
Returns:
1069
str: Visual circuit representation
1070
"""
1071
# Create Unicode diagram for better visualization
1072
diagram = UnicodeCircuitDiagram(circuit)
1073
return str(diagram)
1074
1075
def print_circuit_info(circuit: Circuit) -> dict:
1076
"""
1077
Print detailed information about circuit.
1078
1079
Args:
1080
circuit: Quantum circuit to analyze
1081
1082
Returns:
1083
dict: Circuit analysis information
1084
"""
1085
info = {
1086
'qubit_count': circuit.qubit_count,
1087
'depth': circuit.depth,
1088
'gate_count': len(circuit.instructions),
1089
'moments': circuit.moments(),
1090
'diagram': str(circuit)
1091
}
1092
1093
return info
1094
```
1095
1096
### Circuit Moments and Analysis
1097
1098
```python { .api }
1099
from braket.circuits import Moments, MomentsKey
1100
1101
class Moments:
1102
"""Circuit moment analysis for optimization."""
1103
1104
def __init__(self, circuit: Circuit):
1105
"""
1106
Initialize moments analysis.
1107
1108
Args:
1109
circuit: Circuit to analyze
1110
"""
1111
self.circuit = circuit
1112
1113
def depth(self) -> int:
1114
"""
1115
Calculate circuit depth.
1116
1117
Returns:
1118
int: Circuit depth in moments
1119
"""
1120
pass
1121
1122
def time_slices(self) -> list:
1123
"""
1124
Get time slice representation.
1125
1126
Returns:
1127
list: List of instruction time slices
1128
"""
1129
pass
1130
1131
def analyze_circuit_structure(circuit: Circuit) -> dict:
1132
"""
1133
Analyze quantum circuit structure and properties.
1134
1135
Args:
1136
circuit: Circuit to analyze
1137
1138
Returns:
1139
dict: Comprehensive circuit analysis
1140
"""
1141
moments = Moments(circuit)
1142
1143
analysis = {
1144
'qubit_count': circuit.qubit_count,
1145
'instruction_count': len(circuit.instructions),
1146
'circuit_depth': moments.depth(),
1147
'moment_structure': moments.time_slices(),
1148
'gate_types': {},
1149
'connectivity_graph': {},
1150
'parallelizable_operations': []
1151
}
1152
1153
# Analyze gate types
1154
for instruction in circuit.instructions:
1155
gate_type = type(instruction.operator).__name__
1156
analysis['gate_types'][gate_type] = analysis['gate_types'].get(gate_type, 0) + 1
1157
1158
return analysis
1159
```
1160
1161
## Compiler Directives
1162
1163
```python { .api }
1164
from braket.circuits.compiler_directives import StartVerbatimBox, EndVerbatimBox
1165
1166
class StartVerbatimBox(CompilerDirective):
1167
"""Start verbatim compilation block."""
1168
1169
def __init__(self):
1170
"""Initialize start verbatim directive."""
1171
pass
1172
1173
class EndVerbatimBox(CompilerDirective):
1174
"""End verbatim compilation block."""
1175
1176
def __init__(self):
1177
"""Initialize end verbatim directive."""
1178
pass
1179
1180
def add_verbatim_block(circuit: Circuit, protected_operations: callable) -> Circuit:
1181
"""
1182
Add verbatim compilation block to preserve specific operations.
1183
1184
Args:
1185
circuit: Target quantum circuit
1186
protected_operations: Function that adds protected operations
1187
1188
Returns:
1189
Circuit: Circuit with verbatim block added
1190
"""
1191
# Start verbatim block
1192
circuit.add_instruction(Instruction(StartVerbatimBox(), []))
1193
1194
# Add protected operations that should not be optimized
1195
protected_operations(circuit)
1196
1197
# End verbatim block
1198
circuit.add_instruction(Instruction(EndVerbatimBox(), []))
1199
1200
return circuit
1201
1202
def create_protected_subcircuit() -> Circuit:
1203
"""
1204
Create subcircuit with compilation protection.
1205
1206
Returns:
1207
Circuit: Protected quantum subcircuit
1208
"""
1209
circuit = Circuit()
1210
1211
def protected_ops(c):
1212
# These operations will not be optimized by compiler
1213
c.h(0)
1214
c.cnot(0, 1)
1215
c.rz(0, np.pi/8) # Specific angle must be preserved
1216
c.cnot(0, 1)
1217
c.h(0)
1218
1219
circuit = add_verbatim_block(circuit, protected_ops)
1220
return circuit
1221
```
1222
1223
This comprehensive circuits documentation covers all aspects of quantum circuit construction, gate operations, measurements, noise modeling, and analysis capabilities provided by the Amazon Braket SDK. The API definitions include complete type information and usage patterns optimized for AI agent consumption.