Feature/variational

Project.toml

@@ -1,7 +1,7 @@
 name = "QuantumCollocation"
 uuid = "0dc23a59-5ffb-49af-b6bd-932a8ae77adf"
 authors = ["Aaron Trowbridge <[email protected]> and contributors"]
-version = "0.7.0"
+version = "0.7.2"
 
 [deps]
 DirectTrajOpt = "c823fa1f-8872-4af5-b810-2b9b72bbbf56"
@@ -21,14 +21,14 @@ TestItems = "1c621080-faea-4a02-84b6-bbd5e436b8fe"
 TrajectoryIndexingUtils = "6dad8b7f-dd9a-4c28-9b70-85b9a079bfc8"
 
 [compat]
-DirectTrajOpt = "0.1.0"
+DirectTrajOpt = "0.2"
 Distributions = "0.25"
 ExponentialAction = "0.2"
 Interpolations = "0.15"
 JLD2 = "0.5"
 LinearAlgebra = "1.10, 1.11"
 NamedTrajectories = "0.3"
-PiccoloQuantumObjects = "0.3"
+PiccoloQuantumObjects = "0.4"
 Random = "1.10, 1.11"
 Reexport = "1.2"
 SparseArrays = "1.10, 1.11"

README.md

@@ -67,30 +67,7 @@
 ```
 where $\mathbf{Z}$ is a trajectory  containing states and controls, from [NamedTrajectories.jl](https://github.com/harmoniqs/NamedTrajectories.jl).
 
-### Problem Templates 
-
-*Problem Templates* are reusable design patterns for setting up and solving common quantum control problems. 
-
-For example, a *UnitarySmoothPulseProblem* is tasked with generating a *pulse* sequence $a_{1:T-1}$ in orderd to minimize infidelity, subject to constraints from the Schroedinger equation,
-```math
-    \begin{aligned}
-        \arg \min_{\mathbf{Z}}\quad & |1 - \mathcal{F}(U_T, U_\text{goal})|  \\
-        \nonumber \text{s.t.}
-        \qquad & U_{t+1} = \exp\{- i H(a_t) \Delta t_t \} U_t, \quad \forall\, t \\
-    \end{aligned}
-```
-while a *UnitaryMinimumTimeProblem* minimizes time and constrains fidelity,
-```math
-    \begin{aligned}
-        \arg \min_{\mathbf{Z}}\quad & \sum_{t=1}^T \Delta t_t \\
-        \qquad & U_{t+1} = \exp\{- i H(a_t) \Delta t_t \} U_t, \quad \forall\, t \\
-        \nonumber & \mathcal{F}(U_T, U_\text{goal}) \ge 0.9999
-    \end{aligned}
-```
-
-In each case, the dynamics between *knot points* $(U_t, a_t)$ and $(U_{t+1}, a_{t+1})$ are enforced as constraints on the states, which are free variables in the solver; this optimization framework is called *direct collocation*. For details of our implementation please see our award-winning IEEE QCE 2023 paper, [Direct Collocation for Quantum Optimal Control](https://arxiv.org/abs/2305.03261). If you use QuantumCollocation.jl in your work, please cite :raised_hands:!
-
-Problem templates give the user the ability to add other constraints and objective functions to this problem and solve it efficiently using [Ipopt.jl](https://github.com/jump-dev/Ipopt.jl) and [MathOptInterface.jl](https://github.com/jump-dev/MathOptInterface.jl) under the hood.
+For details of our implementation please see our IEEE QCE 2023 paper, [Direct Collocation for Quantum Optimal Control](https://arxiv.org/abs/2305.03261). If you use QuantumCollocation.jl in your work, please cite :raised_hands:!
 
 ## Installation
 

docs/literate/man/ket_problem_templates.jl

@@ -0,0 +1,97 @@
+# ```@meta
+# CollapsedDocStrings = true
+# ```
+using NamedTrajectories
+using PiccoloQuantumObjects
+using QuantumCollocation
+
+# -----
+
+#=
+## Quantum State Smooth Pulse Problem
+
+```@docs; canonical = false
+QuantumStateSmoothPulseProblem
+```
+
+Each problem starts with a `QuantumSystem` object, which is used to define the system's
+Hamiltonian and control operators. The goal is to find a control pulse that drives the
+intial state, `ψ_init`, to a target state, `ψ_goal`.
+=#
+
+# _define the quantum system_
+system = QuantumSystem(0.1 * PAULIS.Z, [PAULIS.X, PAULIS.Y])
+ψ_init = Vector{ComplexF64}([1.0, 0.0])
+ψ_goal = Vector{ComplexF64}([0.0, 1.0])
+T = 51
+Δt = 0.2
+
+# _create the smooth pulse problem_
+state_prob = QuantumStateSmoothPulseProblem(system, ψ_init, ψ_goal, T, Δt);
+
+# _check the fidelity before solving_
+println("Before: ", rollout_fidelity(state_prob.trajectory, system))
+
+# _solve the problem_
+solve!(state_prob, max_iter=100, verbose=true, print_level=1);
+
+# _check the fidelity after solving_
+println("After: ", rollout_fidelity(state_prob.trajectory, system))
+
+# _extract the control pulses_
+state_prob.trajectory.a |> size
+
+# -----
+
+#=
+## Quantum State Minimum Time Problem
+
+```@docs; canonical = false
+QuantumStateMinimumTimeProblem
+```
+=#
+
+# _create the minimum time problem_
+min_state_prob = QuantumStateMinimumTimeProblem(state_prob, ψ_goal);
+
+# _check the previous duration_
+println("Duration before: ", get_duration(state_prob.trajectory))
+
+# _solve the minimum time problem_
+solve!(min_state_prob, max_iter=100, verbose=true, print_level=1);
+
+# _check the new duration_
+println("Duration after: ", get_duration(min_state_prob.trajectory))
+
+# _the fidelity is preserved by a constraint_
+println("Fidelity after: ", rollout_fidelity(min_state_prob.trajectory, system))
+
+# -----
+
+#=
+
+## Quantum State Sampling Problem
+
+```@docs; canonical = false
+QuantumStateSamplingProblem
+```
+=#
+
+# _create a sampling problem_
+driftless_system = QuantumSystem([PAULIS.X, PAULIS.Y])
+sampling_state_prob = QuantumStateSamplingProblem([system, driftless_system], ψ_init, ψ_goal, T, Δt);
+
+# _new keys are added to the trajectory for the new states_
+println(sampling_state_prob.trajectory.state_names)
+
+# _solve the sampling problem for a few iterations_
+solve!(sampling_state_prob, max_iter=25, verbose=true, print_level=1);
+
+# _check the fidelity of the sampling problem (use the updated key to get the initial and goal)_
+println("After (original system): ", rollout_fidelity(sampling_state_prob.trajectory, system, state_name=:ψ̃1_system_1))
+println("After (new system): ", rollout_fidelity(sampling_state_prob.trajectory, driftless_system, state_name=:ψ̃1_system_1))
+
+# _compare this to using the original problem on the new system_
+println("After (new system, original `prob`): ", rollout_fidelity(state_prob.trajectory, driftless_system))
+
+# -----