This update contains the following important features:

- Derivatives: introducing the representation of derivatives in Redberry.
- New transformations: new transformations implemented.
- Reduce tensorial equations: reduce and solve equations with tensors.
- Generate tensor: generate tensor of the most general form.

To update your Redberry simply change version in your Groovy Grapes:

@Grab(group = 'cc.redberry', module = 'groovy', version = '1.1.5')

or download new `.jar`

from the downloads page.

Now you can use derivatives in Redberry. For example, in order to represent $f'''(x^2)$ in Redberry, one just should replace primes with `~(3)`

:

def d = 'f~(3)[x**2]'.t

In the case of multivariate functions, one should specify how many times to differentiate with respect to each slot (argument). For example:

def d = 'f~(2, 3, 0)[a**2, w, q]'.trepresents \(\left. \frac{\partial^5}{\partial x^2 \partial y^3} f\left(x, y, q\right) \right|_{x =a^2 ,\, y =w}\).

In the case of indexed objects the inverted indices of differentiation variables should be appended to the indices of pure tensor field. For example, the following expression

def d = 'F~(2)_{mn ab}^{cd}[f_ab]'.t

represents \(\left. \frac{\delta}{\delta t^{ab}} \frac{\delta}{\delta t_{cd}} F_{mn} \left(t_{ab}\right) \right|_{t_{ab} = f_{ab}}\). This tensor will be automatically set to be symmetric with respect to transposition of differentiation indices `_ab`

↔ `^cd`

.

Lean more about derivatives in Redberry documentation.

`Collect[var1, var2, …, transformations]`

collects together terms involving the same powers of specified vars and applies specified transformation to the expression that forms the coefficient of each term obtained. Consider the examples:

def t = 'A_m*B_n + A_n*C_m'.t println Collect['A_m'.t] >> t

> A_i*(d^i_m*B_n + d^i_n*C_m)

def t = 'D[x][x*f[x, x**2] + f[x, x**2]]'.t def tr = Collect['f~(0,1)[x, y]'.t, 'f~(1,0)[x, y]'.t, Factor] println tr >> t

> f[x,x**2]+(x+1)*f~(1,0)[x,x**2]+2*x*(x+1)*f~(0,1)[x,x**2]

`PowerExpand[var1, var2, …]`

expands all powers of products and powers with respect to specified vars:

def t = '(a*b*c)**d'.t println PowerExpand >> t

> a**d*b**d*c**d

def t = '(a*b*c)**d'.t println PowerExpand['a'] >> t

> a**d*(b*c)**d

The very important update of mappings API. The old mutual mapping class is now private. All objects returned by the comparison via `%`

are now immutual. Consider cases:

setAntiSymmetric 'f_abc' def from = 'f_abc'.t, to = 'f_mnp'.t def mappings = from % to //get the first mapping println mappings.first

> {_a->_m,_b->_n,_c->_p}

//apply the first mapping assert mappings >> from == to //the same as assert mappings.first >> from == to def k = 0 //iterate over all mappings mappings.each{ ++k } // gives the number of possible mappings println k

> 6

//find first negative mapping def neg = mappings.find{ it.sign == true } println neg

> -{_a->_n,_b->_m,_c->_p}

Allows to generate tensor of the most general form from a given samples. For example, the most general tensor with three indices that can be assembled from metric tensor $g_mn$ and vector $k_m$ is $$ c_1 k_a k_b k_c + c_2 g_{ac} k_b + c_3 g_{ab} k_c + c_4 g_{bc} k_a $$ With Redberry one can do the following

def t = GenerateTensor('_abc'.si, ['g_mn', 'k_a']) println t

> C[0]*k_{a}*k_{b}*k_{c}+C[1]*g_{ac}*k_{b}+C[2]*g_{ab}*k_{c}+C[4]*g_{bc}*k_{a}

For further reading about this feature see GenerateTensor.

A new function `Reduce(equations, vars)`

allows to reduce a system of tensorial equations to a system of symbolic equations and to solve it with external solver (Maple or Mathematica).
Solve a system of equations with special symmetries of unknown tensor:
\[
\left\{
\begin{array}{l}
T^{abe}{}_{rba}-x\,T^{bea}{}_{rba} = 8\,d_{r}^{e}\\
T^{pqr}{}_{klm} T^{abc}{}_{pqr} = d^{a}_{m}\,g^{bc}\,g_{lk}
\end{array}
\right.
\]
where $x$ and $T^{abe}{}_{rba}$ are unknown variables and the last one has symmetry [1, 5, 0, 4, 3, 2]. Redberry code:

addSymmetry('T^abc_pqr', 1, 5, 0, 4, 3, 2) def eq1 = 'T^{abe}_{rba}-x*T^{bea}_{rba} = 8*d_{r}^{e}'.t def eq2 = 'T^{pqr}_{klm}*T^{abc}_{pqr} = d^{a}_{m}*g^{bc}*g_{lk}' def options = [Transformations: 'd_n^n = 4'.t, ExternalSolver: [Solver: 'Mathematica', Path: '/usr/local/bin']] def s = Reduce([eq1, eq2], ['T^abc_pqr', 'x'], options) println s

> [[T^{abc}_{pqr} = -d^{a}_{r}*g^{cb}*g_{qp}, x = 12], [T^{abc}_{pqr} = d^{a}_{r}*g^{cb}*g_{qp}, x = -4]]

For further reading about `Reduce(equations, vars)`

in Reduce.