Problem Templates

QuantumStateSmoothPulseProblem(system, ψ_inits, ψ_goals, T, Δt; kwargs...)
QuantumStateSmoothPulseProblem(system, ψ_init, ψ_goal, T, Δt; kwargs...)
QuantumStateSmoothPulseProblem(H_drift, H_drives, args...; kwargs...)

Create a quantum state smooth pulse problem. The goal is to find a control pulse a(t) that drives all of the initial states ψ_inits to the corresponding target states ψ_goals using T timesteps of size Δt. This problem also controls the first and second derivatives of the control pulse, da(t) and dda(t), to ensure smoothness.

Arguments

• system::AbstractQuantumSystem: The quantum system.

or

• H_drift::AbstractMatrix{<:Number}: The drift Hamiltonian.
• H_drives::Vector{<:AbstractMatrix{<:Number}}: The control Hamiltonians.

with

• ψ_inits::Vector{<:AbstractVector{<:ComplexF64}}: The initial states.
• ψ_goals::Vector{<:AbstractVector{<:ComplexF64}}: The target states.

or

• ψ_init::AbstractVector{<:ComplexF64}: The initial state.
• ψ_goal::AbstractVector{<:ComplexF64}: The target state.

with

• T::Int: The number of timesteps.
• Δt::Float64: The timestep size.

Keyword Arguments

• state_name::Symbol=:ψ̃: The name of the state variable.
• control_name::Symbol=:a: The name of the control variable.
• timestep_name::Symbol=:Δt: The name of the timestep variable.
• init_trajectory::Union{NamedTrajectory, Nothing}=nothing: The initial trajectory.
• a_bound::Float64=1.0: The bound on the control pulse.
• a_bounds::Vector{Float64}=fill(a_bound, length(system.G_drives)): The bounds on the control pulse.
• a_guess::Union{Matrix{Float64}, Nothing}=nothing: The initial guess for the control pulse.
• da_bound::Float64=Inf: The bound on the first derivative of the control pulse.
• da_bounds::Vector{Float64}=fill(da_bound, length(system.G_drives)): The bounds on the first derivative of the control pulse.
• dda_bound::Float64=1.0: The bound on the second derivative of the control pulse.
• dda_bounds::Vector{Float64}=fill(dda_bound, length(system.G_drives)): The bounds on the second derivative of the control pulse.
• Δt_min::Float64=0.5 * Δt: The minimum timestep size.
• Δt_max::Float64=1.5 * Δt: The maximum timestep size.
• drive_derivative_σ::Float64=0.01: The standard deviation of the drive derivative random initialization.
• Q::Float64=100.0: The weight on the state objective.
• R=1e-2: The weight on the control pulse and its derivatives.
• R_a::Union{Float64, Vector{Float64}}=R: The weight on the control pulse.
• R_da::Union{Float64, Vector{Float64}}=R: The weight on the first derivative of the control pulse.
• R_dda::Union{Float64, Vector{Float64}}=R: The weight on the second derivative of the control pulse.
• constraints::Vector{<:AbstractConstraint}=AbstractConstraint[]: The constraints.
• piccolo_options::PiccoloOptions=PiccoloOptions(): The Piccolo options.

QuantumStateMinimumTimeProblem(traj, sys, obj, integrators, constraints; kwargs...)
QuantumStateMinimumTimeProblem(prob; kwargs...)

Construct a DirectTrajOptProblem for the minimum time problem of reaching a target state.

Keyword Arguments

• state_name::Symbol=:ψ̃: The symbol for the state variables.
• final_fidelity::Union{Real, Nothing}=nothing: The final fidelity.
• D=1.0: The cost weight on the time.
• piccolo_options::PiccoloOptions=PiccoloOptions(): The Piccolo options.

UnitarySmoothPulseProblem(system::AbstractQuantumSystem, operator, T, Δt; kwargs...)
UnitarySmoothPulseProblem(H_drift, H_drives, operator, T, Δt; kwargs...)

Construct a DirectTrajOptProblem for a free-time unitary gate problem with smooth control pulses enforced by constraining the second derivative of the pulse trajectory, i.e.,

\[\begin{aligned} \underset{\vec{\tilde{U}}, a, \dot{a}, \ddot{a}, \Delta t}{\text{minimize}} & \quad Q \cdot \ell\qty(\vec{\tilde{U}}_T, \vec{\tilde{U}}_{\text{goal}}) + \frac{1}{2} \sum_t \qty(R_a a_t^2 + R_{\dot{a}} \dot{a}_t^2 + R_{\ddot{a}} \ddot{a}_t^2) \\ \text{ subject to } & \quad \vb{P}^{(n)}\qty(\vec{\tilde{U}}_{t+1}, \vec{\tilde{U}}_t, a_t, \Delta t_t) = 0 \\ & \quad a_{t+1} - a_t - \dot{a}_t \Delta t_t = 0 \\ & \quad \dot{a}_{t+1} - \dot{a}_t - \ddot{a}_t \Delta t_t = 0 \\ & \quad |a_t| \leq a_{\text{bound}} \\ & \quad |\ddot{a}_t| \leq \ddot{a}_{\text{bound}} \\ & \quad \Delta t_{\text{min}} \leq \Delta t_t \leq \Delta t_{\text{max}} \\ \end{aligned}\]

where, for $U \in SU(N)$,

\[\ell\qty(\vec{\tilde{U}}_T, \vec{\tilde{U}}_{\text{goal}}) = \abs{1 - \frac{1}{N} \abs{ \tr \qty(U_{\text{goal}}, U_T)} }\]

is the infidelity objective function, $Q$ is a weight, $R_a$, $R_{\dot{a}}$, and $R_{\ddot{a}}$ are weights on the regularization terms, and $\vb{P}^{(n)}$ is the $n$th-order Pade integrator.

Arguments

• system::AbstractQuantumSystem: the system to be controlled

or

• H_drift::AbstractMatrix{<:Number}: the drift hamiltonian
• H_drives::Vector{<:AbstractMatrix{<:Number}}: the control hamiltonians

with

• goal::AbstractPiccoloOperator: the target unitary, either in the form of an EmbeddedOperator or a `Matrix{ComplexF64}
• T::Int: the number of timesteps
• Δt::Float64: the (initial) time step size

Keyword Arguments

• piccolo_options::PiccoloOptions=PiccoloOptions(): the options for the Piccolo solver
• state_name::Symbol = :Ũ⃗: the name of the state
• control_name::Symbol = :a: the name of the control
• timestep_name::Symbol = :Δt: the name of the timestep
• init_trajectory::Union{NamedTrajectory, Nothing}=nothing: an initial trajectory to use
• a_guess::Union{Matrix{Float64}, Nothing}=nothing: an initial guess for the control pulses
• a_bound::Float64=1.0: the bound on the control pulse
• a_bounds::Vector{Float64}=fill(a_bound, length(system.G_drives)): the bounds on the control pulses, one for each drive
• da_bound::Float64=Inf: the bound on the control pulse derivative
• da_bounds::Vector{Float64}=fill(da_bound, length(system.G_drives)): the bounds on the control pulse derivatives, one for each drive
• dda_bound::Float64=1.0: the bound on the control pulse second derivative
• dda_bounds::Vector{Float64}=fill(dda_bound, length(system.G_drives)): the bounds on the control pulse second derivatives, one for each drive
• Δt_min::Float64=Δt isa Float64 ? 0.5 * Δt : 0.5 * mean(Δt): the minimum time step size
• Δt_max::Float64=Δt isa Float64 ? 1.5 * Δt : 1.5 * mean(Δt): the maximum time step size
• Q::Float64=100.0: the weight on the infidelity objective
• R=1e-2: the weight on the regularization terms
• R_a::Union{Float64, Vector{Float64}}=R: the weight on the regularization term for the control pulses
• R_da::Union{Float64, Vector{Float64}}=R: the weight on the regularization term for the control pulse derivatives
• R_dda::Union{Float64, Vector{Float64}}=R: the weight on the regularization term for the control pulse second derivatives
• constraints::Vector{<:AbstractConstraint}=AbstractConstraint[]: the constraints to enforce

UnitaryMinimumTimeProblem(
    goal::AbstractPiccoloOperator,
    trajectory::NamedTrajectory,
    objective::Objective,
    dynamics::TrajectoryDynamics,
    constraints::AbstractVector{<:AbstractConstraint};
    kwargs...
)

UnitaryMinimumTimeProblem(
    goal::AbstractPiccoloOperator,
    prob::DirectTrajOptProblem;
    kwargs...
)

Create a minimum-time problem for unitary control.

\[\begin{aligned} \underset{\vec{\tilde{U}}, a, \dot{a}, \ddot{a}, \Delta t}{\text{minimize}} & \quad J(\vec{\tilde{U}}, a, \dot{a}, \ddot{a}) + D \sum_t \Delta t_t \\ \text{ subject to } & \quad \vb{P}^{(n)}\qty(\vec{\tilde{U}}_{t+1}, \vec{\tilde{U}}_t, a_t, \Delta t_t) = 0 \\ & c(\vec{\tilde{U}}, a, \dot{a}, \ddot{a}) = 0 \\ & \quad \Delta t_{\text{min}} \leq \Delta t_t \leq \Delta t_{\text{max}} \\ \end{aligned}\]

Keyword Arguments

• piccolo_options::PiccoloOptions=PiccoloOptions(): The Piccolo options.
• unitary_name::Symbol=:Ũ⃗: The name of the unitary for the goal.
• final_fidelity::Float64=1.0: The final fidelity constraint.
• D::Float64=1.0: The scaling factor for the minimum-time objective.

UnitarySamplingProblem(systemns, operator, T, Δt; kwargs...)

A UnitarySamplingProblem is a quantum control problem where the goal is to find a control pulse that generates a target unitary operator for a set of quantum systems. The controls are shared among all systems, and the optimization seeks to find the control pulse that achieves the operator for each system. The idea is to enforce a robust solution by including multiple systems reflecting the problem uncertainty.

Arguments

• systems::AbstractVector{<:AbstractQuantumSystem}: A vector of quantum systems.
• operators::AbstractVector{<:AbstractPiccoloOperator}: A vector of target operators.
• T::Int: The number of time steps.
• Δt::Union{Float64, Vector{Float64}}: The time step value or vector of time steps.

Keyword Arguments

• system_labels::Vector{String} = string.(1:length(systems)): The labels for each system.
• system_weights::Vector{Float64} = fill(1.0, length(systems)): The weights for each system.
• init_trajectory::Union{NamedTrajectory, Nothing} = nothing: The initial trajectory.
• state_name::Symbol = :Ũ⃗: The name of the state variable.
• control_name::Symbol = :a: The name of the control variable.
• timestep_name::Symbol = :Δt: The name of the timestep variable.
• constraints::Vector{<:AbstractConstraint} = AbstractConstraint[]: The constraints.
• a_bound::Float64 = 1.0: The bound for the control amplitudes.
• a_bounds::Vector{Float64} = fill(a_bound, length(systems[1].G_drives)): The bounds for the control amplitudes.
• a_guess::Union{Matrix{Float64}, Nothing} = nothing: The initial guess for the control amplitudes.
• da_bound::Float64 = Inf: The bound for the control first derivatives.
• da_bounds::Vector{Float64} = fill(da_bound, length(systems[1].G_drives)): The bounds for the control first derivatives.
• dda_bound::Float64 = 1.0: The bound for the control second derivatives.
• dda_bounds::Vector{Float64} = fill(dda_bound, length(systems[1].G_drives)): The bounds for the control second derivatives.
• Δt_min::Float64 = 0.5 * Δt: The minimum time step size.
• Δt_max::Float64 = 1.5 * Δt: The maximum time step size.
• Q::Float64 = 100.0: The fidelity weight.
• R::Float64 = 1e-2: The regularization weight.
• R_a::Union{Float64, Vector{Float64}} = R: The regularization weight for the control amplitudes.
• R_da::Union{Float64, Vector{Float64}} = R: The regularization weight for the control first derivatives.
• R_dda::Union{Float64, Vector{Float64}} = R: The regularization weight for the control second derivatives.
• piccolo_options::PiccoloOptions = PiccoloOptions(): The Piccolo options.