### Full Workflow: Initialize, Optimize, and Analyze Circuits - Julia

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

An end-to-end example demonstrating the complete workflow of QEPOptimize.jl, including population initialization, evolutionary optimization over multiple steps, and subsequent analysis of the best circuit's performance and visualization of the optimization history. This script serves as a comprehensive guide for users.

```julia
using QEPOptimize
using QEPOptimize: initialize_pop!, step!, NetworkFidelity
using BPGates: PauliNoise
using CairoMakie
using Quantikz: displaycircuit

# Configuration
config = (
    num_simulations = 1000,
    number_registers = 4,
    purified_pairs = 1,
    code_distance = 1,
    pop_size = 20,
    noises = [NetworkFidelity(0.9), PauliNoise(0.01/3, 0.01/3, 0.01/3)]
)

init_config = (
    start_ops = 10,
    start_pop_size = 1000,
    config...
)

step_config = (
    max_ops = 15,
    new_mutants = 10,
    p_drop = 0.1,
    p_mutate = 0.1,
    p_gain = 0.1,
    config...
)

# Initialize population
pop = Population()
initialize_pop!(pop; init_config...)

# Run evolutionary optimization
_, fitness_history, transition_counts_matrix, transition_counts_keys =
    multiple_steps_with_history!(pop, 80; step_config...)

# Visualize optimization progress
fig1 = plot_fitness_history(fitness_history, transition_counts_matrix, transition_counts_keys)
display(fig1)

# Get best circuit
best_circuit = pop.individuals[1]
println("Best circuit fitness: ", best_circuit.fitness)
println("Best circuit length: ", length(best_circuit.ops))

# Analyze best circuit performance
fig2 = plot_circuit_analysis(
    best_circuit;
    num_simulations = 100000,
    number_registers = config.number_registers,
    purified_pairs = config.purified_pairs,
    noise_sets = [[PauliNoise(0.01/3, 0.01/3, 0.01/3)], []],
    noise_set_labels = ["p=0.01", "p=0"]
)
display(fig2)

# Display circuit diagram
# displaycircuit(best_circuit.ops)
```

--------------------------------

### Initialize Quantum Circuit Population (Julia)

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Creates an initial population of random quantum circuits. This function initializes a `Population` object, generates random circuits with specified parameters (number of operations, registers, noise models), evaluates their fitness using Monte Carlo simulations, and retains a subset of the best candidates. It requires QEPOptimize and BPGates packages.

```julia
using QEPOptimize
using BPGates: PauliNoise

# Create empty population
pop = Population()

# Initialize with random circuits
initialize_pop!(pop;
    start_ops = 10,              # Initial number of operations per circuit
    start_pop_size = 1000,       # Generate 1000 random circuits
    number_registers = 4,        # Use 4 Bell pairs
    pop_size = 20,               # Keep top 20 after evaluation
    num_simulations = 1000,      # Monte Carlo samples per circuit
    purified_pairs = 1,          # Target 1 purified pair
    code_distance = 1,           # For logical qubit fidelity calculation
    noises = [NetworkFidelity(0.9), PauliNoise(0.01/3, 0.01/3, 0.01/3)],
    evolution_metric = :logical_qubit_fidelity,
    max_performance_calcs = 10
)

# Check initialized population
println("Population size: ", length(pop.individuals))
println("Best fitness: ", pop.individuals[1].fitness)
println("Worst fitness: ", pop.individuals[end].fitness)
```

--------------------------------

### Population: Manage a Collection of Quantum Circuit Individuals

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Maintains a collection of `Individual` objects representing quantum circuits and tracks their evolutionary history during optimization. Allows creation of empty populations and inspection of their state.

```julia
using QEPOptimize

# Create an empty population
pop = Population()

# Check population state
println("Size: ", length(pop.individuals))
println("Selection history: ", pop.selection_history)
```

--------------------------------

### calculate_performance!: Evaluate Quantum Circuit Performance with Simulations

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Evaluates a quantum circuit by running Monte Carlo simulations with specified noise conditions. Updates the `Individual`'s performance metrics in place.

```julia
using QEPOptimize
using BPGates: CNOTPerm, BellMeasure, PauliNoise

# Define a simple purification circuit
circuit = Individual([CNOTPerm(1,1,2,1), BellMeasure(1,2)])

# Evaluate circuit performance
# Network fidelity of 0.9 means initial Bell pairs have 90% fidelity
# Gate noise of 0.01/3 per Pauli operator adds realistic errors
performance = calculate_performance!(
    circuit;
    num_simulations = 100000,
    number_registers = 2,
    purified_pairs = 1,
    code_distance = 1,
    noises = [NetworkFidelity(0.9), PauliNoise(0.01/3, 0.01/3, 0.01/3)]
)

println("Purified fidelity: ", performance.purified_pairs_fidelity)
println("Success probability: ", performance.success_probability)
println("Logical qubit fidelity: ", performance.logical_qubit_fidelity)
println("Average marginal fidelity: ", performance.average_marginal_fidelity)
```

--------------------------------

### Perform Single Genetic Algorithm Step (Julia)

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Executes a single generation of the genetic algorithm. This function updates the population by creating mutants, evaluating their performance, and selecting survivors based on the specified evolution metric. It requires QEPOptimize and BPGates packages and takes various parameters for mutation rates, noise models, and simulation settings.

```julia
using QEPOptimize
using BPGates: PauliNoise

# Initialize population first
pop = Population()
initialize_pop!(pop;
    start_ops = 10,
    start_pop_size = 1000,
    number_registers = 4,
    pop_size = 20,
    num_simulations = 1000,
    purified_pairs = 1,
    noises = [NetworkFidelity(0.9)]
)

# Run single evolution step
step!(pop;
    max_ops = 15,
    number_registers = 4,
    purified_pairs = 1,
    num_simulations = 1000,
    pop_size = 20,
    code_distance = 1,
    noises = [NetworkFidelity(0.9), PauliNoise(0.01/3, 0.01/3, 0.01/3)],
    new_mutants = 10,
    p_drop = 0.1,
    p_mutate = 0.1,
    p_gain = 0.1,
    evolution_metric = :logical_qubit_fidelity,
    max_performance_calcs = 10,
    safe_canonicalize = true
)

println("Population after step: ", length(pop.individuals))
println("Best fitness after step: ", pop.individuals[1].fitness)

```

--------------------------------

### Visualize Fitness History and Optimization Progress - Julia

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Visualizes the evolutionary optimization progress, including fitness trends over generations and distributions of mutation types. This plot aids in understanding how the optimization algorithm converges and explores the search space.

```julia
using QEPOptimize
using CairoMakie

# After running multiple_steps_with_history!
_, fitness_history, transition_counts_matrix, transition_counts_keys = multiple_steps_with_history!(
    pop, 80; 
    max_ops = 15,
    new_mutants = 10,
    num_simulations = 1000,
    number_registers = 4,
    pop_size = 20,
    noises = [NetworkFidelity(0.9), PauliNoise(0.01/3, 0.01/3, 0.01/3)]
)

# Create comprehensive fitness visualization
fig = plot_fitness_history(fitness_history, transition_counts_matrix, transition_counts_keys)

# Display creates three plots:
# Top: Heatmap of all individuals' fitness over generations
# Middle: Best and worst fitness trends
# Bottom: Distribution of mutation types (survivor, drop, gain, swap, etc.)
display(fig)
```

--------------------------------

### Evolve Quantum Circuits Over Multiple Generations (Julia)

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Runs a genetic algorithm for multiple generations to optimize quantum circuits. This function takes an initialized population and evolves it over a specified number of generations, tracking fitness history and mutation types. It requires QEPOptimize and BPGates packages, and uses a configuration tuple for various optimization parameters.

```julia
using QEPOptimize
using BPGates: PauliNoise

# Configuration for optimization
config = (
    num_simulations = 1000,
    number_registers = 4,
    purified_pairs = 1,
    code_distance = 1,
    pop_size = 20,
    noises = [NetworkFidelity(0.9), PauliNoise(0.01/3, 0.01/3, 0.01/3)]
)

# Initialize population
pop = Population()
initialize_pop!(pop;
    start_ops = 10,
    start_pop_size = 1000,
    config...
)

# Evolve for 80 generations
final_pop, fitness_history, transition_matrix, transition_keys = multiple_steps_with_history!(pop,
    80;  # Number of generations
    max_ops = 15,                         # Maximum operations per circuit
    new_mutants = 10,                     # New mutations per parent per generation
    p_drop = 0.1,                         # Probability to drop an operation
    p_mutate = 0.1,                       # Probability to mutate an operation
    p_gain = 0.1,                         # Probability to add an operation
    evolution_metric = :logical_qubit_fidelity,
    max_performance_calcs = 10,
    config...
)

# Access best circuit
best_circuit = final_pop.individuals[1]
println("Best fitness: ", best_circuit.fitness)
println("Circuit length: ", length(best_circuit.ops))
println("Final population diversity: ", length(Set([length(i.ops) for i in final_pop.individuals])))

```

--------------------------------

### Individual: Create and Access Quantum Circuit Data

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Represents a quantum purification circuit within the evolutionary population. Allows creation, modification, and access to circuit operations, performance metrics, and history.

```julia
using QEPOptimize
using BPGates: CNOTPerm, BellMeasure

# Create a simple purification circuit
# CNOT gate: control on register 1 qubit 1, target on register 2 qubit 1
# Then measure register 1 and 2
circuit = Individual([CNOTPerm(1,1,2,1), BellMeasure(1,2)])

# Create an empty circuit
empty_circuit = Individual()

# Access circuit properties
println("History: ", circuit.history)          # :manual
println("Operations: ", circuit.ops)           # Vector of quantum operations
println("Fitness: ", circuit.fitness)          # 0.0 (not yet calculated)
println("Performance: ", circuit.performance)  # Performance metrics
```

--------------------------------

### Analyze Output Fidelity vs. Input Fidelity (Julia)

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Analyzes how a given quantum purification circuit transforms input fidelity to output fidelity across a range of input fidelity values. It requires the QEPOptimize and BPGates packages and simulates the circuit's performance with specified noise models and parameters. The function returns lists of input fidelities, corresponding output fidelities, and success probabilities.

```julia
using QEPOptimize
using BPGates: CNOTPerm, BellMeasure, PauliNoise

# Simple purification circuit
circuit = Individual([CNOTPerm(1,1,2,1), BellMeasure(1,2)])

# Analyze circuit performance across input fidelities
f_ins, f_outs, probs = analyze_f_out_vs_f_in(
    circuit;
    num_simulations = 100000,
    number_registers = 2,
    purified_pairs = 1,
    noises = [PauliNoise(0.01/3, 0.01/3, 0.01/3)],
    f_ins = [0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99]
)

# Display results
for (f_in, f_out, prob) in zip(f_ins, f_outs, probs)
    println("F_in: $f_in → F_out: $f_out (success: $prob)")
end

```

--------------------------------

### Performance: Structure Quantum Circuit Performance Metrics

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Stores detailed metrics for quantum circuit quality, including fidelity, success probability, and error distributions. Typically generated by `calculate_performance!`, but can be manually constructed for testing.

```julia
using QEPOptimize

# Performance is typically created by calculate_performance!
# but can be constructed manually for testing
perf = Performance(
    [0.9, 0.08, 0.02],  # error_probabilities for 0, 1, 2 errors
    0.9,                 # purified_pairs_fidelity
    0.98,                # logical_qubit_fidelity
    0.92,                # average_marginal_fidelity
    0.85,                # success_probability
    1                    # num_calcs
)

# Access performance metrics
println("Purified fidelity: ", perf.purified_pairs_fidelity)
println("Success rate: ", perf.success_probability)
println("Error distribution: ", perf.error_probabilities)
```

--------------------------------

### Visualize Circuit Performance Analysis - Julia

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Generates and displays plots to visualize circuit performance across different input fidelities and noise models. This function is useful for understanding the effectiveness of entanglement purification protocols.

```julia
using QEPOptimize
using BPGates: CNOTPerm, BellMeasure, PauliNoise
using CairoMakie

# Best circuit from optimization
best_circuit = pop.individuals[1]

# Create analysis plots comparing different noise levels
fig = plot_circuit_analysis(
    best_circuit; 
    num_simulations = 100000,
    number_registers = 4,
    purified_pairs = 1,
    noise_sets = [
        [PauliNoise(0.01/3, 0.01/3, 0.01/3)],  # With gate noise
        []                                       # No gate noise
    ],
    noise_set_labels = ["p=0.01", "p=0"],
    f_ins = [0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99, 0.999]
)

# Display creates two plots:
# Left: F_in vs F_out showing purification curve
# Right: F_in vs success probability
display(fig)
```

--------------------------------

### NetworkFidelity: Simulate Imperfect Initial Entanglement Distribution

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Creates a network noise model by applying Pauli errors to initial Bell pairs, simulating imperfect entanglement distribution. This noise is typically used in conjunction with other noise sources like `PauliNoise`.

```julia
using QEPOptimize
using BPGates: PauliNoise

# Network fidelity of 0.9 (90% faithful Bell pairs)
network_noise = NetworkFidelity(0.9)

# Equivalent to NetworkPauliNoise with px=py=pz=(1-0.9)/3
# This creates unbiased Pauli noise

# Use with multiple noise sources
circuit = Individual([CNOTPerm(1,1,2,1), BellMeasure(1,2)])
performance = calculate_performance!(
    circuit;
    num_simulations = 10000,
    number_registers = 2,
    noises = [
        NetworkFidelity(0.9),                    # Initial entanglement quality
        PauliNoise(0.01/3, 0.01/3, 0.01/3)      # Gate noise
    ]
)
```

--------------------------------

### Convert Fidelity to Pauli Noise Parameters (Julia)

Source: https://context7.com/quantumsavory/qepoptimize.jl/llms.txt

Converts a given fidelity value into symmetric Pauli error probabilities (X, Y, Z). It assumes the total error is distributed equally among the three Pauli channels. Requires the QEPOptimize package.

```julia
using QEPOptimize

# Convert fidelity to Pauli noise parameters
f_in = 0.9
px, py, pz = f_in_to_pauli(f_in)

println("Pauli X error rate: ", px)  # 0.0333...
println("Pauli Y error rate: ", py)  # 0.0333...
println("Pauli Z error rate: ", pz)  # 0.0333...
# Total error rate: 1 - f_in = 0.1, distributed equally
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.