CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-amazon-braket-sdk

An open source library for interacting with quantum computing devices on Amazon Braket

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview
Eval results
Files

circuits.mddocs/

Quantum Circuits

Comprehensive quantum circuit construction, gate operations, observables, and measurement capabilities.

Core Imports

from braket.circuits import (
    Circuit, Gate, AngledGate, DoubleAngledGate, 
    Instruction, CircuitDiagram, AsciiCircuitDiagram, UnicodeCircuitDiagram,
    Qubit, QubitInput, QubitSet, QubitSetInput,
    FreeParameter, FreeParameterExpression, Parameterizable,
    Moments, MomentsKey
)

# Quantum Gates
from braket.circuits.gates import (
    # Single-qubit gates
    H, I, X, Y, Z, S, Si, T, Ti, V, Vi,
    # Parameterized single-qubit gates  
    Rx, Ry, Rz, PhaseShift, U, GPhase, GPi, GPi2,
    # Two-qubit gates
    CNot, Swap, ISwap, PSwap, XY, CPhaseShift, CPhaseShift00, CPhaseShift01, CPhaseShift10,
    CV, CY, CZ, ECR, XX, YY, ZZ, PRx, MS,
    # Multi-qubit gates
    CCNot, CSwap,
    # Special gates
    Unitary, PulseGate
)

# Observables
from braket.circuits.observables import (
    H as ObsH, I as ObsI, X as ObsX, Y as ObsY, Z as ObsZ,
    TensorProduct, Sum, Hermitian,
    Observable, StandardObservable
)

# Result Types
from braket.circuits.result_types import (
    StateVector, DensityMatrix, AdjointGradient, Amplitude, 
    Probability, Expectation, Sample, Variance,
    ResultType, ObservableResultType
)

# Noise Models
from braket.circuits.noises import (
    BitFlip, PhaseFlip, PauliChannel, Depolarizing, TwoQubitDepolarizing,
    TwoQubitDephasing, TwoQubitPauliChannel, AmplitudeDamping, 
    GeneralizedAmplitudeDamping, PhaseDamping, Kraus,
    Noise, NoiseModel, NoiseModelInstruction
)

# Compiler Directives
from braket.circuits.compiler_directives import StartVerbatimBox, EndVerbatimBox, CompilerDirective

Circuit Construction

Basic Circuit Creation

from braket.circuits import Circuit
from braket.circuits.gates import H, CNot, Rx, Ry, Rz
import numpy as np

def create_basic_circuit() -> Circuit:
    """
    Create a basic quantum circuit with common operations.
    
    Returns:
        Circuit: Basic quantum circuit with gates and measurements
    """
    circuit = Circuit()
    
    # Add Hadamard gate on qubit 0
    circuit.h(0)
    
    # Add CNOT gate with control=0, target=1
    circuit.cnot(0, 1)
    
    # Add rotation gates with parameters
    circuit.rx(0, np.pi/4)
    circuit.ry(1, np.pi/3)
    circuit.rz(2, np.pi/2)
    
    return circuit

def create_parameterized_circuit(theta: float, phi: float) -> Circuit:
    """
    Create a parameterized quantum circuit.
    
    Args:
        theta: Rotation angle parameter
        phi: Phase parameter
        
    Returns:
        Circuit: Parameterized quantum circuit
    """
    circuit = Circuit()
    
    # Parameterized gates
    circuit.ry(0, theta)
    circuit.rz(0, phi)
    circuit.cnot(0, 1)
    circuit.ry(1, theta/2)
    
    return circuit

class Circuit:
    """Main quantum circuit construction interface."""
    
    def __init__(self):
        """Initialize empty quantum circuit."""
        pass
    
    def add_instruction(self, instruction: Instruction) -> 'Circuit':
        """
        Add instruction to circuit.
        
        Args:
            instruction: Quantum instruction to add
            
        Returns:
            Circuit: Self for method chaining
        """
        pass
    
    def h(self, target: QubitInput) -> 'Circuit':
        """
        Add Hadamard gate.
        
        Args:
            target: Target qubit
            
        Returns:
            Circuit: Self for method chaining
        """
        pass
    
    def cnot(self, control: QubitInput, target: QubitInput) -> 'Circuit':
        """
        Add CNOT gate.
        
        Args:
            control: Control qubit
            target: Target qubit
            
        Returns:
            Circuit: Self for method chaining
        """
        pass
    
    def rx(self, target: QubitInput, angle: float) -> 'Circuit':
        """
        Add X-rotation gate.
        
        Args:
            target: Target qubit
            angle: Rotation angle in radians
            
        Returns:
            Circuit: Self for method chaining
        """
        pass
    
    def measure(self, target: QubitSetInput = None) -> 'Circuit':
        """
        Add measurement operations.
        
        Args:
            target: Qubits to measure, defaults to all qubits
            
        Returns:
            Circuit: Self for method chaining
        """
        pass

Advanced Circuit Operations

from braket.circuits import Circuit, FreeParameter, FreeParameterExpression
from braket.circuits.gates import U, Unitary
import numpy as np

def create_variational_circuit(layers: int = 3) -> Circuit:
    """
    Create a variational quantum circuit with free parameters.
    
    Args:
        layers: Number of variational layers
        
    Returns:
        Circuit: Variational circuit with free parameters
    """
    circuit = Circuit()
    n_qubits = 4
    
    # Initialize with Hadamard gates
    for qubit in range(n_qubits):
        circuit.h(qubit)
    
    # Variational layers
    for layer in range(layers):
        # Parameterized single-qubit rotations
        for qubit in range(n_qubits):
            theta = FreeParameter(f"theta_{layer}_{qubit}")
            phi = FreeParameter(f"phi_{layer}_{qubit}")
            circuit.ry(qubit, theta)
            circuit.rz(qubit, phi)
        
        # Entangling gates
        for qubit in range(n_qubits - 1):
            circuit.cnot(qubit, qubit + 1)
    
    return circuit

def add_custom_unitary(circuit: Circuit, matrix: np.ndarray, targets: list[int]) -> Circuit:
    """
    Add custom unitary gate to circuit.
    
    Args:
        circuit: Quantum circuit
        matrix: Unitary matrix
        targets: Target qubits
        
    Returns:
        Circuit: Circuit with custom unitary added
    """
    unitary_gate = Unitary(matrix)
    circuit.add_instruction(Instruction(unitary_gate, targets))
    return circuit

class FreeParameter:
    """Free parameter for parameterized circuits."""
    
    def __init__(self, name: str):
        """
        Initialize free parameter.
        
        Args:
            name: Parameter name
        """
        self.name = name
    
    def __add__(self, other) -> 'FreeParameterExpression':
        """Add operation for parameter expressions."""
        pass
    
    def __mul__(self, other) -> 'FreeParameterExpression':
        """Multiply operation for parameter expressions."""
        pass

class FreeParameterExpression:
    """Mathematical expressions with free parameters."""
    
    def __init__(self, expression: str):
        """
        Initialize parameter expression.
        
        Args:
            expression: Mathematical expression string
        """
        self.expression = expression

Quantum Gates

Single-Qubit Gates

from braket.circuits.gates import H, I, X, Y, Z, S, Si, T, Ti, V, Vi

# Pauli gates
class X(Gate):
    """Pauli-X gate (bit flip)."""
    
    def __init__(self):
        """Initialize Pauli-X gate."""
        pass

class Y(Gate):
    """Pauli-Y gate."""
    
    def __init__(self):
        """Initialize Pauli-Y gate."""
        pass

class Z(Gate):
    """Pauli-Z gate (phase flip)."""
    
    def __init__(self):
        """Initialize Pauli-Z gate."""
        pass

# Clifford gates
class H(Gate):
    """Hadamard gate."""
    
    def __init__(self):
        """Initialize Hadamard gate."""
        pass

class S(Gate):
    """S gate (π/2 phase)."""
    
    def __init__(self):
        """Initialize S gate."""
        pass

class Si(Gate):
    """S† (S-dagger) gate."""
    
    def __init__(self):
        """Initialize S-dagger gate."""
        pass

class T(Gate):
    """T gate (π/4 phase)."""
    
    def __init__(self):
        """Initialize T gate."""
        pass

class Ti(Gate):
    """T† (T-dagger) gate."""
    
    def __init__(self):
        """Initialize T-dagger gate."""
        pass

# Usage examples
def apply_single_qubit_gates(circuit: Circuit) -> Circuit:
    """
    Apply various single-qubit gates to circuit.
    
    Args:
        circuit: Target quantum circuit
        
    Returns:
        Circuit: Circuit with single-qubit gates applied
    """
    # Pauli gates
    circuit.x(0)  # Bit flip
    circuit.y(1)  # Pauli-Y
    circuit.z(2)  # Phase flip
    
    # Hadamard gate
    circuit.h(0)  # Superposition
    
    # Phase gates
    circuit.s(1)  # S gate
    circuit.si(2) # S-dagger
    circuit.t(0)  # T gate
    circuit.ti(1) # T-dagger
    
    return circuit

Parameterized Single-Qubit Gates

from braket.circuits.gates import Rx, Ry, Rz, PhaseShift, U, GPhase, GPi, GPi2
import numpy as np

class Rx(AngledGate):
    """X-axis rotation gate."""
    
    def __init__(self, angle: float):
        """
        Initialize X-rotation gate.
        
        Args:
            angle: Rotation angle in radians
        """
        self.angle = angle

class Ry(AngledGate):
    """Y-axis rotation gate."""
    
    def __init__(self, angle: float):
        """
        Initialize Y-rotation gate.
        
        Args:
            angle: Rotation angle in radians
        """
        self.angle = angle

class Rz(AngledGate):
    """Z-axis rotation gate."""
    
    def __init__(self, angle: float):
        """
        Initialize Z-rotation gate.
        
        Args:
            angle: Rotation angle in radians
        """
        self.angle = angle

class PhaseShift(AngledGate):
    """Phase shift gate."""
    
    def __init__(self, angle: float):
        """
        Initialize phase shift gate.
        
        Args:
            angle: Phase shift angle in radians
        """
        self.angle = angle

class U(Gate):
    """General single-qubit unitary gate."""
    
    def __init__(self, theta: float, phi: float, lam: float):
        """
        Initialize general unitary gate.
        
        Args:
            theta: Rotation angle
            phi: Phase angle 1
            lam: Phase angle 2
        """
        self.theta = theta
        self.phi = phi
        self.lam = lam

# Usage examples
def apply_rotation_gates(circuit: Circuit, angles: dict) -> Circuit:
    """
    Apply parameterized rotation gates.
    
    Args:
        circuit: Target quantum circuit
        angles: Dictionary of rotation angles
        
    Returns:
        Circuit: Circuit with rotation gates applied
    """
    # Rotation gates
    circuit.rx(0, angles['rx'])
    circuit.ry(1, angles['ry']) 
    circuit.rz(2, angles['rz'])
    
    # Phase shift
    circuit.phase_shift(0, angles['phase'])
    
    # General unitary
    circuit.u(1, angles['theta'], angles['phi'], angles['lam'])
    
    return circuit

Two-Qubit Gates

from braket.circuits.gates import CNot, Swap, ISwap, CPhaseShift, CZ, ECR, XX, YY, ZZ

class CNot(Gate):
    """Controlled-NOT gate."""
    
    def __init__(self):
        """Initialize CNOT gate."""
        pass

class Swap(Gate):
    """SWAP gate."""
    
    def __init__(self):
        """Initialize SWAP gate."""
        pass

class ISwap(Gate):
    """iSWAP gate."""
    
    def __init__(self):
        """Initialize iSWAP gate."""
        pass

class CPhaseShift(AngledGate):
    """Controlled phase shift gate."""
    
    def __init__(self, angle: float):
        """
        Initialize controlled phase shift.
        
        Args:
            angle: Phase shift angle in radians
        """
        self.angle = angle

class CZ(Gate):
    """Controlled-Z gate."""
    
    def __init__(self):
        """Initialize controlled-Z gate."""
        pass

class XX(AngledGate):
    """XX interaction gate."""
    
    def __init__(self, angle: float):
        """
        Initialize XX gate.
        
        Args:
            angle: Interaction angle in radians
        """
        self.angle = angle

class YY(AngledGate):
    """YY interaction gate."""
    
    def __init__(self, angle: float):
        """
        Initialize YY gate.
        
        Args:
            angle: Interaction angle in radians
        """
        self.angle = angle

class ZZ(AngledGate):
    """ZZ interaction gate."""
    
    def __init__(self, angle: float):
        """
        Initialize ZZ gate.
        
        Args:
            angle: Interaction angle in radians
        """
        self.angle = angle

# Usage examples
def apply_two_qubit_gates(circuit: Circuit) -> Circuit:
    """
    Apply various two-qubit gates.
    
    Args:
        circuit: Target quantum circuit
        
    Returns:
        Circuit: Circuit with two-qubit gates applied
    """
    # Entangling gates
    circuit.cnot(0, 1)  # Controlled-NOT
    circuit.cz(1, 2)    # Controlled-Z
    
    # SWAP operations
    circuit.swap(0, 2)  # SWAP
    circuit.iswap(1, 2) # iSWAP
    
    # Parameterized gates
    circuit.xx(0, 1, np.pi/4)  # XX interaction
    circuit.yy(1, 2, np.pi/3)  # YY interaction  
    circuit.zz(0, 2, np.pi/2)  # ZZ interaction
    
    # Controlled phase
    circuit.cphaseshift(0, 1, np.pi/6)
    
    return circuit

Multi-Qubit Gates

from braket.circuits.gates import CCNot, CSwap

class CCNot(Gate):
    """Toffoli (controlled-controlled-NOT) gate."""
    
    def __init__(self):
        """Initialize Toffoli gate."""
        pass

class CSwap(Gate):
    """Fredkin (controlled-SWAP) gate."""
    
    def __init__(self):
        """Initialize Fredkin gate."""
        pass

def apply_multi_qubit_gates(circuit: Circuit) -> Circuit:
    """
    Apply multi-qubit gates.
    
    Args:
        circuit: Target quantum circuit
        
    Returns:
        Circuit: Circuit with multi-qubit gates applied
    """
    # Toffoli gate (3-qubit)
    circuit.ccnot(0, 1, 2)  # controls: 0,1  target: 2
    
    # Fredkin gate (3-qubit) 
    circuit.cswap(0, 1, 2)  # control: 0  targets: 1,2
    
    return circuit

Observables and Measurements

Observable Classes

from braket.circuits.observables import X, Y, Z, H, I, TensorProduct, Sum, Hermitian
import numpy as np

class X(StandardObservable):
    """Pauli-X observable."""
    
    def __init__(self):
        """Initialize Pauli-X observable."""
        pass

class Y(StandardObservable):
    """Pauli-Y observable."""
    
    def __init__(self):
        """Initialize Pauli-Y observable."""
        pass

class Z(StandardObservable):
    """Pauli-Z observable."""
    
    def __init__(self):
        """Initialize Pauli-Z observable."""
        pass

class TensorProduct(Observable):
    """Tensor product of observables."""
    
    def __init__(self, *observables):
        """
        Initialize tensor product observable.
        
        Args:
            *observables: Observables to tensor together
        """
        self.observables = observables

class Sum(Observable):
    """Sum of observables."""
    
    def __init__(self, *observables):
        """
        Initialize sum of observables.
        
        Args:
            *observables: Observables to sum
        """
        self.observables = observables

class Hermitian(Observable):
    """Custom Hermitian matrix observable."""
    
    def __init__(self, matrix: np.ndarray):
        """
        Initialize Hermitian observable.
        
        Args:
            matrix: Hermitian matrix
        """
        self.matrix = matrix

# Observable construction examples
def create_observables() -> dict:
    """
    Create various quantum observables.
    
    Returns:
        dict: Collection of observables for measurements
    """
    observables = {}
    
    # Single-qubit Pauli observables
    observables['pauli_x'] = X()
    observables['pauli_y'] = Y()  
    observables['pauli_z'] = Z()
    
    # Multi-qubit observables using tensor products
    observables['zz'] = Z() @ Z()  # Z⊗Z on qubits 0,1
    observables['xx'] = X() @ X()  # X⊗X on qubits 0,1
    observables['xyz'] = X() @ Y() @ Z()  # X⊗Y⊗Z on qubits 0,1,2
    
    # Sum of observables (Hamiltonian)
    observables['hamiltonian'] = (
        0.5 * (Z() @ I()) +  # Z on qubit 0
        0.3 * (I() @ Z()) +  # Z on qubit 1 
        0.1 * (X() @ X())    # XX interaction
    )
    
    # Custom Hermitian observable
    custom_matrix = np.array([[1, 0], [0, -1]], dtype=complex)
    observables['custom'] = Hermitian(custom_matrix)
    
    return observables

Result Types and Measurements

from braket.circuits.result_types import (
    StateVector, DensityMatrix, Expectation, Sample, Probability, 
    Variance, Amplitude, AdjointGradient
)

class StateVector(ResultType):
    """Full quantum state vector result."""
    
    def __init__(self):
        """Initialize state vector result type."""
        pass

class DensityMatrix(ResultType):
    """Density matrix result."""
    
    def __init__(self, target: QubitSetInput = None):
        """
        Initialize density matrix result type.
        
        Args:
            target: Target qubits, defaults to all qubits
        """
        self.target = target

class Expectation(ObservableResultType):
    """Observable expectation value."""
    
    def __init__(self, observable: Observable, target: QubitSetInput = None):
        """
        Initialize expectation value result.
        
        Args:
            observable: Observable to measure
            target: Target qubits
        """
        self.observable = observable
        self.target = target

class Sample(ObservableResultType):
    """Observable sampling result."""
    
    def __init__(self, observable: Observable, target: QubitSetInput = None):
        """
        Initialize sampling result.
        
        Args:
            observable: Observable to sample
            target: Target qubits
        """
        self.observable = observable
        self.target = target

class Probability(ResultType):
    """Measurement probability result."""
    
    def __init__(self, target: QubitSetInput = None):
        """
        Initialize probability result.
        
        Args:
            target: Target qubits
        """
        self.target = target

class Variance(ObservableResultType):
    """Observable variance result."""
    
    def __init__(self, observable: Observable, target: QubitSetInput = None):
        """
        Initialize variance result.
        
        Args:
            observable: Observable for variance calculation
            target: Target qubits
        """
        self.observable = observable
        self.target = target

# Measurement examples
def add_measurements_to_circuit(circuit: Circuit) -> Circuit:
    """
    Add various measurement result types to circuit.
    
    Args:
        circuit: Target quantum circuit
        
    Returns:
        Circuit: Circuit with measurements added
    """
    # State vector (full quantum state)
    circuit.state_vector()
    
    # Density matrix for specific qubits
    circuit.density_matrix([0, 1])
    
    # Observable expectation values
    circuit.expectation(observable=Z(), target=0)
    circuit.expectation(observable=X() @ X(), target=[0, 1])
    
    # Observable sampling
    circuit.sample(observable=Z(), target=0)
    
    # Measurement probabilities
    circuit.probability([0, 1])
    
    # Observable variance
    circuit.variance(observable=Z(), target=0)
    
    # Amplitude for specific computational basis states
    circuit.amplitude(['00', '11'])  # Bell state amplitudes
    
    return circuit

Noise Models

Noise Channels

from braket.circuits.noises import (
    BitFlip, PhaseFlip, PauliChannel, Depolarizing, 
    AmplitudeDamping, PhaseDamping, Kraus
)

class BitFlip(Noise):
    """Bit flip noise channel."""
    
    def __init__(self, probability: float):
        """
        Initialize bit flip noise.
        
        Args:
            probability: Bit flip probability [0, 1]
        """
        self.probability = probability

class PhaseFlip(Noise):
    """Phase flip noise channel."""
    
    def __init__(self, probability: float):
        """
        Initialize phase flip noise.
        
        Args:
            probability: Phase flip probability [0, 1]
        """
        self.probability = probability

class Depolarizing(Noise):
    """Depolarizing noise channel."""
    
    def __init__(self, probability: float):
        """
        Initialize depolarizing noise.
        
        Args:
            probability: Depolarizing probability [0, 1]
        """
        self.probability = probability

class AmplitudeDamping(Noise):
    """Amplitude damping noise channel."""
    
    def __init__(self, gamma: float):
        """
        Initialize amplitude damping.
        
        Args:
            gamma: Damping parameter [0, 1]
        """
        self.gamma = gamma

class PhaseDamping(Noise):
    """Phase damping noise channel."""
    
    def __init__(self, gamma: float):
        """
        Initialize phase damping.
        
        Args:
            gamma: Damping parameter [0, 1]  
        """
        self.gamma = gamma

class Kraus(Noise):
    """Custom Kraus operator noise."""
    
    def __init__(self, matrices: list[np.ndarray]):
        """
        Initialize Kraus noise channel.
        
        Args:
            matrices: List of Kraus operator matrices
        """
        self.matrices = matrices

# Noise application examples
def apply_noise_to_circuit(circuit: Circuit, noise_params: dict) -> Circuit:
    """
    Apply various noise channels to circuit.
    
    Args:
        circuit: Target quantum circuit
        noise_params: Noise parameter dictionary
        
    Returns:
        Circuit: Circuit with noise applied
    """
    # Single-qubit noise
    circuit.bit_flip(0, noise_params['bit_flip_prob'])
    circuit.phase_flip(1, noise_params['phase_flip_prob'])
    circuit.depolarizing(2, noise_params['depol_prob'])
    
    # Damping noise
    circuit.amplitude_damping(0, noise_params['amp_damp'])
    circuit.phase_damping(1, noise_params['phase_damp'])
    
    # Custom Kraus noise
    kraus_matrices = [
        np.array([[1, 0], [0, np.sqrt(1 - noise_params['custom'])]]),
        np.array([[0, np.sqrt(noise_params['custom'])], [0, 0]])
    ]
    circuit.kraus(2, kraus_matrices)
    
    return circuit

Noise Models

from braket.circuits.noises import NoiseModel, NoiseModelInstruction
from braket.circuits.noise_model.criteria import GateCriteria

class NoiseModel:
    """Comprehensive noise model for quantum circuits."""
    
    def __init__(self):
        """Initialize empty noise model."""
        pass
    
    def add_noise(self, noise: Noise, criteria: 'Criteria') -> 'NoiseModel':
        """
        Add noise to model with application criteria.
        
        Args:
            noise: Noise channel to apply
            criteria: Criteria for when to apply noise
            
        Returns:
            NoiseModel: Self for method chaining
        """
        pass
    
    def add_noise_to_gate(self, noise: Noise, gate_class: type) -> 'NoiseModel':
        """
        Add noise after specific gate types.
        
        Args:
            noise: Noise channel to apply
            gate_class: Gate class to target
            
        Returns:
            NoiseModel: Self for method chaining
        """
        pass

def create_realistic_noise_model() -> NoiseModel:
    """
    Create realistic noise model for NISQ devices.
    
    Returns:
        NoiseModel: Comprehensive noise model
    """
    noise_model = NoiseModel()
    
    # Single-qubit gate errors
    single_qubit_error = 0.001
    noise_model.add_noise_to_gate(
        Depolarizing(single_qubit_error), 
        gate_class=Rx
    )
    noise_model.add_noise_to_gate(
        Depolarizing(single_qubit_error), 
        gate_class=Ry
    )
    
    # Two-qubit gate errors (higher)
    two_qubit_error = 0.01
    noise_model.add_noise_to_gate(
        Depolarizing(two_qubit_error),
        gate_class=CNot  
    )
    
    # Measurement errors
    readout_error = 0.02
    noise_model.add_noise_to_gate(
        BitFlip(readout_error),
        gate_class=type(None)  # Apply to measurements
    )
    
    # T1/T2 coherence effects
    t1_damping = AmplitudeDamping(0.0001)  # T1 = 10ms
    t2_dephasing = PhaseDamping(0.0002)    # T2 = 5ms
    
    # Apply coherence noise to all operations
    for gate_type in [H, X, Y, Z, Rx, Ry, Rz, CNot]:
        noise_model.add_noise_to_gate(t1_damping, gate_type)
        noise_model.add_noise_to_gate(t2_dephasing, gate_type)
    
    return noise_model

Circuit Analysis and Visualization

Circuit Diagrams

from braket.circuits import AsciiCircuitDiagram, UnicodeCircuitDiagram, CircuitDiagram

class CircuitDiagram:
    """Base class for circuit visualization."""
    
    def __init__(self, circuit: Circuit):
        """
        Initialize circuit diagram.
        
        Args:
            circuit: Quantum circuit to visualize
        """
        self.circuit = circuit

class AsciiCircuitDiagram(CircuitDiagram):
    """ASCII-based circuit diagram."""
    
    def __str__(self) -> str:
        """
        Generate ASCII representation of circuit.
        
        Returns:
            str: ASCII circuit diagram
        """
        pass

class UnicodeCircuitDiagram(CircuitDiagram):
    """Unicode-based circuit diagram with better symbols."""
    
    def __str__(self) -> str:
        """
        Generate Unicode representation of circuit.
        
        Returns:
            str: Unicode circuit diagram
        """
        pass

def visualize_circuit(circuit: Circuit) -> str:
    """
    Create visual representation of quantum circuit.
    
    Args:
        circuit: Quantum circuit to visualize
        
    Returns:
        str: Visual circuit representation
    """
    # Create Unicode diagram for better visualization
    diagram = UnicodeCircuitDiagram(circuit)
    return str(diagram)

def print_circuit_info(circuit: Circuit) -> dict:
    """
    Print detailed information about circuit.
    
    Args:
        circuit: Quantum circuit to analyze
        
    Returns:
        dict: Circuit analysis information
    """
    info = {
        'qubit_count': circuit.qubit_count,
        'depth': circuit.depth,
        'gate_count': len(circuit.instructions),
        'moments': circuit.moments(),
        'diagram': str(circuit)
    }
    
    return info

Circuit Moments and Analysis

from braket.circuits import Moments, MomentsKey

class Moments:
    """Circuit moment analysis for optimization."""
    
    def __init__(self, circuit: Circuit):
        """
        Initialize moments analysis.
        
        Args:
            circuit: Circuit to analyze
        """
        self.circuit = circuit
    
    def depth(self) -> int:
        """
        Calculate circuit depth.
        
        Returns:
            int: Circuit depth in moments
        """
        pass
    
    def time_slices(self) -> list:
        """
        Get time slice representation.
        
        Returns:
            list: List of instruction time slices
        """
        pass

def analyze_circuit_structure(circuit: Circuit) -> dict:
    """
    Analyze quantum circuit structure and properties.
    
    Args:
        circuit: Circuit to analyze
        
    Returns:
        dict: Comprehensive circuit analysis
    """
    moments = Moments(circuit)
    
    analysis = {
        'qubit_count': circuit.qubit_count,
        'instruction_count': len(circuit.instructions),
        'circuit_depth': moments.depth(),
        'moment_structure': moments.time_slices(),
        'gate_types': {},
        'connectivity_graph': {},
        'parallelizable_operations': []
    }
    
    # Analyze gate types
    for instruction in circuit.instructions:
        gate_type = type(instruction.operator).__name__
        analysis['gate_types'][gate_type] = analysis['gate_types'].get(gate_type, 0) + 1
    
    return analysis

Compiler Directives

from braket.circuits.compiler_directives import StartVerbatimBox, EndVerbatimBox

class StartVerbatimBox(CompilerDirective):
    """Start verbatim compilation block."""
    
    def __init__(self):
        """Initialize start verbatim directive."""
        pass

class EndVerbatimBox(CompilerDirective):
    """End verbatim compilation block."""
    
    def __init__(self):
        """Initialize end verbatim directive.""" 
        pass

def add_verbatim_block(circuit: Circuit, protected_operations: callable) -> Circuit:
    """
    Add verbatim compilation block to preserve specific operations.
    
    Args:
        circuit: Target quantum circuit
        protected_operations: Function that adds protected operations
        
    Returns:
        Circuit: Circuit with verbatim block added
    """
    # Start verbatim block
    circuit.add_instruction(Instruction(StartVerbatimBox(), []))
    
    # Add protected operations that should not be optimized
    protected_operations(circuit)
    
    # End verbatim block
    circuit.add_instruction(Instruction(EndVerbatimBox(), []))
    
    return circuit

def create_protected_subcircuit() -> Circuit:
    """
    Create subcircuit with compilation protection.
    
    Returns:
        Circuit: Protected quantum subcircuit
    """
    circuit = Circuit()
    
    def protected_ops(c):
        # These operations will not be optimized by compiler
        c.h(0)
        c.cnot(0, 1) 
        c.rz(0, np.pi/8)  # Specific angle must be preserved
        c.cnot(0, 1)
        c.h(0)
    
    circuit = add_verbatim_block(circuit, protected_ops)
    return circuit

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.

Install with Tessl CLI

npx tessl i tessl/pypi-amazon-braket-sdk

docs

advanced-features.md

aws-integration.md

circuits.md

devices-simulation.md

index.md

quantum-information.md

tile.json