BCK Hopf Algebra

The kauri.bck sub-package implements the Butcher-Connes-Kreimer (BCK) [CK99] Hopf algebra \((H, \Delta_{BCK}, \mu, \varepsilon_{BCK}, \emptyset, S_{BCK})\), defined as follows.

  • \(H\) is the set of all non-planar rooted trees.

  • The unit \(\emptyset\) is the empty forest.

  • The counit map is defined by \(\varepsilon_{BCK}(\emptyset) = 1\), \(\varepsilon_{BCK}(t) = 0\) for all \(\emptyset \neq t \in H\).

  • Multiplication \(\mu : H \otimes H \to H\) is defined as the commutative juxtaposition of two forests.

  • Comultiplication \(\Delta : H \to H \otimes H\) is defined as

    \[\Delta_{BCK}(t) = t \otimes \emptyset + \emptyset \otimes t + \sum_{s \subset t} [t \setminus s] \otimes s\]

    where the sum runs over all proper rooted subtrees \(s\) of \(t\), and \([t \setminus s]\) is the forest of all trees remaining after erasing \(s\) from \(t\).

  • The antipode \(S_{BCK}\) is defined by \(S_{BCK}(\bullet) = -\bullet\) and

    \[S_{BCK}(t) = -t - \sum_{s \subset t} S_{BCK}([t \setminus s]) \, s.\]

Example: BCK coproduct

import kauri as kr
import kauri.bck as bck
t = kr.Tree([[],[[]]])
kr.display(bck.coproduct(t))
⊗ ∅ + ⊗ + ∅ ⊗ + ⊗ + ⊗ + ⊗ + ⊗

Example: BCK antipode

import kauri as kr
import kauri.bck as bck
t = kr.Tree([[],[[]]])
kr.display(bck.antipode(t))
− + − 3 + + +
counit = <kauri.maps.Map object>

The counit \(\varepsilon_{BCK}\) of the BCK Hopf algebra.

Type:

Map

Example usage:

print(bck.counit(Tree(None)))  # Returns 1
print(bck.counit(Tree([])))  # Returns 0

1
0
antipode = <kauri.maps.Map object>

The antipode \(S_{BCK}\) of the BCK Hopf algebra.

Type:

Map

Example usage:

t = Tree([[[]],[]])
kr.display(bck.antipode(t))
− + − 3 + + +
coproduct(t: Tree) → TensorProductSum[source]

The coproduct \(\Delta_{BCK}\) of the BCK Hopf algebra.

Parameters:

t (Tree) – tree

Return type:

TensorProductSum

Example usage:

t = Tree([[[]],[]])
kr.display(bck.coproduct(t))
⊗ ∅ + ⊗ + ∅ ⊗ + ⊗ + ⊗ + ⊗ + ⊗
map_product(f: Map, g: Map) → Map[source]

Returns the product of maps in the BCK Hopf algebra, defined by

\[(f \cdot g)(t) := \mu \circ (f \otimes g) \circ \Delta_{BCK} (t)\]

Note

bck.map_product(f,g) is equivalent to the Map operator f * g

Parameters:
Return type:

Map

Example usage:

f = bck.map_product(ident, bck.antipode)
print(f(Tree([[]])))

0
map_power(f: Map, exponent: int) → Map[source]

Returns the power of a map in the BCK Hopf algebra, where the product of functions is defined by

\[(f \cdot g)(t) := \mu \circ (f \otimes g) \circ \Delta_{BCK} (t)\]

and negative powers are defined as \(f^{-n} = (f \circ S_{BCK})^n\), where \(S_{BCK}\) is the BCK antipode.

Note

bck.map_power(f, n) is equivalent to the Map operator f ** n

Parameters:

  • f (Map) – f

  • exponent (int) – exponent

Example usage:

S = bck.map_power(ident, -1)  # antipode
print(S(Tree([[]])))

-1 * [[]] + 1 * [] []