Solving problems with time-dependent Hamiltonians

[ColinVendromin]

Describe the Issue!

Hi, I am trying to solve a problem with a time-dependent Hamiltonian using QuantumToolbox.jl and sesolve(). My Julia version is 1.11.2

Here is the simplest example of my code:

When I run this I get the following error:

I believe the error is caused because H is a tuple but the sesolve() function is expecting it to be a quantum object type. Here are the types of the relevant things in my code:

julia> typeof(H)
Tuple{QuantumObject{SparseMatrixCSC{ComplexF64, Int64}, OperatorQuantumObject}, typeof(C1_coeff)}

julia> typeof(C1_coeff)
typeof(C1_coeff) (singleton type of function C1_coeff, subtype of Function)

julia> typeof(H1)
QuantumObject{SparseMatrixCSC{ComplexF64, Int64}, OperatorQuantumObject}

As you can see my H is a tuple of operator-function pairs and when I look at the documentation for sesolve() online it says the Hamiltonian can be of this tuple type:

H: Hamiltonian of the system \hat{H}. It can be either a QuantumObject, a QuantumObjectEvolution, or a Tuple of operator-function pairs.

So since my H is a tuple of operator-function pairs I shouldn't be getting an error...right?

I am hoping that someone here can help me solve this issue.

Thanks!

[ytdHuang]

@ColinVendromin

Thank you for using QuantumToolbox.jl.

Before we move on, I would suggest you update QuantumToolbox.jl to the latest version.

sesolve indeed supports H to be specified as a Tuple, but it must be in the correct format in order to generate QobjEvo.

As we mentioned in the documentation here:

The following code sets up this problem by using a Tuple which contains many time-dependent pairs (H_j, f_j)

To generate a single element Tuple in julia, you need to add an extra comma ,

That is, instead of generating H with

H = (
    (H1, C1_coeff)
)

You need to do it like this:

H = (
    (H1, C1_coeff),
)

You can use typeof(H) to see the type differences between the above two cases.

Furthermore, I saw another problem in your definition of C1_coeff. Again, as we mentioned in the documentation here:

Although we didn't use the argument p in the definition of coef, we still need to put a dummy input p (in front of t) in the declaration of coef.

That is, your definition of C1_coeff should be:

C1_coeff(p, t) = exp(-t)

[ytdHuang]

@albertomercurio

I think we can add a method for generating QobjEvo with single-element Tuple:

QuantumObjectEvolution(op_func::Tuple{QuantumObject,Function}; type::Union{Nothing,QuantumObjectType} = nothing)
  = QuantumObjectEvolution((op_func,); type = type)

For the type-check of coefficient function, we can use Base.methods while constructing QobjEvo:

# here, specify [Any, Real] will return an array of methods for coef whose types match:
#   - 1st argument is Any
#   - 2nd argument is Real
coef_method = methods(coef, [Any, Real])

length(coef_method.ms) == 0 && throw(ArgumentError("The function `$(coef_method.mt.name)` must accept two arguments: `$(coef_method.mt.name)(p, t)` with t<:Real"))

[albertomercurio]

Yes, thrown an error with a hint message is a good option.

[ColinVendromin]

@ytdHuang

Thank you for your quick response to my question.

Ultimately I realized I was using an old version of QuantumToolbox.jl. After updating to the latest version and fixing my code according to your suggestions I was able to resolve my issue.

Of course if I had read the documentation carefully I would have caught these coding errors, but adding a hint message to make debugging easier would save time for the user and is much appreciated!

Thanks again!

[ytdHuang]

@ColinVendromin

Yes, I have just made PR #339 to address the hint error messages~
This issue should be improved in the next release.