Option to render elementary differentials using summation notation

[ketch]

There is one thing that's in the TOMS paper that BSeries.jl actually still doesn't do, which is to write the elementary differentials for an unspecified RHS function $f$ using the notation that is used e.g. in the books of Hairer et. al. -- see column 5 of the table from the paper:

I would like to add this option. Here's some simple code that generates this as a LaTeX string:

function elementary_differential_string(t)
    indices = ["i","j","k","l","m","n"];
    labels = copy(indices[1:length(t.level_sequence)]);
    edstring = ""
    for i in 1:order(t)
        edstring *= "f^{"
        edstring *= labels[i]
        edstring *= "}_{"
        for j in i+1:order(t)
            if t.level_sequence[j] == t.level_sequence[i]
                break
            elseif t.level_sequence[j]-t.level_sequence[i] == 1
                edstring *= labels[j]
            end
        end
        edstring *= "} "
    end
    edstring = replace(edstring,"_{}"=>"")
    return edstring
end

Before going ahead, I wanted to get your opinion (@ranocha).

• Is direct string generation the best approach? In principle we could generate the products of partial derivatives symbolically first and then render those. This is more elegant but otherwise I don't see an advantage to it.
• How should the user specify that they want the elementary differentials in this form? My plan is to implement a global option like the one in RootedTrees.jl for how to render trees.
• There is a minor issue of needing enough distinct index labels for a given tree. My plan is to just start with "i" and go through the end of the alphabet. In practice it seems unlikely that someone would work with a tree that exhausts this.

[ranocha]

That's a nice feature to have 👍

• Generating the string directly sounds reasonable to me.

• Which use case(s) do we want to support?

  • The elementary differentials can be printed like this when calling latexify(series).
  • There is a function printing the elementary differential associated to a rooted tree like this.

  In the first case, a global option is okay with me. However, I think the second use case would also be nice, e.g.,
  to generate the content of the table you have shown above automatically. We should find a good name for such
  a function and add it to RootedTrees.jl, since it's just about the trees, not about B-series. We could still have a global
  option in BSeries.jl for the first use case.

• That sounds reasonable. You can get a list of these labels as 'i':'z'. We should just check whether the rooted tree is small enough and throw an error otherwise.

• We may also think about doing this for colored rooted trees. Then, the functions need to get additional indices specifying the color.

[ketch]

Thanks!

We should find a good name for such a function and add it to RootedTrees.jl, since it's just about the trees, not about B-series.

I am fine with that, although mapping trees to elementary differentials is something that is only done in the context of B-series. Then again, I guess that everything in RootedTrees.jl is aimed at working with B-series, and not with rooted trees more generally. So it's a question about the scope of RootedTrees.jl, which is up to you. If we implement this functionality in RootedTrees.jl, then the option to use it in latexify(series) could also just be an argument that is passed to latexify.

I agree that it would be nice to extend this to colored trees, and seems straightforward.

I'll prepare a PR that implements "use case 2" in RootedTrees.jl.

[ranocha]

Great, thanks!

Yeah, the scope of RootedTrees.jl may be a bit unclear. In our description, we write

A collection of functionality around rooted trees to generate order conditions for Runge-Kutta methods

That's why we also have the basic types RungeKuttaMethod etc. in there, see https://sciml.github.io/RootedTrees.jl/stable/tutorials/RK_order_conditions/ Thus, I think it's totally fine to add the new functionality there.

[ketch]

I've thought about this a bit more. Currently, there are no functions dealing with elementary differentials in RootedTrees.jl. There are functions dealing with elementary differentials in BSeries.jl. If we add the proposed functionality to RootedTrees.jl, then we'll have

• Functionality for computing concrete elementary differentials in BSeries.jl
• Functionality for computing abstract elementary differentials in RootedTrees.jl

It may be a bit confusing for users (as it is for me).

After looking through both packages, it seems to me that the only reasonable place to put this functionality is in BSeries.jl under src/latexify.jl, since that's where we currently define LatexifyElementaryDifferential. If we think this functionality belongs in RootedTrees.jl, I think we should move that file to RootedTrees.jl.

[ranocha]

You are right. Let's keep this in BSeries.jl.