Warning, You have just upgraded from version 9 to version 10 of the Customer Support Updates. In order to have this version active, please close Maple entirely, then open Maple and enter SupportTools:-Version() to confirm the active version.

Warning, You have just reverted to version 4 of the Customer Support Updates. This version contains no actual updates other than the SupportTools package itself. In order to verify this, please close Maple entirely, then open Maple and enter SupportTools:-Version() to verify that the version number is 4.

Warning, You have just upgraded from version 4 to version 10 of the Customer Support Updates. In order to have this version active, please close Maple entirely, then open Maple and enter SupportTools:-Version() to confirm the active version.

with(PDEtools): with(DEtools):

## Hirota Bilinear Method
## Bilinear Derivative / Hirota Operator
BD := proc(FF, DD)
    local f, g, x, m, opt;
    if nargs = 1 then
        return `*`(FF[]);
    fi;
    f, g := FF[];
    x, m := DD[];
    opt := args[3..-1];
    if m = 0 then
        return procname(FF, opt);
    fi;
    procname([diff(f, x), g], [x, m-1], opt) - procname([f, diff(g, x)], [x, m-1], opt);
end:

`print/BD` := proc(FF, DD)
    local f, g, x, m, i;
    f, g := FF[];
    f := cat(f, ` `, g);
    g := product(D[args[i][1]]^args[i][2], i = 2..nargs);
    if g <> 1 then
        f := ``(g)*``(f);
    fi;
    f;
end:

## collect(expr, f); first!
getFnumer := proc(df, f, pow::posint := 1)
    local i, g, fdenom;
    if type(df, `+`) then
        g := [op(df)];
        fdenom := map(denom, g);
        for i to nops(fdenom) while fdenom[i] <> f^pow do
        od;
        if i > nops(fdenom) then
            lprint(fdenom);
            error "no term(s) or numer=0 when denom=%1", op(0, f)^pow;
        fi;
        g := numer(g[i]);
        if not type(expand(g), `+`) then
            lprint(g);
            error "Expected more than 1 term about Hirota D-operator";
        fi;
        return g;
    fi;
    lprint(df);
    error "expected 1st argument be type `+`.";
end:

getvarpow := proc(df::function)
    local i, f, var, dif, pow;
    if op(0, df) <> diff then
        lprint(df);
        error "expected diff function";
    fi;
    f := convert(df, D);
    var := [op(f)];
    dif := [op(op([0, 0], f))];
    pow := [0$nops(var)];
    f := op(op(0, f))(var[]);
    for i to nops(var) do
        dif := selectremove(member, dif, {i});
        pow[i] := nops(dif[1]);
        dif := dif[2];
    od;
    pow := zip((x, y) -> [x, y], var, pow);
    pow := remove(has, pow, {0});
    [[f, f], pow[]];
end:

#convert to Hirota Bilinear Form
HBF := proc(df)
    local i, c, f;
    if type(df, `+`) then
        f := [op(df)];
        return map(procname, f);
    fi;
    if type(df, `*`) then
        f := [op(df)];
        f := selectremove(hasfun, f, diff);
        c := f[2];
        f := f[1];
        if nops(f) <> 1 then
            lprint(df);
            error "need only one diff function factor.";
        fi;
        f := f[];
        c := `*`(c[]);
        f := getvarpow(f);
        f := [c, f];
        return f;
    fi;
    if op(0, df) = diff then
        f := getvarpow(df);
        f := [1, f];
        return f;
    fi;
    lprint(df);
    error "unexpected type.";
end:

printHBF := proc(PL::list)
    local j, DD, f, C, tmp, gcdC, i;
    C := map2(op, 1, PL);
    gcdC := 1;
    if nops(C) > 1 then
        tmp := [seq(cat(_Z, i), i = 1..nops(C))];
        gcdC := tmp *~ C;
        gcdC := `+`(gcdC[]);
        gcdC := factor(gcdC);
        tmp := selectremove(has, gcdC, tmp);
        gcdC := tmp[2];
        if gcdC = 0 then
            gcdC := 1;
        fi;
        gcdC := gcdC*content(tmp[1]);
    fi;
    if gcdC <> 1 then
        C := C /~ gcdC;
    fi;
    DD := map2(op, 2, PL);
    f := op(0, DD[1][1][1]);
    DD := map(z -> product(D[z[i][1]]^z[i][2], i = 2..nops(z)), DD);
    DD := zip(`*`, C, DD);
    DD := `+`(DD[]);
    gcdC * ``(DD) * cat(f, ` `, f);
end:

## print Hirota Bilinear Transform
printHBT := proc(uf, u, f, i, j, PL, alpha := 1)
    local DD, g, C, tmp, pl;
    pl := printHBF(PL);
    if j > 0 then
        print(u = 2*alpha*'diff'(ln(f), x$j));
    else
        print(u = 2*alpha*ln(f));
    fi;
    if i > 0 then
        print('diff'(pl/f^2, x$i) = 0);
    else
       print(pl/f^2 = 0);
    fi;
    NULL;
 end:

guessdifforder := proc(PL::list, x::name)
    local L, minorder, maxorder, tmp;
    L := map2(op, 2, PL);
    L := map(z -> z[2..-1], L);
    tmp := map(z -> map2(op, 2, z), L);
    tmp := map(z -> `+`(z[]), tmp);
    tmp := selectremove(type, tmp, even);
    minorder := 0;
    if nops(tmp[1]) < nops(tmp[2]) then
        minorder := 1;
    fi;
    tmp := map(z -> select(has, z, {x}), L);
    tmp := map(z -> map2(op, 2, z), tmp);
    if has(tmp, {[]}) then
        maxorder := 0;
    else
        tmp := map(op, tmp);
        maxorder := min(tmp[]);
    fi;
    if type(maxorder - minorder, odd) then
        maxorder := maxorder - 1;
    fi;
    [minorder, maxorder];
end:

guessalpha := proc(Res, uf, u, f, i, j, PL, alpha)
    local tmp, res, pl, flag, k;
    flag := 1;
    tmp := [op(Res)];
    tmp := map(numer, tmp);
    tmp := gcd(tmp[1], tmp[-1]);
    if type(tmp, `*`) then
        tmp := remove(has, tmp, f);
    fi;
    if tmp <> 0 and has(tmp, {alpha}) then
        tmp := solve(tmp/alpha^difforder(uf), {alpha});
        if tmp <> NULL and has(tmp, {alpha}) then
            lprint(tmp);
            for k to nops([tmp]) while flag = 1 do
                res := collect(expand(subs(tmp[k], Res)), f, factor);
                if res = 0 then
                    pl := subs(tmp[k], PL);
                    printHBT(uf, u, f, i, j, pl, rhs(tmp[k]));
                    flag := 0;
                fi;
            od;
        fi;
    fi;
    PL;
end:

Bilinear := proc(uf, u, f, x, alpha)
    local su, h, i, j, g1, CB, PL, gdo, DD, Res;
    if hasfun(uf, int) then
        error "Do not support integral function yet. Please substitute int function.";
    fi;
    for j from 0 to 2 do
        Res := 1;
        su := u = 2*alpha*diff(ln(f), [x$j]);
        h := collect(expand(dsubs(su, uf)), f, factor);
        if hasfun(h, ln) then
            next;
        fi;
        g1 := getFnumer(h, f)/2;
        g1 := expand(g1);
        CB := HBF(g1);
        gdo := guessdifforder(CB, x);
        for i from gdo[1] by 2 to gdo[2] do
            if i = 0 then
                PL := CB;
            else
                PL := HBF(int(g1, x$i));
            fi;
            DD := add(PL[i][1]*BD(PL[i][2][]), i = 1..nops(PL));
            Res := collect(expand(diff(DD/f^2, [x$i]) - h), f, factor);
            if Res = 0 then
                printHBT(uf, u, f, i, j, PL, alpha);
                break;
            elif type(alpha, name) and has(DD, alpha) then
                Res := guessalpha(Res, uf, u, f, i, j, PL, alpha);
            fi;
        od;
        if Res = 0 then
            break;
        fi;
    od;
    PL;
end:

with(PDEtools):

# Definieer de Boussinesq vergelijking
boussinesq := diff(u(x,t),t,t) - diff(u(x,t),x,x) - 3*diff(u(x,t),x,x)^2 - diff(u(x,t),x$4);

# Pas de bilineaire transformatie toe
Bilinear(boussinesq, u(x,t), f(x,t), x, alpha);

{alpha = 1}

# Definieer de Kadomtsev–Petviashvili (KP) vergelijking in één regel
kp := diff(diff(u(x,y,t),x$3) + 6*u(x,y,t)*diff(u(x,y,t),x) + diff(u(x,y,t),t), x)
       + 3*delta^2*diff(u(x,y,t), y$2):
Bilinear(kp, u(x,y,t), f(x,y,t), x, alpha);
 

{alpha = 1}

Lagrange Equations and simplification of tensorial expressions in curved spacetimes

LagrangeEquations  is a Physics command introduced in 2023 taking advantage of the functional differentiation  capabilities of the Physics  package . This command can handle tensors  and vectors  of the Physics  package as well as derivatives using vectorial differential operators (see d_  and Nabla ), works by performing functional differentiation (see Fundiff ), and handles 1^st, and higher order derivatives of the coordinates in the Lagrangian automatically. LagrangeEquations  receives an expression representing a Lagrangian and returns a sequence of Lagrange equations with as many equations as coordinates are indicated. The number of parameters can also be many. For example, in electrodynamics, the "coordinate" is a tensor field , there are then four coordinates, one for each of the values of the index , and there are four parameters .

New in Maple 2025, the "coordinates" can now also be the components of the metric tensor in a curved spacetime, in which case the equations returned are Einstein's equations. Also new, instead of a coordinate or set of them, you can pass the keyword EnergyMomentum, in which case the output is the conserved energy-momentum tensor of the physical model represented by the given Lagrangian L.

Examples

The  model in classical field theory and corresponding field equations, as in previous releases

Lagrange's equations

New: The energy-momentum tensor can be computed as the Lagrange equations taking the metric as the coordinate, not equating to 0 the result, but multiplying the variation of the action  by  (in flat spacetimes ). For that purpose, you can use the EnergyMomentum keyword. You can optionally indicate the indices to be used in the output as well as their covariant or contravariant character

To further compute using the above as the definition for , you can use the Define  command

After which the system knows about the symmetry properties and the components of

New: LagrangeEquations takes advantage of the extension of Fundiff  to compute functional derivatives in curved spacetimes introduced for Maple 2025, and so it also handles the case of a scalar field in a curved spacetime. Set for instance an arbitrary metric

For the action to be a true scalar in spacetime, the Lagrangian density now needs to be multiplied by the square root of the determinant of the metric

New: With the extension of the tensorial simplification algorithms for curved spacetimes, the Lagrange equations can be computed arriving directly to the compact form

Comparing with the result (4) for the same Lagrangian in a flat spacetime, we see the only difference is that the dAlembertian  is now expressed in terms of covariant derivatives D_ .

The EnergyMomentum  tensor is computed in the same way as when the spacetime is flat

General Relativity

New: the most significant development in LagrangeEquations is regarding General Relativity. It can now compute Einstein's equations directly from the Lagrangian, not using tabulated cases, and properly handling several (traditional or not) alternative ways of presenting the Lagrangian.

Einstein's equations concern the case of a curved spacetime with metric  as, for instance, the general case of an arbitrary metric set lines above. In the Lagrangian formulation, the coordinates of the problem are the components of the metric , and as in the case of electrodynamics the parameters are the spacetime coordinates . The simplest case is that of Einstein's equation in vacuum, for which the Lagrangian density is expressed in terms of the trace of the Ricci  tensor by

Einstein's equations in vacuum:

where in the above instead of passing  as second argument, we passed  to get the equations using those free indices. The tensorial equation computed is also the definition of the Einstein  tensor

The Lagrangian  used to compute Einstein's equations (15)  contains first and second derivatives of the metric. To see that, rewrite L in terms of Christoffel  symbols

Recalling the definition

in  the two terms containing derivatives of Christoffel symbols contain second order derivatives of . Now, it is always possible to add a total spacetime derivative to  without changing Einstein's equations (assuming the variation of the metric in the corresponding boundary integrals vanishes), and in that way, in this particular case of , obtain a Lagrangian involving only 1st order derivatives. The total derivative, expressed using the inert  command to see it before the differentiation operation is performed, is

Adding this term to , performing the  differentiation operation and simplifying we get

which is a Lagrangian depending only on 1st order derivatives of the metric through Christoffel  symbols. As expected, the equations of motion resulting from this Lagrangian are the same Einstein equations computed in (15)

To illustrate the new Maple 2025 tensorial simplification capabilities note that  is no just  ≡ (17) after discarding its two terms involving derivatives of Christoffel symbols. To verify this, split  into the terms containing or not derivatives of Christoffel

Comparing, the total derivative TD≡ (19) is not just , but

Things like these, , can now be verified directly with the new tensorial simplification capabilities: take the left-hand side minus the right-hand side, evaluate the inert derivative  and simplify to see the equality is true

That said, it is also true that  results in the Lagrangian , and since the equations of movement don't depend on the sign of the Lagrangian, for this Lagrangian  adding the term  happens to be equivalent to just discarding the terms of  involving derivatives of Christoffel symbols.

Also new in Maple 2025, due to the extension of Fundiff  to compute in curved spacetimes, it is now also possible to compute Einstein's equations from first principles by constructing the action,

and equating to zero the functional derivative with respect to the metric. To avoid displaying the resulting large expression, end the input line with ":"

Simplifying this result, we get an expression in terms of Christoffel  symbols and its derivatives

In this result, we see derivatives of Christoffel  symbols, expressed using the D_  command for covariant differentiation. Although, such objects have not the geometrical meaning of a covariant derivative, computationally, they here represent what would be a covariant derivative if the Christoffel symbols were a tensor. For example,

With this computational meaning for the derivatives of Christoffel symbols appearing in (30), rewrite EEC≡(30) in terms of the Ricci  and Riemann  tensors. For that, consider the definition

Rewrite the noncovariant derivatives  in terms of derivatives using the computational representation (31), simplify and isolate one of them

Analogously, derive an expression to rewrite derivatives of Christoffel symbols using the Riemann  tensor

Substitute  these two equations, in sequence, into Einstein's equations EEC≡(30)

Simplify  to arrive at the traditional compact form of Einstein's equations

Linearized Gravity

Generally speaking, linearizing gravity is about discarding in Einstein's field equations the terms that are quadratic in the metric and its derivatives, an approximation valid when the gravitational field is weak (the deviation from a flat Minkowski spacetime is small). Linearizing gravity is used, e.g. in the study of gravitational waves. In the context of Maple's Physics , the formulation of linearized gravity can be done using the general relativity tensors that come predefined in Physics plus a new in Maple 2025 Physics:-Library:-Linearize  command.

In what follows it is shown how to linearize the Ricci  tensor and through it Einstein 's equations. To compare results, see for instance the Wikipedia page for Linearized gravity. Start setting coordinates, you could use Cartesian, spherical, cylindrical, or define your own.

The default metric when Physics is loaded is the Minkowski metric, representing a flat (no curvature) spacetime

The weakly perturbed metric

Suppose you want to define a small perturbation around this metric. For that purpose, define a perturbation tensor , that in the general case depends on the coordinates and is not diagonal, the only requirement is that it is symmetric (to have it diagonal, change symmetric by diagonal; to have it constant, change  by )

In the above it is understood that , so that quadratic or higher powers of it or its derivatives can be approximated to 0 (discarded). Define the components of  accordingly

Define also a tensor  representing the unperturbed Minkowski metric

The weakly perturbed metric is given by

Make this be the definition of the metric

Linearizing the Ricci tensor

The linearized form of the Ricci  tensor is computed by introducing this weakly perturbed metric (48) in the expression of the Ricci tensor as a function of the metric. This can be accomplished in different ways, the simpler being to use the conversion network between tensors , but for illustration purposes, showing steps one at time, a substitution of definitions one into the other one is used

Introducing (48)≡, and also the inert form of the Ricci tensor to facilitate simplification some steps below,

This expression contains several terms quadratic in the small perturbation  and its derivatives. The new in Maple 2025 routine to filter out those terms is Physics:-Library:-Linearize , which requires specifying the symbol representing the small quantities

Important: in this result,  is the flat Minkowski metric, not the perturbed metric . However, in the context of a linearized formulation,  raises and lowers tensor indices the same way as . Hence, to further simplify contracted products of  in (54) , it is practical to reintroduce representing that Minkowski metric and simplify using the internal algorithms for a flat metric

To proceed simplifying, replace in the expression (54) for the Ricci tensor the intermediate Minkowski by

Simplifying, results in the linearized form of the Ricci tensor shown in the Wikipedia page for Linearized gravity.

Linearizing Einstein's equations

Einstein's equations are the components of Einstein's tensor , whose definition in terms of the Ricci tensor is

Compute the trace  directly from the linearized form (57) of the Ricci tensor,

The linearized Einstein equations are constructed reproducing the definition (58) using (57) and (60)

which is the same formula shown in the Wikipedia page for Linearized gravity.

You can now redefine the general  introduced in (44) in different ways (see discussion in the Wikipedia page), or, depending on the case, just substitute your preferred gauge in this formula (61) for the general case. For example, the condition for the Harmonic gauge also known as Lorentz gauge reduces the linearized field equations to their simplest form

Relative Tensors

In General Relativity, the context of a curved spacetime, it is sometimes necessary to work with relative tensors, for which the transformation rule under a transformation of coordinates involves powers of the determinant of the transformation - see Chapter 4 of  "Lovelock, D., and Rund, H. Tensors, Differential Forms and Variational Principles, Dover, 1989." Physics  in Maple 2025 includes a complete, new implementation of relative tensors.

To indicate that a tensor being defined is relative pass its relative weight. For example, set a curved spacetime,

Define now two tensors of one index, one of them being relative

Transformation of Coordinates

Consider a transformation of coordinates, from spherical  to   where

The transformed components of  and  are, respectively,

where, when comparing both results, we see that the transformed components for  are all multiplied by  with  and  is the determinant of the transformation:

Relative weight

The relative weight of a scalar, tensor or tensorial expression can be computed using the Physics:-Library:-GetRelativeWeight  command. For the two tensors  and  used above,

The relative weight of a tensor does not depend on the covariant or contravariant character of its indices

The LeviCivita  tensor is a special case, has its relative weight defined when Physics  is loaded, and because in a curved spacetime it is not a tensor its relative weight depends on the covariant or contravariant character of its indices

The relative weight w of a product is equal to the sum of relative weights of each factor

The relative weight w of a power is equal to the relative weight of the base multiplied by the power

The relative weight w of a sum is equal to the relative weight of one of its terms and exists if all the terms have the same w.

The relative weight of any determinant is always equal to 2

Relative Term in covariant derivatives

When computing the covariant derivative of a relative scalar, tensor or tensorial expression that has non-zero relative weight w, a relative term is added, that can be computed using the Physics:-Library:-GetRelativeWeight  command.

The corresponding covariant derivatives

where in the above we see the additional (relative) term

New Physics:-Library commands

ConvertToF , Linearize , GetRelativeTerm , GetRelativeWeight.

Examples

For example, rewrite the Christoffel  symbols in terms of the metric g_ ; this works as in previous releases

Define a  representing the 4D electromagnetic potential as a function of the coordinates  and  representing the electromagnetic field tensors

Rewrite the following expression in terms of the electromagnetic potential

In the example above, the output is similar to this other one

The rewriting, however, works also with tensorial expressions

See Also

Index of New Maple 2025 Features , Physics , Computer Algebra for Theoretical Physics, The Physics project, The Physics Updates