Adding operator support to time evolution problem #606

Gavin-Rockwood · 2025-12-01T05:49:16Z

Checklist

Thank you for contributing to QuantumToolbox.jl! Please make sure you have finished the following tasks before opening the PR.

Please read Contributing to Quantum Toolbox in Julia.
Any code changes were done in a way that does not break public API.
Appropriate tests were added and tested locally by running: make test.
Any code changes should be julia formatted by running: make format.
All documents (in docs/ folder) related to code changes were updated and able to build locally by running: make docs.
(If necessary) the CHANGELOG.md should be updated (regarding to the code changes) and built by running: make changelog.

Request for a review after you have completed all the tasks. If you have not finished them all, you can also open a Draft Pull Request to let the others know this on-going work.

Description

Updated TimeEvolutionProblem be parametrically typed using the type of the starting state as well as expanded sesolve, mesolve and mcsolve to allow them to take in operators, superoperators and operators respectively (along with other changes to facilitate this). ssesolve and smesolve are still in progress.

Related issues or PRs

Working on #521

…nsions for examples.

…ions for usage.

…onProblem

…ense.

.gitignore

src/time_evolution/time_evolution.jl

src/time_evolution/mcsolve.jl

src/time_evolution/mesolve.jl

src/time_evolution/mcsolve.jl

…onProblem

…ussed in the PR comments.

src/time_evolution/mcsolve.jl

src/time_evolution/mesolve.jl

src/time_evolution/sesolve.jl

src/time_evolution/smesolve.jl

src/time_evolution/ssesolve.jl

ytdHuang · 2025-12-06T03:45:27Z

src/time_evolution/mesolve.jl

    T = Base.promote_eltype(L_evo, ψ0)
-    ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type
-        to_dense(_complex_float_type(T), copy(ψ0.data))
-    else
-        to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))
+    # ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type
+    #     to_dense(_complex_float_type(T), copy(ψ0.data))
+    # else
+    #     to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))
+    # end
+    if isoper(ψ0)
+        ρ0 = to_dense(_complex_float_type(T), mat2vec(ψ0.data))
+        state_type = Operator()
+    elseif isoperket(ψ0)
+        ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data))
+        state_type = OperatorKet()
+    elseif isket(ψ0)
+        ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))
+        state_type = Operator()
+    elseif issuper(ψ0)
+        ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data))
+        state_type = SuperOperator()
    end


Suggested change

T = Base.promote_eltype(L_evo, ψ0)

ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type

to_dense(_complex_float_type(T), copy(ψ0.data))

else

to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))

# ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type

# to_dense(_complex_float_type(T), copy(ψ0.data))

# else

# to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))

# end

if isoper(ψ0)

ρ0 = to_dense(_complex_float_type(T), mat2vec(ψ0.data))

state_type = Operator()

elseif isoperket(ψ0)

ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data))

state_type = OperatorKet()

elseif isket(ψ0)

ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))

state_type = Operator()

elseif issuper(ψ0)

ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data))

state_type = SuperOperator()

end

# Convert to dense vector with complex element type

T = _complex_float_type(Base.promote_eltype(L_evo, ψ0))

if isoperket(ψ0) || issuper(ψ0)

ρ0 = to_dense(T, copy(ψ0.data))

states_type = ψ0.type

else

ρ0 = to_dense(T, mat2vec(ket2dm(ψ0).data))

states_type = Operator()

end

ket2dm will do nothing if the input is density matrix (Operator), so it doesn't hurt performance, and we can also do ket2dm for Operator input.

Also, maybe also use states_type instead of state_type to avoid confusion, since we call it states_type in TimeEvolutionProblem

ytdHuang · 2025-12-06T03:53:49Z

src/time_evolution/mesolve.jl

+        if isoper(state)
+            to_dense(_complex_float_type(T), mat2vec(state.data))
+        elseif isoperket(state)
+            to_dense(_complex_float_type(T), copy(state.data))
+        elseif isket(state)
+            to_dense(_complex_float_type(T), mat2vec(ket2dm(state).data))
+        elseif issuper(state)
+            to_dense(_complex_float_type(T), copy(state.data))
        end


same here

Suggested change

if isoper(state)

to_dense(_complex_float_type(T), mat2vec(state.data))

elseif isoperket(state)

to_dense(_complex_float_type(T), copy(state.data))

elseif isket(state)

to_dense(_complex_float_type(T), mat2vec(ket2dm(state).data))

elseif issuper(state)

to_dense(_complex_float_type(T), copy(state.data))

end

if isoperket(state) || issuper(state)

to_dense(T, copy(state.data))

else

to_dense(T, mat2vec(ket2dm(state).data))

end

ytdHuang · 2025-12-06T03:55:49Z

src/time_evolution/mesolve.jl

-    if getVal(isoperket)
-        ρt = map(ϕ -> QuantumObject(ϕ, type = OperatorKet(), dims = dimensions), sol.u)
+function _gen_mesolve_solution(sol, prob::TimeEvolutionProblem{ST}) where {ST<:Union{Operator,OperatorKet,SuperOperator}}
+    if prob.states_type == Operator


I think here should be

Suggested change

if prob.states_type == Operator

if prob.states_type isa Operator

cause prob.states_type should be Operator() ?

ytdHuang · 2025-12-06T20:10:47Z

src/time_evolution/smesolve.jl

+#_smesolve_generate_state(u, dims, isoperket::Val{false}) = QuantumObject(vec2mat(u), type = Operator(), dims = dims)
+#_smesolve_generate_state(u, dims, isoperket::Val{true}) = QuantumObject(u, type = OperatorKet(), dims = dims)
+function _smesolve_generate_state(u, dims, type)
+    if type == OperatorKet
+        return QuantumObject(u, type = type, dims = dims)
+    else
+        return QuantumObject(vec2mat(u), type = Operator(), dims = dims)
+    end
+end


Suggested change

#_smesolve_generate_state(u, dims, isoperket::Val{false}) = QuantumObject(vec2mat(u), type = Operator(), dims = dims)

#_smesolve_generate_state(u, dims, isoperket::Val{true}) = QuantumObject(u, type = OperatorKet(), dims = dims)

function _smesolve_generate_state(u, dims, type)

if type == OperatorKet

return QuantumObject(u, type = type, dims = dims)

else

return QuantumObject(vec2mat(u), type = Operator(), dims = dims)

end

end

_smesolve_generate_state(u, dims, type::Operator) = QuantumObject(vec2mat(u), type = type, dims = dims)

_smesolve_generate_state(u, dims, type::OperatorKet) = QuantumObject(u, type = type, dims = dims)

ytdHuang · 2025-12-06T20:18:17Z

src/time_evolution/mesolve.jl

    prob = ODEProblem{getVal(inplace),FullSpecialize}(L, ρ0, tspan, params; kwargs4...)

-    return TimeEvolutionProblem(prob, tlist, L_evo.dimensions, (isoperket = Val(isoperket(ψ0)),))
+    return TimeEvolutionProblem(prob, tlist, state_type, L_evo.dimensions)


Suggested change

return TimeEvolutionProblem(prob, tlist, state_type, L_evo.dimensions)

return TimeEvolutionProblem(prob, tlist, states_type, L_evo.dimensions)

ytdHuang · 2025-12-06T20:30:10Z

src/time_evolution/sesolve.jl

+    ψ0 = map(to_dense, ψ0) # Convert all initial states to dense vectors
+
    ψ0_iter = map(get_data, ψ0)


This changes the input ψ0 provided by users, better do it in same way as mesolve:

Suggested change

ψ0 = map(to_dense, ψ0) # Convert all initial states to dense vectors

ψ0_iter = map(get_data, ψ0)

ψ0_iter = map(state -> to_dense(_complex_float_type(eltype(state)), copy(state.data)), ψ0) # Convert all initial states to dense vectors

Gavin-Rockwood added 5 commits November 30, 2025 22:25

made most of the changes. Look at testing.ipynb ##Testing Solver Exte…

571abc9

…nsions for examples.

Added operator support. Look at testing.ipynb ##Testing Solver Extens…

9665194

…ions for usage.

Merge branch 'qutip:main' into Adding-Operator-Support-to-TimeEvoluti…

0e6036a

…onProblem

updated testing.ipynb

01baa16

added to_dense call to sesolve_map to ensure all initial states are d…

e575f7d

…ense.

ytdHuang reviewed Dec 1, 2025

View reviewed changes

Gavin-Rockwood added 4 commits December 2, 2025 18:40

fixed .gitignore and removed testing.ipynb

71842a7

Merge branch 'qutip:main' into Adding-Operator-Support-to-TimeEvoluti…

41e8216

…onProblem

Updated the state type variable to ST and made the other changes disc…

5a354fe

…ussed in the PR comments.

fixed a bug with smesolve!

d8d26a3

ytdHuang reviewed Dec 4, 2025

View reviewed changes

ytdHuang reviewed Dec 6, 2025

View reviewed changes

	if prob.states_type == Operator
	if prob.states_type isa Operator

	return TimeEvolutionProblem(prob, tlist, state_type, L_evo.dimensions)
	return TimeEvolutionProblem(prob, tlist, states_type, L_evo.dimensions)

		ψ0 = map(to_dense, ψ0) # Convert all initial states to dense vectors

		ψ0_iter = map(get_data, ψ0)

Adding operator support to time evolution problem #606

Are you sure you want to change the base?

Adding operator support to time evolution problem #606

Uh oh!

Conversation

Gavin-Rockwood commented Dec 1, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Checklist

Description

Related issues or PRs

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Gavin-Rockwood commented Dec 1, 2025 •

edited

Loading