added butcher_representation (#8)

Author: ranocha

README.md

@@ -31,6 +31,15 @@ this tree can be written as `[[τ²] τ]` or `(τ ∘ τ) ∘ (τ ∘ τ)`, wher
 `∘` is the non-asociative Butcher product of `RootedTree`s, which is also
 implemented.
 
+To get the representation of a `RootedTree` introduced by Butcher, use `butcher_representation`:
+```julia
+julia> t = rootedtree([1, 2, 3, 4, 3, 3, 2, 2, 2, 2, 2])
+RootedTree{Int64}: [1, 2, 3, 4, 3, 3, 2, 2, 2, 2, 2]
+
+julia> butcher_representation(t)
+"[[[τ]τ²]τ⁵]"
+```
+
 ### Iteration over `RootedTree`s
 
 A `RootedTreeIterator(order::Integer)` can be used to iterate efficiently
@@ -41,8 +50,7 @@ over all `RootedTree`s of a given `order`.
 The usual functions on `RootedTree`s are implemented, cf.
 [Butcher (Numerical Methods for ODEs, 2016)](https://doi.org/10.1002/9781119121534).
 - `order(t::RootedTree)`: The order of a `RootedTree`, i.e. the length of it's level sequence.
-- `σ(t::RootedTree)`: The order of a `symmetry`, i.e. the order of the group of automorphisms
-on a particular labelling (of the vertices) of `t`.
+- `σ(t::RootedTree)`:The symmetry `σ` of a rooted tree, i.e. the order of the group of automorphisms on a particular labelling (of the vertices) of `t`.
 - `γ(t::RootedTree)`: The density `γ(t)` of a rooted tree, i.e. the product over all vertices of `t` of the order of the subtree rooted at that vertex.
 - `α(t::RootedTree)`: The number of monotonic labellings of `t` not equivalent under the symmetry group.
 - `β(t::RootedTree)`: The total number of labellings of `t` not equivalent under the symmetry group.

src/RootedTrees.jl

@@ -3,11 +3,13 @@ module RootedTrees
 
 using LinearAlgebra
 
-import Base: show, isless, ==, iterate, copy     
+import Base: show, isless, ==, iterate, copy
 
 
 export rootedtree, RootedTreeIterator
 
+export butcher_representation
+
 export α, β, γ, σ, order, residual_order_condition, elementary_weight, derivative_weight
 
 export count_trees
@@ -432,6 +434,8 @@ function residual_order_condition(t::RootedTree, A, b, c)
 end
 
 
+# additional representation and construction methods
+
 """
     t1 ∘ t2
 
@@ -450,4 +454,50 @@ function Base.:∘(t1::RootedTree, t2::RootedTree)
 end
 
 
+"""
+  butcher_represetation(t::RootedTree)
+
+Returns the representation of `t::RootedTree` as introduced by Butcher.
+
+Reference: Section 301 of
+  Butcher, John Charles.
+  Numerical methods for ordinary differential equations.
+  John Wiley & Sons, 2008.
+"""
+function butcher_representation(t::RootedTree)
+  if order(t) == 1
+    return "τ"
+  end
+
+  subtr = Subtrees(t)
+  result = ""
+  for i in eachindex(subtr)
+    result = result * butcher_representation(subtr[i])
+  end
+  result = "[" * result * "]"
+
+  # normalise the result by grouping repeated occurences of τ
+  # TODO: Decide whether powers should also be used for subtrees,
+  #       e.g. "[[τ]²]" instead of "[[τ][τ]]"
+  #       for rootedtree([1, 2, 3, 2, 3]).
+  #       Currently, powers are only used for τ.
+  for n in order(t):-1:2
+    n_str = string(n)
+    n_str = replace(n_str, "1" => "¹")
+    n_str = replace(n_str, "2" => "²")
+    n_str = replace(n_str, "3" => "³")
+    n_str = replace(n_str, "4" => "⁴")
+    n_str = replace(n_str, "5" => "⁵")
+    n_str = replace(n_str, "6" => "⁶")
+    n_str = replace(n_str, "7" => "⁷")
+    n_str = replace(n_str, "8" => "⁸")
+    n_str = replace(n_str, "9" => "⁹")
+    n_str = replace(n_str, "0" => "⁰")
+    result = replace(result, "τ"^n => "τ"*n_str)
+  end
+
+  return result
+end
+
+
 end # module

test/runtests.jl

@@ -34,6 +34,7 @@ t1 = rootedtree([1])
 @test γ(t1) == 1
 @test α(t1) == 1
 @test β(t1) == α(t1)*γ(t1)
+@test butcher_representation(t1) == "τ"
 
 @inferred order(t1)
 @inferred σ(t1)
@@ -49,6 +50,7 @@ t2 = rootedtree([1, 2])
 @test α(t2) == 1
 @test β(t2) == α(t2)*γ(t2)
 @test t2 == t1 ∘ t1
+@test butcher_representation(t2) == "[τ]"
 
 t3 = rootedtree([1, 2, 2])
 @test order(t3) == 3
@@ -57,6 +59,7 @@ t3 = rootedtree([1, 2, 2])
 @test α(t3) == 1
 @test β(t3) == α(t3)*γ(t3)
 @test t3 == t2 ∘ t1
+@test butcher_representation(t3) == "[τ²]"
 
 t4 = rootedtree([1, 2, 3])
 @test order(t4) == 3
@@ -65,6 +68,7 @@ t4 = rootedtree([1, 2, 3])
 @test α(t4) == 1
 @test β(t4) == α(t4)*γ(t4)
 @test t4 == t1 ∘ t2
+@test butcher_representation(t4) == "[[τ]]"
 
 t5 = rootedtree([1, 2, 2, 2])
 @test order(t5) == 4
@@ -73,6 +77,7 @@ t5 = rootedtree([1, 2, 2, 2])
 @test α(t5) == 1
 @test β(t5) == α(t5)*γ(t5)
 @test t5 == t3 ∘ t1
+@test butcher_representation(t5) == "[τ³]"
 
 t6 = rootedtree([1, 2, 2, 3])
 @inferred RootedTrees.subtrees(t6)
@@ -82,20 +87,23 @@ t6 = rootedtree([1, 2, 2, 3])
 @test α(t6) == 3
 @test β(t6) == α(t6)*γ(t6)
 @test t6 == t2 ∘ t2 == t4 ∘ t1
+@test butcher_representation(t6) == "[[τ]τ]"
 
 t7 = rootedtree([1, 2, 3, 3])
 @test order(t7) == 4
 @test σ(t7) == 2
 @test γ(t7) == 12
 @test β(t7) == α(t7)*γ(t7)
 @test t7 == t1 ∘ t3
+@test butcher_representation(t7) == "[[τ²]]"
 
 t8 = rootedtree([1, 2, 3, 4])
 @test order(t8) == 4
 @test σ(t8) == 1
 @test γ(t8) == 24
 @test α(t8) == 1
 @test t8 == t1 ∘ t4
+@test butcher_representation(t8) == "[[[τ]]]"
 
 t9 = rootedtree([1, 2, 2, 2, 2])
 @test order(t9) == 5
@@ -104,6 +112,7 @@ t9 = rootedtree([1, 2, 2, 2, 2])
 @test α(t9) == 1
 @test β(t9) == α(t9)*γ(t9)
 @test t9 == t5 ∘ t1
+@test butcher_representation(t9) == "[τ⁴]"
 
 t10 = rootedtree([1, 2, 2, 2, 3])
 @test order(t10) == 5
@@ -112,13 +121,15 @@ t10 = rootedtree([1, 2, 2, 2, 3])
 @test α(t10) == 6
 @test β(t10) == α(t10)*γ(t10)
 @test t10 == t3 ∘ t2 == t6 ∘ t1
+@test butcher_representation(t10) == "[[τ]τ²]"
 
 t11 = rootedtree([1, 2, 2, 3, 3])
 @test order(t11) == 5
 @test σ(t11) == 2
 @test γ(t11) == 15
 @test α(t11) == 4
 @test t11 == t2 ∘ t3 == t7 ∘ t1
+@test butcher_representation(t11) == "[[τ²]τ]"
 
 t12 = rootedtree([1, 2, 2, 3, 4])
 @test order(t12) == 5
@@ -127,6 +138,7 @@ t12 = rootedtree([1, 2, 2, 3, 4])
 @test α(t12) == 4
 @test β(t12) == α(t12)*γ(t12)
 @test t12 == t2 ∘ t4 == t8 ∘ t1
+@test butcher_representation(t12) == "[[[τ]]τ]"
 
 t13 = rootedtree([1, 2, 3, 2, 3])
 @test order(t13) == 5
@@ -135,6 +147,7 @@ t13 = rootedtree([1, 2, 3, 2, 3])
 @test α(t13) == 3
 @test β(t13) == α(t13)*γ(t13)
 @test t13 == t4 ∘ t2
+@test butcher_representation(t13) == "[[τ][τ]]"
 
 t14 = rootedtree([1, 2, 3, 3, 3])
 @test order(t14) == 5
@@ -143,6 +156,7 @@ t14 = rootedtree([1, 2, 3, 3, 3])
 @test α(t14) == 1
 @test β(t14) == α(t14)*γ(t14)
 @test t14 == t1 ∘ t5
+@test butcher_representation(t14) == "[[τ³]]"
 
 t15 = rootedtree([1, 2, 3, 3, 4])
 @test order(t15) == 5
@@ -151,6 +165,7 @@ t15 = rootedtree([1, 2, 3, 3, 4])
 @test α(t15) == 3
 @test β(t15) == α(t15)*γ(t15)
 @test t15 == t1 ∘ t6
+@test butcher_representation(t15) == "[[[τ]τ]]"
 
 t16 = rootedtree([1, 2, 3, 4, 4])
 @test order(t16) == 5
@@ -159,6 +174,7 @@ t16 = rootedtree([1, 2, 3, 4, 4])
 @test α(t16) == 1
 @test β(t16) == α(t16)*γ(t16)
 @test t16 == t1 ∘ t7
+@test butcher_representation(t16) == "[[[τ²]]]"
 
 t17 = rootedtree([1, 2, 3, 4, 5])
 @test order(t17) == 5
@@ -167,6 +183,7 @@ t17 = rootedtree([1, 2, 3, 4, 5])
 @test α(t17) == 1
 @test β(t17) == α(t17)*γ(t17)
 @test t17 == t1 ∘ t8
+@test butcher_representation(t17) == "[[[[τ]]]]"
 
 
 # see butcher2008numerical, Table 302(I)