braket.circuits package

Subpackages

• braket.circuits.noise_model package
  • Submodules
    • braket.circuits.noise_model.circuit_instruction_criteria module
      • CircuitInstructionCriteria
    • braket.circuits.noise_model.criteria module
      • CriteriaKey
      • CriteriaKeyResult
      • Criteria
    • braket.circuits.noise_model.criteria_input_parsing module
      • parse_operator_input()
      • parse_qubit_input()
    • braket.circuits.noise_model.gate_criteria module
      • GateCriteria
    • braket.circuits.noise_model.initialization_criteria module
      • InitializationCriteria
    • braket.circuits.noise_model.noise_model module
      • NoiseModelInstruction
      • NoiseModelInstructions
      • NoiseModel
    • braket.circuits.noise_model.observable_criteria module
      • ObservableCriteria
    • braket.circuits.noise_model.qubit_initialization_criteria module
      • QubitInitializationCriteria
    • braket.circuits.noise_model.result_type_criteria module
      • ResultTypeCriteria
    • braket.circuits.noise_model.unitary_gate_criteria module
      • UnitaryGateCriteria
• braket.circuits.text_diagram_builders namespace
  • Submodules
    • braket.circuits.text_diagram_builders.ascii_circuit_diagram module
      • AsciiCircuitDiagram
    • braket.circuits.text_diagram_builders.text_circuit_diagram module
      • TextCircuitDiagram
    • braket.circuits.text_diagram_builders.text_circuit_diagram_utils module
    • braket.circuits.text_diagram_builders.unicode_circuit_diagram module
      • UnicodeCircuitDiagram

Submodules

• braket.circuits.angled_gate module
  • AngledGate
    • AngledGate.parameters
    • AngledGate.angle
    • AngledGate.bind_values()
    • AngledGate.adjoint()
  • DoubleAngledGate
    • DoubleAngledGate.parameters
    • DoubleAngledGate.angle_1
    • DoubleAngledGate.angle_2
    • DoubleAngledGate.bind_values()
    • DoubleAngledGate.adjoint()
  • TripleAngledGate
    • TripleAngledGate.parameters
    • TripleAngledGate.angle_1
    • TripleAngledGate.angle_2
    • TripleAngledGate.angle_3
    • TripleAngledGate.bind_values()
    • TripleAngledGate.adjoint()
  • angled_ascii_characters()
  • get_angle()
• braket.circuits.ascii_circuit_diagram module
• braket.circuits.basis_state module
  • BasisState
    • BasisState.size
    • BasisState.as_tuple
    • BasisState.as_int
    • BasisState.as_string
• braket.circuits.braket_program_context module
  • BraketProgramContext
    • BraketProgramContext.circuit
    • BraketProgramContext.is_builtin_gate()
    • BraketProgramContext.add_phase_instruction()
    • BraketProgramContext.add_gate_instruction()
    • BraketProgramContext.add_custom_unitary()
    • BraketProgramContext.add_noise_instruction()
    • BraketProgramContext.add_kraus_instruction()
    • BraketProgramContext.add_result()
    • BraketProgramContext.handle_parameter_value()
    • BraketProgramContext.add_measure()
• braket.circuits.circuit module
  • Circuit
    • Circuit.register_subroutine()
    • Circuit.depth
    • Circuit.global_phase
    • Circuit.instructions
    • Circuit.result_types
    • Circuit.basis_rotation_instructions
    • Circuit.moments
    • Circuit.qubit_count
    • Circuit.qubits
    • Circuit.parameters
    • Circuit.add_result_type()
    • Circuit.add_instruction()
    • Circuit.add_circuit()
    • Circuit.add_verbatim_box()
    • Circuit.measure()
    • Circuit.apply_gate_noise()
    • Circuit.apply_initialization_noise()
    • Circuit.make_bound_circuit()
    • Circuit.apply_readout_noise()
    • Circuit.add()
    • Circuit.adjoint()
    • Circuit.diagram()
    • Circuit.to_ir()
    • Circuit.from_ir()
    • Circuit.to_unitary()
    • Circuit.qubits_frozen
    • Circuit.observables_simultaneously_measurable
    • Circuit.copy()
    • Circuit.adjoint_gradient()
    • Circuit.amplitude()
    • Circuit.amplitude_damping()
    • Circuit.bit_flip()
    • Circuit.ccnot()
    • Circuit.cnot()
    • Circuit.cphaseshift()
    • Circuit.cphaseshift00()
    • Circuit.cphaseshift01()
    • Circuit.cphaseshift10()
    • Circuit.cswap()
    • Circuit.cv()
    • Circuit.cy()
    • Circuit.cz()
    • Circuit.density_matrix()
    • Circuit.depolarizing()
    • Circuit.ecr()
    • Circuit.expectation()
    • Circuit.generalized_amplitude_damping()
    • Circuit.gphase()
    • Circuit.gpi()
    • Circuit.gpi2()
    • Circuit.h()
    • Circuit.i()
    • Circuit.iswap()
    • Circuit.kraus()
    • Circuit.ms()
    • Circuit.pauli_channel()
    • Circuit.phase_damping()
    • Circuit.phase_flip()
    • Circuit.phaseshift()
    • Circuit.probability()
    • Circuit.prx()
    • Circuit.pswap()
    • Circuit.pulse_gate()
    • Circuit.rx()
    • Circuit.ry()
    • Circuit.rz()
    • Circuit.s()
    • Circuit.sample()
    • Circuit.si()
    • Circuit.state_vector()
    • Circuit.swap()
    • Circuit.t()
    • Circuit.ti()
    • Circuit.two_qubit_dephasing()
    • Circuit.two_qubit_depolarizing()
    • Circuit.two_qubit_pauli_channel()
    • Circuit.u()
    • Circuit.unitary()
    • Circuit.v()
    • Circuit.variance()
    • Circuit.vi()
    • Circuit.x()
    • Circuit.xx()
    • Circuit.xy()
    • Circuit.y()
    • Circuit.yy()
    • Circuit.z()
    • Circuit.zz()
  • subroutine()
• braket.circuits.circuit_diagram module
  • CircuitDiagram
    • CircuitDiagram.build_diagram()
• braket.circuits.circuit_helpers module
  • validate_circuit_and_shots()
• braket.circuits.compiler_directive module
  • CompilerDirective
    • CompilerDirective.name
    • CompilerDirective.ascii_symbols
    • CompilerDirective.to_ir()
    • CompilerDirective.counterpart()
• braket.circuits.compiler_directives module
  • StartVerbatimBox
    • StartVerbatimBox.counterpart()
  • EndVerbatimBox
    • EndVerbatimBox.counterpart()
• braket.circuits.free_parameter module
• braket.circuits.free_parameter_expression module
• braket.circuits.gate module
  • Gate
    • Gate.adjoint()
    • Gate.to_ir()
    • Gate.ascii_symbols
    • Gate.register_gate()
    • Gate.CCNot
      • Gate.CCNot.adjoint()
      • Gate.CCNot.ccnot()
      • Gate.CCNot.fixed_qubit_count()
      • Gate.CCNot.to_matrix()
    • Gate.CNot
      • Gate.CNot.adjoint()
      • Gate.CNot.cnot()
      • Gate.CNot.fixed_qubit_count()
      • Gate.CNot.to_matrix()
    • Gate.CPhaseShift
      • Gate.CPhaseShift.bind_values()
      • Gate.CPhaseShift.cphaseshift()
      • Gate.CPhaseShift.fixed_qubit_count()
      • Gate.CPhaseShift.to_matrix()
    • Gate.CPhaseShift00
      • Gate.CPhaseShift00.bind_values()
      • Gate.CPhaseShift00.cphaseshift00()
      • Gate.CPhaseShift00.fixed_qubit_count()
      • Gate.CPhaseShift00.to_matrix()
    • Gate.CPhaseShift01
      • Gate.CPhaseShift01.bind_values()
      • Gate.CPhaseShift01.cphaseshift01()
      • Gate.CPhaseShift01.fixed_qubit_count()
      • Gate.CPhaseShift01.to_matrix()
    • Gate.CPhaseShift10
      • Gate.CPhaseShift10.bind_values()
      • Gate.CPhaseShift10.cphaseshift10()
      • Gate.CPhaseShift10.fixed_qubit_count()
      • Gate.CPhaseShift10.to_matrix()
    • Gate.CSwap
      • Gate.CSwap.adjoint()
      • Gate.CSwap.cswap()
      • Gate.CSwap.fixed_qubit_count()
      • Gate.CSwap.to_matrix()
    • Gate.CV
      • Gate.CV.adjoint()
      • Gate.CV.cv()
      • Gate.CV.fixed_qubit_count()
      • Gate.CV.to_matrix()
    • Gate.CY
      • Gate.CY.adjoint()
      • Gate.CY.cy()
      • Gate.CY.fixed_qubit_count()
      • Gate.CY.to_matrix()
    • Gate.CZ
      • Gate.CZ.adjoint()
      • Gate.CZ.cz()
      • Gate.CZ.fixed_qubit_count()
      • Gate.CZ.to_matrix()
    • Gate.ECR
      • Gate.ECR.adjoint()
      • Gate.ECR.ecr()
      • Gate.ECR.fixed_qubit_count()
      • Gate.ECR.to_matrix()
    • Gate.GPhase
      • Gate.GPhase.adjoint()
      • Gate.GPhase.bind_values()
      • Gate.GPhase.fixed_qubit_count()
      • Gate.GPhase.gphase()
      • Gate.GPhase.to_matrix()
    • Gate.GPi
      • Gate.GPi.adjoint()
      • Gate.GPi.bind_values()
      • Gate.GPi.fixed_qubit_count()
      • Gate.GPi.gpi()
      • Gate.GPi.to_matrix()
    • Gate.GPi2
      • Gate.GPi2.adjoint()
      • Gate.GPi2.bind_values()
      • Gate.GPi2.fixed_qubit_count()
      • Gate.GPi2.gpi2()
      • Gate.GPi2.to_matrix()
    • Gate.H
      • Gate.H.adjoint()
      • Gate.H.fixed_qubit_count()
      • Gate.H.h()
      • Gate.H.to_matrix()
    • Gate.I
      • Gate.I.adjoint()
      • Gate.I.fixed_qubit_count()
      • Gate.I.i()
      • Gate.I.to_matrix()
    • Gate.ISwap
      • Gate.ISwap.adjoint()
      • Gate.ISwap.fixed_qubit_count()
      • Gate.ISwap.iswap()
      • Gate.ISwap.to_matrix()
    • Gate.MS
      • Gate.MS.adjoint()
      • Gate.MS.bind_values()
      • Gate.MS.fixed_qubit_count()
      • Gate.MS.ms()
      • Gate.MS.to_matrix()
    • Gate.PRx
      • Gate.PRx.adjoint()
      • Gate.PRx.bind_values()
      • Gate.PRx.fixed_qubit_count()
      • Gate.PRx.prx()
      • Gate.PRx.to_matrix()
    • Gate.PSwap
      • Gate.PSwap.bind_values()
      • Gate.PSwap.fixed_qubit_count()
      • Gate.PSwap.pswap()
      • Gate.PSwap.to_matrix()
    • Gate.PhaseShift
      • Gate.PhaseShift.bind_values()
      • Gate.PhaseShift.fixed_qubit_count()
      • Gate.PhaseShift.phaseshift()
      • Gate.PhaseShift.to_matrix()
    • Gate.PulseGate
      • Gate.PulseGate.bind_values()
      • Gate.PulseGate.parameters
      • Gate.PulseGate.pulse_gate()
      • Gate.PulseGate.pulse_sequence
      • Gate.PulseGate.to_matrix()
    • Gate.Rx
      • Gate.Rx.bind_values()
      • Gate.Rx.fixed_qubit_count()
      • Gate.Rx.rx()
      • Gate.Rx.to_matrix()
    • Gate.Ry
      • Gate.Ry.bind_values()
      • Gate.Ry.fixed_qubit_count()
      • Gate.Ry.ry()
      • Gate.Ry.to_matrix()
    • Gate.Rz
      • Gate.Rz.bind_values()
      • Gate.Rz.fixed_qubit_count()
      • Gate.Rz.rz()
      • Gate.Rz.to_matrix()
    • Gate.S
      • Gate.S.adjoint()
      • Gate.S.fixed_qubit_count()
      • Gate.S.s()
      • Gate.S.to_matrix()
    • Gate.Si
      • Gate.Si.adjoint()
      • Gate.Si.fixed_qubit_count()
      • Gate.Si.si()
      • Gate.Si.to_matrix()
    • Gate.Swap
      • Gate.Swap.adjoint()
      • Gate.Swap.fixed_qubit_count()
      • Gate.Swap.swap()
      • Gate.Swap.to_matrix()
    • Gate.T
      • Gate.T.adjoint()
      • Gate.T.fixed_qubit_count()
      • Gate.T.t()
      • Gate.T.to_matrix()
    • Gate.Ti
      • Gate.Ti.adjoint()
      • Gate.Ti.fixed_qubit_count()
      • Gate.Ti.ti()
      • Gate.Ti.to_matrix()
    • Gate.U
      • Gate.U.adjoint()
      • Gate.U.bind_values()
      • Gate.U.fixed_qubit_count()
      • Gate.U.to_matrix()
      • Gate.U.u()
    • Gate.Unitary
      • Gate.Unitary.adjoint()
      • Gate.Unitary.to_matrix()
      • Gate.Unitary.unitary()
    • Gate.V
      • Gate.V.adjoint()
      • Gate.V.fixed_qubit_count()
      • Gate.V.to_matrix()
      • Gate.V.v()
    • Gate.Vi
      • Gate.Vi.adjoint()
      • Gate.Vi.fixed_qubit_count()
      • Gate.Vi.to_matrix()
      • Gate.Vi.vi()
    • Gate.X
      • Gate.X.adjoint()
      • Gate.X.fixed_qubit_count()
      • Gate.X.to_matrix()
      • Gate.X.x()
    • Gate.XX
      • Gate.XX.bind_values()
      • Gate.XX.fixed_qubit_count()
      • Gate.XX.to_matrix()
      • Gate.XX.xx()
    • Gate.XY
      • Gate.XY.bind_values()
      • Gate.XY.fixed_qubit_count()
      • Gate.XY.to_matrix()
      • Gate.XY.xy()
    • Gate.Y
      • Gate.Y.adjoint()
      • Gate.Y.fixed_qubit_count()
      • Gate.Y.to_matrix()
      • Gate.Y.y()
    • Gate.YY
      • Gate.YY.bind_values()
      • Gate.YY.fixed_qubit_count()
      • Gate.YY.to_matrix()
      • Gate.YY.yy()
    • Gate.Z
      • Gate.Z.adjoint()
      • Gate.Z.fixed_qubit_count()
      • Gate.Z.to_matrix()
      • Gate.Z.z()
    • Gate.ZZ
      • Gate.ZZ.bind_values()
      • Gate.ZZ.fixed_qubit_count()
      • Gate.ZZ.to_matrix()
      • Gate.ZZ.zz()
• braket.circuits.gate_calibrations module
  • GateCalibrations
    • GateCalibrations.pulse_sequences
    • GateCalibrations.copy()
    • GateCalibrations.filter()
    • GateCalibrations.to_ir()
• braket.circuits.gates module
  • H
    • H.adjoint()
    • H.to_matrix()
    • H.fixed_qubit_count()
    • H.h()
  • I
    • I.adjoint()
    • I.to_matrix()
    • I.fixed_qubit_count()
    • I.i()
  • GPhase
    • GPhase.adjoint()
    • GPhase.to_matrix()
    • GPhase.bind_values()
    • GPhase.fixed_qubit_count()
    • GPhase.gphase()
  • X
    • X.adjoint()
    • X.to_matrix()
    • X.fixed_qubit_count()
    • X.x()
  • Y
    • Y.adjoint()
    • Y.to_matrix()
    • Y.fixed_qubit_count()
    • Y.y()
  • Z
    • Z.adjoint()
    • Z.to_matrix()
    • Z.fixed_qubit_count()
    • Z.z()
  • S
    • S.adjoint()
    • S.to_matrix()
    • S.fixed_qubit_count()
    • S.s()
  • Si
    • Si.adjoint()
    • Si.to_matrix()
    • Si.fixed_qubit_count()
    • Si.si()
  • T
    • T.adjoint()
    • T.to_matrix()
    • T.fixed_qubit_count()
    • T.t()
  • Ti
    • Ti.adjoint()
    • Ti.to_matrix()
    • Ti.fixed_qubit_count()
    • Ti.ti()
  • V
    • V.adjoint()
    • V.to_matrix()
    • V.fixed_qubit_count()
    • V.v()
  • Vi
    • Vi.adjoint()
    • Vi.to_matrix()
    • Vi.fixed_qubit_count()
    • Vi.vi()
  • Rx
    • Rx.to_matrix()
    • Rx.fixed_qubit_count()
    • Rx.bind_values()
    • Rx.rx()
  • Ry
    • Ry.to_matrix()
    • Ry.fixed_qubit_count()
    • Ry.bind_values()
    • Ry.ry()
  • Rz
    • Rz.to_matrix()
    • Rz.bind_values()
    • Rz.fixed_qubit_count()
    • Rz.rz()
  • PhaseShift
    • PhaseShift.to_matrix()
    • PhaseShift.bind_values()
    • PhaseShift.fixed_qubit_count()
    • PhaseShift.phaseshift()
  • U
    • U.to_matrix()
    • U.adjoint()
    • U.fixed_qubit_count()
    • U.bind_values()
    • U.u()
  • CNot
    • CNot.adjoint()
    • CNot.to_matrix()
    • CNot.fixed_qubit_count()
    • CNot.cnot()
  • Swap
    • Swap.adjoint()
    • Swap.to_matrix()
    • Swap.fixed_qubit_count()
    • Swap.swap()
  • ISwap
    • ISwap.adjoint()
    • ISwap.to_matrix()
    • ISwap.fixed_qubit_count()
    • ISwap.iswap()
  • PSwap
    • PSwap.to_matrix()
    • PSwap.bind_values()
    • PSwap.fixed_qubit_count()
    • PSwap.pswap()
  • XY
    • XY.to_matrix()
    • XY.bind_values()
    • XY.fixed_qubit_count()
    • XY.xy()
  • CPhaseShift
    • CPhaseShift.to_matrix()
    • CPhaseShift.bind_values()
    • CPhaseShift.fixed_qubit_count()
    • CPhaseShift.cphaseshift()
  • CPhaseShift00
    • CPhaseShift00.to_matrix()
    • CPhaseShift00.bind_values()
    • CPhaseShift00.fixed_qubit_count()
    • CPhaseShift00.cphaseshift00()
  • CPhaseShift01
    • CPhaseShift01.to_matrix()
    • CPhaseShift01.bind_values()
    • CPhaseShift01.fixed_qubit_count()
    • CPhaseShift01.cphaseshift01()
  • CPhaseShift10
    • CPhaseShift10.to_matrix()
    • CPhaseShift10.bind_values()
    • CPhaseShift10.fixed_qubit_count()
    • CPhaseShift10.cphaseshift10()
  • CV
    • CV.adjoint()
    • CV.to_matrix()
    • CV.fixed_qubit_count()
    • CV.cv()
  • CY
    • CY.adjoint()
    • CY.to_matrix()
    • CY.fixed_qubit_count()
    • CY.cy()
  • CZ
    • CZ.adjoint()
    • CZ.to_matrix()
    • CZ.fixed_qubit_count()
    • CZ.cz()
  • ECR
    • ECR.adjoint()
    • ECR.to_matrix()
    • ECR.fixed_qubit_count()
    • ECR.ecr()
  • XX
    • XX.to_matrix()
    • XX.bind_values()
    • XX.fixed_qubit_count()
    • XX.xx()
  • YY
    • YY.to_matrix()
    • YY.bind_values()
    • YY.fixed_qubit_count()
    • YY.yy()
  • ZZ
    • ZZ.to_matrix()
    • ZZ.bind_values()
    • ZZ.fixed_qubit_count()
    • ZZ.zz()
  • CCNot
    • CCNot.adjoint()
    • CCNot.to_matrix()
    • CCNot.fixed_qubit_count()
    • CCNot.ccnot()
  • CSwap
    • CSwap.adjoint()
    • CSwap.to_matrix()
    • CSwap.fixed_qubit_count()
    • CSwap.cswap()
  • GPi
    • GPi.to_matrix()
    • GPi.adjoint()
    • GPi.fixed_qubit_count()
    • GPi.bind_values()
    • GPi.gpi()
  • PRx
    • PRx.to_matrix()
    • PRx.adjoint()
    • PRx.fixed_qubit_count()
    • PRx.bind_values()
    • PRx.prx()
  • GPi2
    • GPi2.to_matrix()
    • GPi2.adjoint()
    • GPi2.fixed_qubit_count()
    • GPi2.bind_values()
    • GPi2.gpi2()
  • MS
    • MS.to_matrix()
    • MS.adjoint()
    • MS.fixed_qubit_count()
    • MS.bind_values()
    • MS.ms()
  • Unitary
    • Unitary.to_matrix()
    • Unitary.adjoint()
    • Unitary.unitary()
  • PulseGate
    • PulseGate.pulse_sequence
    • PulseGate.parameters
    • PulseGate.bind_values()
    • PulseGate.to_matrix()
    • PulseGate.pulse_gate()
  • format_complex()
• braket.circuits.instruction module
  • Instruction
    • Instruction.operator
    • Instruction.target
    • Instruction.control
    • Instruction.control_state
    • Instruction.power
    • Instruction.adjoint()
    • Instruction.to_ir()
    • Instruction.ascii_symbols
    • Instruction.copy()
• braket.circuits.measure module
  • Measure
    • Measure.ascii_symbols
    • Measure.to_ir()
• braket.circuits.moments module
  • MomentType
    • MomentType.GATE
    • MomentType.NOISE
    • MomentType.GATE_NOISE
    • MomentType.INITIALIZATION_NOISE
    • MomentType.READOUT_NOISE
    • MomentType.COMPILER_DIRECTIVE
    • MomentType.GLOBAL_PHASE
    • MomentType.MEASURE
  • MomentsKey
    • MomentsKey.time
    • MomentsKey.qubits
    • MomentsKey.moment_type
    • MomentsKey.noise_index
    • MomentsKey.subindex
  • Moments
    • Moments.depth
    • Moments.qubit_count
    • Moments.qubits
    • Moments.time_slices()
    • Moments.add()
    • Moments.add_noise()
    • Moments.sort_moments()
    • Moments.keys()
    • Moments.items()
    • Moments.values()
    • Moments.get()
• braket.circuits.noise module
  • Noise
    • Noise.name
    • Noise.to_ir()
    • Noise.to_matrix()
    • Noise.from_dict()
    • Noise.register_noise()
    • Noise.AmplitudeDamping
      • Noise.AmplitudeDamping.amplitude_damping()
      • Noise.AmplitudeDamping.bind_values()
      • Noise.AmplitudeDamping.fixed_qubit_count()
      • Noise.AmplitudeDamping.from_dict()
      • Noise.AmplitudeDamping.to_matrix()
    • Noise.BitFlip
      • Noise.BitFlip.bind_values()
      • Noise.BitFlip.bit_flip()
      • Noise.BitFlip.fixed_qubit_count()
      • Noise.BitFlip.from_dict()
      • Noise.BitFlip.to_matrix()
    • Noise.Depolarizing
      • Noise.Depolarizing.bind_values()
      • Noise.Depolarizing.depolarizing()
      • Noise.Depolarizing.fixed_qubit_count()
      • Noise.Depolarizing.from_dict()
      • Noise.Depolarizing.to_matrix()
    • Noise.GeneralizedAmplitudeDamping
      • Noise.GeneralizedAmplitudeDamping.bind_values()
      • Noise.GeneralizedAmplitudeDamping.fixed_qubit_count()
      • Noise.GeneralizedAmplitudeDamping.from_dict()
      • Noise.GeneralizedAmplitudeDamping.generalized_amplitude_damping()
      • Noise.GeneralizedAmplitudeDamping.to_matrix()
    • Noise.Kraus
      • Noise.Kraus.from_dict()
      • Noise.Kraus.kraus()
      • Noise.Kraus.to_dict()
      • Noise.Kraus.to_matrix()
    • Noise.PauliChannel
      • Noise.PauliChannel.bind_values()
      • Noise.PauliChannel.fixed_qubit_count()
      • Noise.PauliChannel.from_dict()
      • Noise.PauliChannel.pauli_channel()
      • Noise.PauliChannel.to_matrix()
    • Noise.PhaseDamping
      • Noise.PhaseDamping.bind_values()
      • Noise.PhaseDamping.fixed_qubit_count()
      • Noise.PhaseDamping.from_dict()
      • Noise.PhaseDamping.phase_damping()
      • Noise.PhaseDamping.to_matrix()
    • Noise.PhaseFlip
      • Noise.PhaseFlip.bind_values()
      • Noise.PhaseFlip.fixed_qubit_count()
      • Noise.PhaseFlip.from_dict()
      • Noise.PhaseFlip.phase_flip()
      • Noise.PhaseFlip.to_matrix()
    • Noise.TwoQubitDephasing
      • Noise.TwoQubitDephasing.bind_values()
      • Noise.TwoQubitDephasing.fixed_qubit_count()
      • Noise.TwoQubitDephasing.from_dict()
      • Noise.TwoQubitDephasing.to_matrix()
      • Noise.TwoQubitDephasing.two_qubit_dephasing()
    • Noise.TwoQubitDepolarizing
      • Noise.TwoQubitDepolarizing.bind_values()
      • Noise.TwoQubitDepolarizing.fixed_qubit_count()
      • Noise.TwoQubitDepolarizing.from_dict()
      • Noise.TwoQubitDepolarizing.to_matrix()
      • Noise.TwoQubitDepolarizing.two_qubit_depolarizing()
    • Noise.TwoQubitPauliChannel
      • Noise.TwoQubitPauliChannel.bind_values()
      • Noise.TwoQubitPauliChannel.fixed_qubit_count()
      • Noise.TwoQubitPauliChannel.from_dict()
      • Noise.TwoQubitPauliChannel.to_matrix()
      • Noise.TwoQubitPauliChannel.two_qubit_pauli_channel()
  • SingleProbabilisticNoise
    • SingleProbabilisticNoise.probability
    • SingleProbabilisticNoise.parameters
    • SingleProbabilisticNoise.bind_values()
    • SingleProbabilisticNoise.to_dict()
  • SingleProbabilisticNoise_34
  • SingleProbabilisticNoise_1516
  • MultiQubitPauliNoise
    • MultiQubitPauliNoise.probabilities
    • MultiQubitPauliNoise.parameters
    • MultiQubitPauliNoise.bind_values()
    • MultiQubitPauliNoise.to_dict()
  • PauliNoise
    • PauliNoise.probX
    • PauliNoise.probY
    • PauliNoise.probZ
    • PauliNoise.parameters
    • PauliNoise.bind_values()
    • PauliNoise.to_dict()
  • DampingNoise
    • DampingNoise.gamma
    • DampingNoise.parameters
    • DampingNoise.bind_values()
    • DampingNoise.to_dict()
  • GeneralizedAmplitudeDampingNoise
    • GeneralizedAmplitudeDampingNoise.probability
    • GeneralizedAmplitudeDampingNoise.parameters
    • GeneralizedAmplitudeDampingNoise.to_dict()
• braket.circuits.noise_helpers module
  • no_noise_applied_warning()
  • wrap_with_list()
  • check_noise_target_gates()
  • check_noise_target_unitary()
  • check_noise_target_qubits()
  • apply_noise_to_moments()
  • apply_noise_to_gates()
• braket.circuits.noises module
  • BitFlip
    • BitFlip.to_matrix()
    • BitFlip.fixed_qubit_count()
    • BitFlip.bit_flip()
    • BitFlip.bind_values()
    • BitFlip.from_dict()
  • PhaseFlip
    • PhaseFlip.to_matrix()
    • PhaseFlip.fixed_qubit_count()
    • PhaseFlip.phase_flip()
    • PhaseFlip.bind_values()
    • PhaseFlip.from_dict()
  • PauliChannel
    • PauliChannel.to_matrix()
    • PauliChannel.fixed_qubit_count()
    • PauliChannel.pauli_channel()
    • PauliChannel.bind_values()
    • PauliChannel.from_dict()
  • Depolarizing
    • Depolarizing.to_matrix()
    • Depolarizing.fixed_qubit_count()
    • Depolarizing.depolarizing()
    • Depolarizing.bind_values()
    • Depolarizing.from_dict()
  • TwoQubitDepolarizing
    • TwoQubitDepolarizing.to_matrix()
    • TwoQubitDepolarizing.fixed_qubit_count()
    • TwoQubitDepolarizing.two_qubit_depolarizing()
    • TwoQubitDepolarizing.bind_values()
    • TwoQubitDepolarizing.from_dict()
  • TwoQubitDephasing
    • TwoQubitDephasing.to_matrix()
    • TwoQubitDephasing.fixed_qubit_count()
    • TwoQubitDephasing.two_qubit_dephasing()
    • TwoQubitDephasing.bind_values()
    • TwoQubitDephasing.from_dict()
  • TwoQubitPauliChannel
    • TwoQubitPauliChannel.to_matrix()
    • TwoQubitPauliChannel.fixed_qubit_count()
    • TwoQubitPauliChannel.two_qubit_pauli_channel()
    • TwoQubitPauliChannel.bind_values()
    • TwoQubitPauliChannel.from_dict()
  • AmplitudeDamping
    • AmplitudeDamping.to_matrix()
    • AmplitudeDamping.fixed_qubit_count()
    • AmplitudeDamping.amplitude_damping()
    • AmplitudeDamping.bind_values()
    • AmplitudeDamping.from_dict()
  • GeneralizedAmplitudeDamping
    • GeneralizedAmplitudeDamping.to_matrix()
    • GeneralizedAmplitudeDamping.fixed_qubit_count()
    • GeneralizedAmplitudeDamping.generalized_amplitude_damping()
    • GeneralizedAmplitudeDamping.bind_values()
    • GeneralizedAmplitudeDamping.from_dict()
  • PhaseDamping
    • PhaseDamping.to_matrix()
    • PhaseDamping.fixed_qubit_count()
    • PhaseDamping.phase_damping()
    • PhaseDamping.bind_values()
    • PhaseDamping.from_dict()
  • Kraus
    • Kraus.to_matrix()
    • Kraus.kraus()
    • Kraus.to_dict()
    • Kraus.from_dict()
• braket.circuits.observable module
  • Observable
    • Observable.to_ir()
    • Observable.coefficient
    • Observable.basis_rotation_gates
    • Observable.eigenvalues
    • Observable.eigenvalue()
    • Observable.register_observable()
    • Observable.H
      • Observable.H.basis_rotation_gates
      • Observable.H.to_matrix()
    • Observable.Hermitian
      • Observable.Hermitian.basis_rotation_gates
      • Observable.Hermitian.eigenvalue()
      • Observable.Hermitian.eigenvalues
      • Observable.Hermitian.to_matrix()
    • Observable.I
      • Observable.I.basis_rotation_gates
      • Observable.I.eigenvalue()
      • Observable.I.eigenvalues
      • Observable.I.to_matrix()
    • Observable.Sum
      • Observable.Sum.basis_rotation_gates
      • Observable.Sum.eigenvalue()
      • Observable.Sum.eigenvalues
      • Observable.Sum.summands
      • Observable.Sum.to_matrix()
    • Observable.TensorProduct
      • Observable.TensorProduct.ascii_symbols
      • Observable.TensorProduct.basis_rotation_gates
      • Observable.TensorProduct.eigenvalue()
      • Observable.TensorProduct.eigenvalues
      • Observable.TensorProduct.factors
      • Observable.TensorProduct.to_matrix()
    • Observable.X
      • Observable.X.basis_rotation_gates
      • Observable.X.to_matrix()
    • Observable.Y
      • Observable.Y.basis_rotation_gates
      • Observable.Y.to_matrix()
    • Observable.Z
      • Observable.Z.basis_rotation_gates
      • Observable.Z.to_matrix()
  • StandardObservable
    • StandardObservable.eigenvalues
    • StandardObservable.eigenvalue()
    • StandardObservable.ascii_symbols
• braket.circuits.observables module
  • H
    • H.to_matrix()
    • H.basis_rotation_gates
  • I
    • I.to_matrix()
    • I.basis_rotation_gates
    • I.eigenvalues
    • I.eigenvalue()
  • X
    • X.to_matrix()
    • X.basis_rotation_gates
  • Y
    • Y.to_matrix()
    • Y.basis_rotation_gates
  • Z
    • Z.to_matrix()
    • Z.basis_rotation_gates
  • TensorProduct
    • TensorProduct.ascii_symbols
    • TensorProduct.factors
    • TensorProduct.to_matrix()
    • TensorProduct.basis_rotation_gates
    • TensorProduct.eigenvalues
    • TensorProduct.eigenvalue()
  • Sum
    • Sum.summands
    • Sum.to_matrix()
    • Sum.basis_rotation_gates
    • Sum.eigenvalues
    • Sum.eigenvalue()
  • Hermitian
    • Hermitian.to_matrix()
    • Hermitian.basis_rotation_gates
    • Hermitian.eigenvalues
    • Hermitian.eigenvalue()
  • observable_from_ir()
• braket.circuits.operator module
  • Operator
    • Operator.name
    • Operator.to_ir()
• braket.circuits.parameterizable module
• braket.circuits.quantum_operator module
  • QuantumOperator
    • QuantumOperator.fixed_qubit_count()
    • QuantumOperator.qubit_count
    • QuantumOperator.ascii_symbols
    • QuantumOperator.name
    • QuantumOperator.to_ir()
    • QuantumOperator.to_matrix()
    • QuantumOperator.matrix_equivalence()
• braket.circuits.quantum_operator_helpers module
  • verify_quantum_operator_matrix_dimensions()
  • is_hermitian()
  • is_square_matrix()
  • is_unitary()
  • is_cptp()
  • get_pauli_eigenvalues()
• braket.circuits.qubit module
• braket.circuits.qubit_set module
• braket.circuits.result_type module
  • ResultType
    • ResultType.ascii_symbols
    • ResultType.name
    • ResultType.to_ir()
    • ResultType.copy()
    • ResultType.register_result_type()
    • ResultType.AdjointGradient
      • ResultType.AdjointGradient.adjoint_gradient()
    • ResultType.Amplitude
      • ResultType.Amplitude.amplitude()
      • ResultType.Amplitude.state
    • ResultType.DensityMatrix
      • ResultType.DensityMatrix.density_matrix()
      • ResultType.DensityMatrix.target
    • ResultType.Expectation
      • ResultType.Expectation.expectation()
    • ResultType.Probability
      • ResultType.Probability.probability()
      • ResultType.Probability.target
    • ResultType.Sample
      • ResultType.Sample.sample()
    • ResultType.StateVector
      • ResultType.StateVector.state_vector()
    • ResultType.Variance
      • ResultType.Variance.variance()
  • ObservableResultType
    • ObservableResultType.observable
    • ObservableResultType.target
  • ObservableParameterResultType
    • ObservableParameterResultType.parameters
• braket.circuits.result_types module
  • StateVector
    • StateVector.state_vector()
  • DensityMatrix
    • DensityMatrix.target
    • DensityMatrix.density_matrix()
  • AdjointGradient
    • AdjointGradient.adjoint_gradient()
  • Amplitude
    • Amplitude.state
    • Amplitude.amplitude()
  • Probability
    • Probability.target
    • Probability.probability()
  • Expectation
    • Expectation.expectation()
  • Sample
    • Sample.sample()
  • Variance
    • Variance.variance()
• braket.circuits.serialization module
  • IRType
    • IRType.OPENQASM
    • IRType.JAQCD
  • QubitReferenceType
    • QubitReferenceType.VIRTUAL
    • QubitReferenceType.PHYSICAL
  • OpenQASMSerializationProperties
    • OpenQASMSerializationProperties.qubit_reference_type
    • OpenQASMSerializationProperties.format_target()
  • SerializationProperties
• braket.circuits.translations module
  • get_observable()
  • get_tensor_product()
  • braket_result_to_result_type()
• braket.circuits.unitary_calculation module
  • calculate_unitary_big_endian()