Most of the internal Routines of PDEtools, used by the external commands listed in PDEtools, are also available for use as external commands via PDEtools:-Library:-Routine. These Routines can be useful to program your own extensions of PDEtools, or differential equation programs in general, without having to rewrite everything from the scratch. In this sense, these Library Routines are useful mainly for programmers, although some of them, like for instance CloseSystem or ContactCondition can also be seen as differential equation commands.

All the routines of the PDEtools:-Library also work with anticommutative variables set using the Physics package.

Instead of providing a help page for each of these Library readable programming tools, only brief information on their use is provided using the Describe command, as in Describe(PDEtools:-Library:-Routine) or just Describe(Routine) if you have first entered with(PDEtools:-Library). Below there is also an alphabetical listing of these Library Routines pointing to sections within this single page, containing the same information provided by Describe(Routine).

An alphabetical listing of these Routines is as follows

AbstractedFunction(object,chi,j,YX,(Y := YX),{(inallcases::truefalse := false)})

Parameters

* object - any algebraic object
* chi    - a name to be used in the returned function chi[j](...)
* j      - an index for 'chi', typically a number
* YX     - a list of relevant names
* Y      - optional, a list of relevant symbols that appear indexed within object
* inallcases - optional, default to false, to proceed also when object is already an unknown function

Description: AbstractedFunction abstracts an algebraic object into a function chi[j](...), of the names found in object that are members of YX or that are indexed symbols found in Y.

Example

> PDEtools:-Library:-AbstractedFunction(exp(x), phi, 1, [y, x]);
                              phi[1](x)

AssignFromINFO(INFO,Vars)

Parameters

* INFO - a table
* Vars - a list of names, to be used as indexes of INFO

Description: AssignFromINFO assigns to A the value of INFO["A"] for every name A in a list 'Vars'.

Example

> INFO["a"], INFO["b"] := 5, e:
> PDEtools:-Library:-AssignFromINFO('INFO', '[a, b]'):
> a;
                           5
> b;
                           e

AssignToINFO(INFO,Vars::uneval)

Parameters

* INFO - a table
* Vars - a list of names, to be used as indexes of INFO, and that may have some value assigned

Description: AssignToINFO assigns INFO["A"] := eval(A) for every name A in a list 'Vars'.

Example

> a, b := 5, e:
> PDEtools:-Library:-AssignToINFO('INFO', [a, b]):
> INFO["a"];
                           5

BuildFunctionFieldHint(sys::set(algebraic),F::list,(Y := map2(op,0,F)),(X := GetIndepVars(F)),(v::{name, identical("not given")} := "not given"),` $`,{(mathfunctiondegree := "not given"), (orderofderivatives := "not given"), (v_indexshift::nonnegint := 0)})

Parameters

* sys  - a set of algebraic differential equations, mainly involving mathematical functions
* F    - a list with the dependent variables of sys
* Y    - the names of the functions in F
* X    - the independent variables with the ordering found in F
* v    - optional, any name to be used as in v[n](..) to represent coefficients of powers of mathematical functions
* mathfunctiondegree - optional, a nonegative integer indicating the degree with which the mathematical functions will enter the functionalfield hint returned
* orderofderivatives - optional, a nonegative integer indicating the order for derivatives of mathematical functions entering the functionalfield hint returned
* v_indexshift - optional, default value is 0, used in the v[n+v_indexshift](..) entering the functionfield hint returned

Description: BuildFunctionFieldHint returns a sequence of two elements:
   1) a set with equations, with the dependent variables of F in the lhs and a related hint in the rhs, polynomial in the mathematical functions found in sys and their derivatives, and with unknown function coefficients v[..](...);
   2) a list with all the functions v[..](...) entering that set of hints.

Example

> PDEtools:-Library:-BuildFunctionFieldHint({-((diff(F(x, y), y))*x*y-(diff(F(x, y), x))*x*y-exp(x)*x*y+x+exp(x)*y^2*x+y)/(x*y), -((diff(G(x, y), y))*x*y-(diff(G(x, y), x))*x*y-exp(x)*x*y-x+exp(x)*y^2*x+y)/(x*y)}, [F(x, y), G(x, y)], [F, G], [x, y], v, mathfunctiondegree = 1, orderofderivatives = 1);

  {F(x, y) = v1[1](x, y) + v1[2](x, y) ln(y) + v1[3](x, y) ln(x)

         + v1[4](x, y) exp(x) + v1[5](x, y) Ei(x), G(x, y) =

        v1[6](x, y) + v1[7](x, y) ln(y) + v1[8](x, y) ln(x)

         + v1[9](x, y) exp(x) + v1[10](x, y) Ei(x)}, [

        v1[1] = v1[1](x, y), v1[2] = v1[2](x, y), v1[3] = v1[3](x, y),

        v1[4] = v1[4](x, y), v1[5] = v1[5](x, y), v1[6] = v1[6](x, y),

        v1[7] = v1[7](x, y), v1[8] = v1[8](x, y), v1[9] = v1[9](x, y),

        v1[10] = v1[10](x, y)], [v1[1](x, y), v1[2](x, y),

        v1[3](x, y), v1[4](x, y), v1[5](x, y), v1[6](x, y),

        v1[7](x, y), v1[8](x, y), v1[9](x, y), v1[10](x, y)]

BuildPolynomialHint(PDESYS,F::list,(v::{list(name), identical("not given")} := "not given"),` $`,{(degree := "not given"), (dependency::{list(name), identical("not given")} := "not given"), (donotusethesesymbols := {}), (ivars::{list(name), set(name)} := {}), (undeterminedcoefficients::{string, assignable, identical("not given")} := "not given"), (v_indexshift::nonnegint := 0)})

Parameters

* PDESYS    - a set of algebraic differential equations
* F         - a list with the dependent variables of PDESYS
* v         - optional, any name to be used as in v[n](..) to represent coefficients of powers of the independent variables found in F
* donotusethesesymbols - optional, a set of global names that should not be used when constructing the hint to be returned
* dependency - optional, default to the independent variables found in F, can be a list of names indicating the dependency of the hint
* ivars - optional, to indicate additional independent variables, possibly not found in F, so that the hint returned should also be polynomial in ivars
* undeterminedcoefficients - optional, of type assignable, if given it will be assigned a set with the undetermined coefficients
* v_indexshift - optional, default value is 0, used in the v[n+v_indexshift](..) entering the hint returned

Description: BuildFunctionFieldHint returns a set of equations with the dependent variables of F in the left-hand-sides and a related hint for them, polynomial in the independent variables found in F, in the right-hand-sides, with unknown constant coefficients v[n] (n::integer).

Example

> PDEtools:-Library:-BuildPolynomialHint((diff(F(x, y), x))*(diff(G(x, y), x))+(diff(F(x, y), y))*(diff(G(x, y), y))+G(x, y)*(diff(diff(F(x, y), x), x)+diff(diff(F(x, y), y), y)) = -1, [F(x, y), G(x, y)], undeterminedcoefficients = 'S');

  {F(x, y) =
                                           2                      2
        v1[1] + v1[2] y + v1[3] x + v1[4] y  + v1[5] x y + v1[6] x ,

        G(x, y) = v2[1] + v2[2] y + v2[3] x}

> S;

   {v1[1], v1[2], v1[3], v1[4], v1[5], v1[6], v2[1], v2[2], v2[3]}

ChooseSimilarityVariables(sv,TY,TX,nY,itr,(recursing := false))

Parameters

* sv    - a list of candidates for dependent similarity variables
* TY    - the similarity transformation for the dependent variables (old to new)
* TX    - the similarity transformation for the independent variables (old to new)
* nY    - the number of dependent variables
* itr   - the complete inverse transformation (new to old)
* recursing  - default is false, to allow recursion

Description: ChooseSimilarityVariables returns a set with an optimal choice for the dependent similarity variables.

Example

> PDEtools:-Library:-ChooseSimilarityVariables([r, s], [u = s+Intat(_F1(_a)+_F3(_a-r), _a = _psi)+_F2(r)*_psi], [t = _psi, x = r], 1, {_psi = t, r = x, s = -(Int(_F1(t)+_F3(t-x), t))-_F2(x)*t+u});

        {s}

CloseSystem(SYS,F::list,(X := GetIndepVars(F)),{(DepVars_ranking::{list, identical("not given")} := "not given"), (IndepVars_ranking::{list, identical("not given")} := "not given"), (avoidfirstround::truefalse := false), (usephysics::truefalse := false)})

Parameters

* SYS    - any differential equation, or a set or list of them
* F      - a list of dependent variables
* avoidfirstround - optional, to indicate that SYS is of the form 'dF = ...' and written according to some ranking for DepVars and IndepVars
* DepVars_ranking - optional, required when passing avoidfirstround, this is the ranking for the dependent variables 'F'
* IndepVars_ranking - optional, required when passing avoidfirstround, this is the ranking for the independent variables of 'F'

Description: CloseSystem computes a system equivalent to SYS in that it has the same solutions as SYS, and that includes all the integrability conditions explicited.

Example

> PDEtools:-Library:-CloseSystem([diff(u(x, y), x)-(diff(u(x, y), y)) = 0, diff(u(x, y), y, y) = 0], [u(x, y)]);

                                      2            2          
        /d         \   /d         \  d            d           
       {|-- u(x, y)| - |-- u(x, y)|, --- u(x, y), --- u(x, y)}
        \dx        /   \dy        /    2            2         
                                     dx           dy          

CompatibleOptions(command,{(exceptions::set(name) := {})})

Parameters

* command    - any Maple command name
* _rest      - a sequence of Maple options, typically of the form keyword = value, to be analyzed for compatibility
* exceptions - optional, to indicate a set of options to be excluded from the compatibility analysis

Description: CompatibleOptions returns the options that are compatible with a given 'command', among an arbitrary sequence of options (the _rest sequence).

Example

> PDEtools:-Library:-CompatibleOptions(PDEtools:-DeterminingPDE, order=2, explicit, jetnotation = jetvariables, simplifier = normal, tryrisingtheorder, arbitraryfunctionname, exceptions = {simplifier});

        order = 2, jetnotation = jetvariables

ConstructTrivialSymmetry(Fn::list(name),Y,X,{(expanded::truefalse := true), (prolongation::nonnegint := 0), (differentialorder::nonnegint := prolongation), ([notation, jetnotation]::{identical(true,jetODE,jetvariables,jetvariableswithbrackets,jetnumbers)} := 'jetnumbers')})

Parameters

* Fn    - a list with N names of arbitrary functions, where N is the number of independent variables in the given 'X'
* Y    - a list with names of dependent variables
* X    - a list with names of independent variables
* prolongation - optional, default to 0, can be any nonnegative integer indicating the prolongation order of the trivial symmetry to be returned
* jetnotation - optional, default is 'jetnumbers', can be any of the jet notations understood in PDEtools (see ?PDEtools:-ToJet)
* differentialorder - optional, the maximal differential order of derivatives entering (in jet notation) the functionality of the arbitrary functions of the trivial symmetry
* expanded - optional, can be true (default) or false, to return expanded the prolongations of the trivial symmetry (see option expanded in ?InfinitesimalGenerator)

Description: ConstructTrivialSymmetry returns a list with the infinitesimals of a trivial symmetry, that is, one that is always admitted by any PDE system but that cannot be used to reduce the number of its independent variables or dependency in general.

Example

> PDEtools:-Library:-ConstructTrivialSymmetry([_F1, _F2], [u], [x, t], prolongation = 0, jetnotation = jetvariables, differentialorder = 0);

 [_F1(x, t, u), _F2(x, t, u), _F1(x, t, u) u[x] + _F2(x, t, u) u[t]]

ContactCondition(xi,eta,F,(Y := map2(op,0,F)),(X := GetIndepVars(F)),(nY := nops(Y)),{(jetnotation::identical(true,false,jetnumbers,jetvariables,jetvariableswithbrackets,jetODE) := 'jetvariableswithbrackets'), (normalizejetnotation::truefalse := true), (usephysics::truefalse := false)})

Parameters

* xi   - a list with the infinitesimals [xi[1], xi[x2], ...] in jetnumbers jetnotation, ordered according to the order of GetIndepVars(F)
* eta  - a list with the infinitesimals [eta[1], eta[x2], ...] in jetnumbers jetnotation, ordered according to the order of F
* F    - a list of unknown functions of the problem, the ones defining the jet space
* normalizejetnotation - optional, can be true (default) or false, to rewrite the input in jetvariableswithbrackets notation (necessary within this routine) before proceeding

Description: ContactCondition returns a sequence of equations representing the conditions to be satisfied by [xi[1], xi[2], ..., eta[1], eta[2], ...] in order to be a contact symmetry.

Example

> Xi, Eta := [_xi[x], _xi[t]](x, t, u[], u[x], u[t]), [_eta[u]](x, t, u[], u[x], u[t]);

# default output is in jetvariables notation
> PDEtools:-Library:-ContactCondition(Xi, Eta, [u(x,t)]);

  /  d                                 \
  |----- _eta[u](x, t, u[], u[x], u[t])|
  \du[x]                               /

           /  d                                \
         - |----- _xi[x](x, t, u[], u[x], u[t])| u[x]
           \du[x]                              /

           /  d                                \
         - |----- _xi[t](x, t, u[], u[x], u[t])| u[t],
           \du[x]                              /

        /  d                                 \
        |----- _eta[u](x, t, u[], u[x], u[t])|
        \du[t]                               /

           /  d                                \
         - |----- _xi[x](x, t, u[], u[x], u[t])| u[x]
           \du[t]                              /

           /  d                                \
         - |----- _xi[t](x, t, u[], u[x], u[t])| u[t]
           \du[t]                              /

# request output in jetnumbers
> PDEtools:-Library:-ContactCondition(Xi, Eta, [u(x,t)], jetnotation = jetnumbers);

  /  d                                 \
  |----- _eta[u](x, t, u[], u[1], u[2])|
  \du[1]                               /

           /  d                                \
         - |----- _xi[x](x, t, u[], u[1], u[2])| u[1]
           \du[1]                              /

           /  d                                \
         - |----- _xi[t](x, t, u[], u[1], u[2])| u[2],
           \du[1]                              /

        /  d                                 \
        |----- _eta[u](x, t, u[], u[1], u[2])|
        \du[2]                               /

           /  d                                \
         - |----- _xi[x](x, t, u[], u[1], u[2])| u[1]
           \du[2]                              /

           /  d                                \
         - |----- _xi[t](x, t, u[], u[1], u[2])| u[2]
           \du[2]                              /

# the input can be in jetnumbers notation
> Xi, Eta := PDEtools:-ToJet(Xi, u(x,t), jetnotation = jetnumbers), PDEtools:-ToJet(Eta, u(x,t), jetnotation = jetnumbers);

  Xi, Eta := [_xi[x](x, t, u[], u[1], u[2]), _xi[t](x, t, u[], u[1], u[2])]

        , [_eta[u](x, t, u[], u[1], u[2])]

# jetnotation for the output is still jetvariableswithbrackets unless requested otherwise passing jetnotation = ...
> PDEtools:-Library:-ContactCondition(Xi, Eta, [u(x,t)]);

  /  d                                 \
  |----- _eta[u](x, t, u[], u[x], u[t])|
  \du[x]                               /

           /  d                                \
         - |----- _xi[x](x, t, u[], u[x], u[t])| u[x]
           \du[x]                              /

           /  d                                \
         - |----- _xi[t](x, t, u[], u[x], u[t])| u[t],
           \du[x]                              /

        /  d                                 \
        |----- _eta[u](x, t, u[], u[x], u[t])|
        \du[t]                               /

           /  d                                \
         - |----- _xi[x](x, t, u[], u[x], u[t])| u[x]
           \du[t]                              /

           /  d                                \
         - |----- _xi[t](x, t, u[], u[x], u[t])| u[t]
           \du[t]                              /

Degree(EE,X,{(minmax::identical(min,max,both) := 'max'), (usephysics::Or(truefalse,identical("not given")) := "not given")})

Parameters

* EE  - any Maple algebraic object, or equation or a set or list of them
* X   - a name or a set of them
* minmax - optional, can be 'min', 'max' (default), or 'both', to request the minimal (equivalent to the lower degree), maximal degree with respect to X, or both (returns a sequence of two numbers)

Description: Degree computes the maximum degree of a set of equations EE with respect to variable(s) X. NOTE: if all the equations are equal to 0, the value returned is 0, not -infinity. When the degree cannot be computed, Degree returns FAIL.

Example

> PDEtools:-Library:-Degree({a, b^2, c^3}, {a, b, c});

                            3

DifforderJet(ee_J,F,(Y := map2(op,0,`if`(F::'list',F,`if`(F::'set',[op(F)],[F])))),{(derivatives_J::{set(indexed), identical("not given")} := indets(ee_J,'specindex'('{name, posint}',Y))), (ivars::{name, set(name), identical("with respect to each of them","not given")} := select(type,{op(map(op,F))},'name')), (minmax::identical(min,max) := 'max'), (totaldifforder::truefalse := false)})

Parameters

* ee_J  - algebraic expression or an equation or a set or list of them, written in jet notation
* F    - a list of unknown functions of the problem, the ones defining the jet space
* ivars - optional, default to all the names entering functionality of functions in F, ivars can be a name or a set of them, or it can be the string "with respect to each of them", to request the differential order with respect to these 'ivars' variables, or alternatively returning the values 'with respect to each of them'
* derivatives_J - optional, default to all the derivatives of F in jetnumbers jetnotation, can be a (sub)set of them, to request the differential order only of that (sub)set
* minmax - optional, default to 'max', can also be 'min', to respectively request the maximum or minimum differential order
* totaldifforder - optional, to return only one number representing the total differential order of derivatives of F found in ee_j

Description: DifforderJet computes the (minimal or maximal) differential order of ee_J (given in jetnumbers jetnotation) with respect to each of the dependent variables (F).

Example

> PDEtools:-Library:-DifforderJet(u[1]*v[1,2] - u[2,2,2]*v[1,1,1], [u, v](x,t));

                         [u = 3, v = 3]
> PDEtools:-Library:-DifforderJet(u[1]*v[1,2] - u[2,2,2]*v[1,1,1], [u, v](x,t), minmax = min);

                         [u = 1, v = 2]
> PDEtools:-Library:-DifforderJet(u[1]*v[1,2] - u[2,2,2]*v[1,1,1], [u, v](x,t), totaldifforder);

                                3

Forget()

Parameters

* This command takes no parameters.

Description: Forget clears all the remember tables of the PDEtools commands and subroutines.

Example

> PDEtools:-Library:-Forget();

FromJetNumbersToJetVariables(expr,F::list,{(withoutbrackets::truefalse := true)})

Parameters

* expr    - any mathematical expression
* F    - a list with the dependent variables
* withoutbrackets - optional, it can be true (default) or false, to return the dependent variables in jet notation without or with brackets

Description: FromJetNumbersToJetVariables returns the given expression after replacing jet numbers 1, 2, ... by the corresponding jet variables x, y, ... according to the order implicit in F.

Example

> PDEtools:-Library:-FromJetNumbersToJetVariables(u[1]*u[]+v[2,2]*u[1] = 0, [u,v](x,t));

                      u[x] u + v[t, t] u[x] = 0

FromJetVariablesToJetNumbers(expr,F::list,(X := map(op,F)))

Parameters

* expr    - any mathematical expression
* F    - a list with the dependent variables

Description: FromJetVariablesToJetNumbers returns the given expression after replacing jetvariables x, y, ... u, v, ... by the corresponding jet numbers according to the order implicit in F.

Example

> PDEtools:-Library:-FromJetVariablesToJetNumbers(u[x]*u[]+v[t,t]*u[x] = 0, [u,v](x,t));

                      u[1] u[] + v[2, 2] u[1] = 0

GenerateInfinitesimalLabels(xi,eta,Y,X,{(jetnotation::identical(true,false,jetnumbers,jetvariables,jetvariableswithbrackets,jetODE) := 'jetnumbers'), (functionality::Or(list({name, function}),"not given") := "not given"), (prolongation::nonnegint := 0)})

Parameters

* xi    - a name to be used as root xi[q], for the infinitesimals related to transformations of the independent variables
* eta   - a name to be used as root eta[q], for the infinitesimals related to transformations of the dependent variables
* Y     - a list with the names of the dependent variables
* X     - a list with the independent variables (names)
* functionality - optional, a list with the functionality to be attached to the labels in the list of infinitesimal's labels returned
* jetnotation - optional, default is 'jetnumbers', can be any jet notation in use in PDEtools (see ?PDEtools:-ToJet)
* prolongation - optional, default is 0, can be any nonnegative integer

Description: GenerateInfinitesimalLabels returns a list of infinitesimal labels, prolonged to any order, that can be attached (e.g., using zip) to infinitesimals without labels, or just to understand the ordering implied when infinitesimasl are returned by other PDEtools commands without labels.

Example

> PDEtools:-Library:-GenerateInfinitesimalLabels(xi, eta, [u,v,w],[x,y,z], jetnotation = jetvariables);

            [xi[x], xi[y], xi[z], eta[u], eta[v], eta[w]]

> PDEtools:-Library:-GenerateInfinitesimalLabels(xi, eta, [u,v,w],[x,y,z], jetnotation = jetvariables, functionality = [x,y,z,u,v,w]);

  [xi[x](x, y, z, u, v, w), xi[y](x, y, z, u, v, w),

        xi[z](x, y, z, u, v, w), eta[u](x, y, z, u, v, w),

        eta[v](x, y, z, u, v, w), eta[w](x, y, z, u, v, w)]

> PDEtools:-Library:-GenerateInfinitesimalLabels(xi, eta, [u,v,w],[x,y,z], prolongation = 1);

  [xi[1], xi[2], xi[3], eta[1], eta[2], eta[3], eta[1, [1]],

        eta[2, [1]], eta[3, [1]], eta[1, [2]], eta[2, [2]],

        eta[3, [2]], eta[1, [3]], eta[2, [3]], eta[3, [3]]]

> PDEtools:-Library:-GenerateInfinitesimalLabels(xi, eta, [u,v,w],[x,y,z], prolongation = 2, jetnotation = jetvariables);

  [xi[x], xi[y], xi[z], eta[u], eta[v], eta[w], eta[u, [x]],

        eta[v, [x]], eta[w, [x]], eta[u, [y]], eta[v, [y]],

        eta[w, [y]], eta[u, [z]], eta[v, [z]], eta[w, [z]],

        eta[u, [x, x]], eta[v, [x, x]], eta[w, [x, x]],

        eta[u, [x, y]], eta[v, [x, y]], eta[w, [x, y]],

        eta[u, [x, z]], eta[v, [x, z]], eta[w, [x, z]],

        eta[u, [y, y]], eta[v, [y, y]], eta[w, [y, y]],

        eta[u, [y, z]], eta[v, [y, z]], eta[w, [y, z]],

        eta[u, [z, z]], eta[v, [z, z]], eta[w, [z, z]]]

GetCoefficients(sys,vars,{(undeterminedcoefficients := "not given"), (usephysics::truefalse := false)})

Parameters

* sys    - a system of algebraic expressions
* vars    - a set or list of algebraic objects, typically names
* undeterminedcoefficients - optional, a set of names, to select, in each of the coefficients being returned, the factors that contain these 'undeterminedcoefficients'

Description: GetCoefficients returns a set with the coefficients of vars, and of mathematical objects that have vars, found in sys.

Example

> PDEtools:-Library:-GetCoefficients({v2[3]*(v1[3]+v1[5]*y+2*v1[6]*x)+v2[2]*(v1[2]+2*v1[4]*y+v1[5]*x)+1}, {x, y});

  {2 v2[2] v1[4] + v2[3] v1[5], 2 v2[3] v1[6] + v2[2] v1[5],

        v2[3] v1[3] + 1 + v2[2] v1[2]}

> ee := {-y*exp(x)*(v[9]*ln(y)+v[12]*ln(x)+v[4]*x+2*v[15]*Ei(x)+2*v[13]*exp(x)*x), -y*((2*v[28]+x)*exp(x)^2+(ln(x)*v[27]+x*v[19]+ln(y)*v[24]+2*Ei(x)*v[30])*exp(x))}:

> PDEtools:-Library:-GetCoefficients(ee, [Ei(x), exp(x), ln(x), ln(y)]);

  {y v[9], y v[12], y v[15], y v[24], y v[27], y v[30],

        y (2 v[28] + x), y x v[19], y v[4] x, y v[13] x}

> PDEtools:-Library:-GetCoefficients(ee, [Ei(x), exp(x), ln(x), ln(y)], undeterminedcoefficients = [v]);

  {v[4], v[9], v[12], v[13], v[15], v[19], v[24], v[27], v[30], 2 v[28] + x}

GetDepVars(DepVars,(PDESYS::{identical("not given"), {`<>`, `=`, algebraic, And(Or(set({`<>`, `=`, algebraic}),list({`<>`, `=`, algebraic})),satisfies(SL -> evalb(0 < nops(SL))))}} := "not given"),{(dependencytype::anything := `PDEtools/F(...)`), (onlydifferentiatedfunctions::truefalse := true), (removeDepVarsnotfoundinPDESYS::truefalse := false)})

Parameters

* DepVars   - a name or a function or a set or list of them, or the string "not given"
* PDESYS    - a differential (or not) equation, or a set or list, or the string "not given"
* dependencytype - optional, to consider a dependent variable only those of type 'function(dependencytype)'
* onlydifferentiatedfunctions   - optional, can be true (default) or false, when DepVars = "not given", consider dependent variable only those functions that are found in differentiated within PDESYS
* removeDepVarsnotfoundinPDESYS - optional, can be true or false (default), to discard dependent variables indicated in DepVars but not found in PDESYS

Description: GetDepVars checks for inconsistencies in the given DepVars with respect to given PDESYS and returns a list with the input DepVars after removing repeated elements, and when PDEsys is given it also replaces, in the given DepVars, names by the corresponding functions, optionally returning only the functions actually found in PDEsys.

Example

> PDEtools:-Library:-GetDepVars([u(x,t), v(x,t), w(x,t)], diff(u(x,t),x) = v(x,t));

                     [u(x, t), v(x, t), w(x, t)]

> PDEtools:-Library:-GetDepVars([u, v, w], diff(u(x,t),x) = v(x,t), removeDepVarsnotfoundinPDESYS);

                          [u(x, t), v(x, t)]

> PDEtools:-Library:-GetDepVars("not given", diff(u(x,t),x) = v(x,t));

                              [u(x, t)]

> PDEtools:-Library:-GetDepVars("not given", diff(u(x,t),x) = v(x,t), onlydifferentiatedfunctions = false);

                          [u(x, t), v(x, t)]

> PDEtools:-Library:-GetDepVars([u(x,t), v(x,t), w(x,t)], diff(u(x,t),x) = u(t, x));
  Error, (in PDEtools:-Library:-GetDepVars) unexpected functions with name [u] having different dependency: [[u(t,x), u(x,t)]]

GetDependency(dependency,PDESYS,(DepVars := "not given"),{(groupedbynumberofvariables::truefalse := false), (onlydifferentiatedfunctions::truefalse := true), (sortedbyascendingnumberofvariables::Or(truefalse,identical("not given")) := "not given"), (vars::{list(name), identical("not given")} := "not given")})

Parameters

* dependency   - an abstract indication of dependency (see the option dependencyofinfinitesimals in ?PDEtools:-InvariantSolutions)
* PDESYS       - a differential (or not) equation, or a set or list, or the string "not given"
* DepVars      - a name or a function or a set or list of them, or the string "not given"
* groupedbynumberofvariables  - optional, can be true or false (default), to return the list of dependencies with all its inner lists that thave the same number of variables enclosed with a list
* onlydifferentiatedfunctions - optional, can be true (default) or false, when 'vars' = "not given", consider dependent variable only those functions that are found in differentiated within PDESYS
* sortedbyascendingnumberofvariables - optional, can be true, false or "not given" (default), to sort the returned list of lists of dependencies by ascending or descending number of variables, and to not sort when it is "not given"
* vars - optional, a list of variables to be organized according to 'dependency'; if not given, it is derived from PDESYS and DepVars

Description: GetDependency returns a list of lists of function's dependencies, according to what is indicated in the first argument 'dependency' (see the option dependencyofinfinitesimals in ?PDEtools:-InvariantSolutions).

Example

> PDEtools:-Library:-GetDependency(1..2, PDESYS);

  [[x], [y], [z], [t], [u], [x, y], [x, z], [x, t], [x, u], [y, z],

        [y, t], [y, u], [z, t], [z, u], [t, u]]

> PDEtools:-Library:-GetDependency(1..2, vars = [x,y,z,t]);

  [[x], [y], [z], [t], [x, y], [x, z], [x, t], [y, z], [y, t], [z, t]]

> PDEtools:-Library:-GetDependency(1..2, PDESYS, groupedbynumberofvariables = true);

  [[[x], [y], [z], [t], [u]], [[x, y], [x, z], [x, t], [x, u], [y, z],

        [y, t], [y, u], [z, t], [z, u], [t, u]]]

> PDEtools:-Library:-GetDependency(1..2, PDESYS, sortedbyascendingnumberofvariables = false);

  [[x, y], [x, z], [x, t], [x, u], [y, z], [y, t], [y, u], [z, t],

        [z, u], [t, u], [x], [y], [z], [t], [u]]

GetExplicitSolutions(F,{(discardDESol::truefalse := false), (discardODESolStruc::truefalse := false)})

Parameters

* F    - a set or list of unknowns
* _rest      - a sequence of equations or of sets of equations

Description: GetExplicitSolutions returns the equations and sets of equations of '_rest' such that the left-hand-sides are members of the list of unknowns 'F'.

Example

> PDEtools:-Library:-GetExplicitSolutions([a, u(x,t)], {a=1, u(x,t) = x}, {a-u(x,t) = 0});

                         {a = 1, u(x, t) = x}

GetFAndDiffVars(df,{(usephysics::truefalse := false)})

Parameters

* df    - a derivative in diff, %diff or Diff notation

Description: If 'df' is a derivative in diff notation, GetFAndDiffVars returns a sequence: the derivand followed by all the differentiation variables, otherwise it returns the arguments received.

Example

> PDEtools:-Library:-GetFAndDiffVars(diff(diff(diff(diff(diff(u(x,t),t),t),x),x),x));

                        u(x, t), t, t, x, x, x

GetFunctionsWithDifferentDependency(F,(Y := map2(op,0,F)))

Parameters

* F    - a list of distinct functions
* Y    - optional, a list of function's names positionally corresponding to the functions found in F

Description: GetFunctionsWithDifferentDependency returns a sequences of two lists, with the functions in F that have the same name but (being distinct) they have different functionality.

Example

> PDEtools:-Library:-GetFunctionsWithDifferentDependency([f(x), g(y), f(z), g(z), f(y)]);

              [f, g], [[f(x), f(z), f(y)], [g(y), g(z)]]

GetIndepVars(F)

Parameters

* F   - a list of unknown functions, or the string "not given"

Description: GetIndepVars returns the variables of type name found in F, typically representing independent variables, preserving the ordering found in the list F and after removing repeated elements.

Example

> PDEtools:-Library:-GetIndepVars([u(x,t), v(t,z), w(x,y,z)]);

                             [x, t, z, y]

GetInfinitesimals(S::list,(Y::{list(name), identical("not given")} := "not given"),(X::{list(name), identical("not given")} := "not given"),{(functionality::truefalse := false)})

Parameters

* S    - a list of infinitesimals
* Y    - the names of the dependent variables
* X    - the independent variables
* functionality - optional, to request the functionality found in the labels of the left-hand-sides of equations in 'S'

Description: GetInfinitesimals checks the syntax of a list of infinitesimals 'S' and either interrupts with an error message if there is something unepxected in it, or returns the given list unchanged when everything checks OK. When the option functionality is passed, the received list of infinitesimals is returned within a sequence of two elementes, where the second element is a list with the functionality of the functions found in the left-hand-sides of the received list of infinitesimals when they are given as equations [_xi[x](x,y,..) = ..., ], or the string "not present", when the infinitesimals were passed as a list of algebraic expressions, not equations.

Example

> PDEtools:-Library:-GetInfinitesimals([_xi[1](x,y,z,t,u[]) = 0, _xi[2](x,y,z,t,u[]) = 1, _xi[3](x,y,z,t,u[]) = 0, _xi[4](x,y,z,t,u[]) = 0, _eta[1](x,y,z,t,u[]) = 0], functionality);
  
  [_xi[1] = 0, _xi[2] = 1, _xi[3] = 0, _xi[4] = 0, _eta[1] = 0], [x, y, z, t, u[]]

GetJetVariables(sys,F::{list, set},{(applyToJet::truefalse := false), (includeindependentvariables::truefalse := true), (jetnotation::identical(true,false,jetnumbers,jetvariables,jetvariableswithbrackets,jetODE) := 'jetnumbers')})

Parameters

* sys    - an algebraic object or equation, or a set or list of them
* F      - a list of unknown functions defining the jet space
* includeindependentvariables  - optional, can be true (default) or false, to include the independent variables defining the jet space together with the dependent variables
* applyToJet                   - optional, can be true or false (default), to apply 'ToJet' to 'sys' before proceeding

Description: GetJetVariables returns the jet variables found in sys, using jetnumbers notation, taking F as the dependent variables of the problem.

Example

> PDEtools:-Library:-GetJetVariables(diff(u(x,t),x,x)*x+diff(u(x,t),x), {u(x,t)}, applyToJet);

                        {t, x, u[1], u[1, 1]}

GetNewDepAndIndepVars(NewVars,Y,X)

Parameters

* newVars  - a list of (new) unknown functions typically defininig a (new) jet space
* Y        - a list with the names of (old) unknown functions, typically defining an (old) jet space
* X        - a list with the names of (old) independent variables

Description: GetNewDepAndIndepVars returns two lists with respectively the same number of elements and type as Y and X, typically representing new variables, or an error message when some inconsistency is detected.

Example

> PDEtools:-Library:-GetNewDepAndIndepVars([u(r,s), v(r,s)], [y, z], [x, t]);

                            [u, v], [r, s]

> PDEtools:-Library:-GetNewDepAndIndepVars([u(r,s)], [y, z], [x, t]);

  Error, (in PDEtools:-Library:-GetNewDepAndIndepVars) expected an indication of 2 new dependent variables, received a list with only 1

> PDEtools:-Library:-GetNewDepAndIndepVars([u(r), v(r)], [y, z], [x, t]);

  Error, (in PDEtools:-Library:-GetNewDepAndIndepVars) expected to find at least 2 new independent variables in the dependency of the indicated new dependent variables, where there are only 1 independent variables

GetNew_Fn(sol,PDE,(sorted::truefalse := true))

Parameters

* sol    - an algebraic object or a set or list of them, typically representing the solution to a differential equation system
* PDE    - an algebraic object or a set or list of them, typically representing the system for which 'sol' is a solution
* sorted  - can be true (default value if not given) or false, to sort or not the output list before returning
* applyToJet                   - optional, can be true or false (default), to apply 'ToJet' to 'sys' before proceeding

Description: GetNew_Fn returns the new _Fn arbitrary function's names entering sol and not found in PDE.

Example

> PDEtools:-Library:-GetNew_Fn(u(x,t) = Int((Int(_F1(x),x)+_F2(t))/x,x)+_F3(t), diff(u(x,t),x,x)*x+diff(u(x,t),x) = _F1(x));

                              [_F2, _F3]

GetNotation(ee,F::list,{(converttodiff::truefalse := false)})

Parameters

* ee    - any Maple object (but not a procedure)
* F     - a list of unknown functions
* converttodiff  - optional, can be true or false (default), to convert to diff notation before proceeding

Description: GetNotation returns a list with the jet notations found in 'ee', among: 'function', 'jetnumbers', 'jetvariables', 'jetvariableswithbrackets' and 'jetODE'.

Example

> PDEtools:-Library:-GetNotation(diff(u(x,t),x,x)*x + diff(u(x,t),x), [u(x,t)]);

                              [function]

> PDEtools:-Library:-GetNotation(u[x,x]*x + u[x], [u(x,t)]);

                            [jetvariables]

> PDEtools:-Library:-GetNotation(u[x,x]*x + u[x] + u[], [u(x,t)]);

                      [jetvariableswithbrackets]

> PDEtools:-Library:-GetNotation(u[x,x]*x + u[x] + u[1], [u(x,t)]);

                      [jetnumbers, jetvariables]

> PDEtools:-Library:-GetNotation(diff(y(x),x) = _y1, [y(x)]);

                          [function, jetODE]

GetPDESYS(PDESYS,{(notation::Or("as given",And(symbol,satisfies(s -> member(cat(s),'{:-D, :-diff}')))) := (NULL)[diff]), (equation_to_algebraic::truefalse := true)})

Parameters

* PDESYS - an algebraic object or equation, or a set or list of them
* notation               - optional, can be diff (default), D or the string "as given", to indicate the notation to use in the output list
* equation_to_algebraic  - optional, can be true (default) or false, to transform equations into the corresponding lhs - rhs in the output list.

Description: GetPDESYS returns a list with the input system after removing repeated elements mapping equations into lhs-rhs, optionally not performing that mapping.

Example

> PDEtools:-Library:-GetPDESYS([diff(u(x,t),x,x)*x+diff(u(x,t),x) = _F1(x), diff(u(x,t),x,x)*x+diff(u(x,t),x) - _F1(x)]);

               / 2         \
               |d          |     /d         \
              [|--- u(x, t)| x + |-- u(x, t)| - _F1(x)]
               |  2        |     \dx        /
               \dx         /

> PDEtools:-Library:-GetPDESYS([diff(u(x,t),x,x)*x+diff(u(x,t),x) = _F1(x), diff(u(x,t),x,x)*x+diff(u(x,t),x) - _F1(x)], notation = D);

            [D[1, 1](u)(x, t) x + D[1](u)(x, t) - _F1(x)]

GetProlongationValue(infinitesimal_generator::{list, procedure},Y::list(name),X::list(name))

Parameters

* infinitesimal_generator    - a list of infinitesimals or an infinitesimal generator operator
* Y      - list with the names of the dependent variables defining the jet space
* X      - list with the names of the independent variables

Description: GetProlongationValue returns a nonegative integer representing the prolongation of the given infinitesimal.

Example

> PDEtools:-Library:-GetProlongationValue(f -> x*diff(f,x)+t*diff(f,t)+u*diff(f,u)-u[x,x]*diff(f,u[x,x]), [u], [x,t]);

                                  2

GetRepeatedNames(Y)

Parameters

* Y - a list with names, typically the names of functions defining a jet space

Description: GetRepeatedNames returns, in a set, the operands of Y that appear repeated.

Example

> PDEtools:-Library:-GetRepeatedNames([u, v, w, u]);

                                 {u}

GetSysUFYX(PDESYS,DepVars,{(onlydifferentiatedfunctions::truefalse := true)})

Parameters

* PDESYS    - an algebraic object or equation, or a set or list of them, typically representing a differential equation system
* DepVars   - an unkonwn, or a set or list with the unknown functions of the problem
* onlydifferentiatedfunctions  - optional, can be true (default) or false, to include only the differentiated functions of PDESYS in the list of dependent variables within the sequence of objects returned

Description: GetSysUFYX returns a sequence of five objects: PDESYS in diff format, the unknown functions in it, the dependent variables according to DepVars, their names, and a list with the independent variables.

Example

> PDEtools:-Library:-GetSysUFYX(diff(u(x,t),x,x)*x+diff(u(x,t),x) = F(x), u(x,t));

 / 2         \
 |d          |     /d         \
[|--- u(x, t)| x + |-- u(x, t)| - F(x)], {F(x), u(x, t)}, [u(x, t)], [u], [x, t]
 |  2        |     \dx        /
 \dx         /

GetUnknownsAndDependency(object,other_unknowns,F,(Y := map2(op,0,F)),{(jetnotation::identical(true,false,jetnumbers,jetvariables,jetvariableswithbrackets,jetODE) := 'jetvariableswithbrackets'), (dependencytype::anything := `PDEtools/F(...)`), (kind_of_object::{string, symbol} := "received object")})

Parameters

* object          - an algebraic object or equation, or a set or list of them
* other_unknowns  - an algebraic object or equation, or a set or list of them
* F               - a set or list of unknown functions to be excluded in the output
* dependencytype  - optional, a type indicating the type of function to be tested

Description: GetUnknownsAndDependency checks syntax of unknowns in 'object' and the absence of conflicts with 'other_unknowns' - for example functions with the same name but different dependency - then returns a sequence with two elements: the unknowns in object and a list with all their dependency.

Example

> PDEtools:-Library:-GetUnknownsAndDependency(diff(u(x,t),x,x)*x+diff(v(x,t),x), {v(x,t)}, [u(x,t)]);

                          {v(x, t)}, [x, t]

Gsolve(SYS,_F_,{(solver::identical("not given",pdsolve,dsolve,`ODEtools/Solve/EnvDropMultiplicity`,solve,fsolve,`ODEtools/Solve`,InvariantSolutions,SimilaritySolutions,PolynomialSolutions,FunctionFieldSolutions) := "not given"), (validsolvers := 'anything'), (explicitsolutions::{truefalse, identical(build)} := build), (DepVarswerederived::truefalse := false), (allowrecursingforfsolve::truefalse := true), (boundaryconditions::set({`=`, algebraic}) := {}), (build::truefalse := true), (convertindeterminedto_Fn::truefalse := false), (derivatives::{"not given", set} := "not given"), (differentiatedfuncs::{"not given", set} := "not given"), (dropmultiplicity::truefalse := true), (errormessage := "not given"), (getsolverusedonly::truefalse := false), (independentof::set(name) := {}), (ivarsused := "not given"), (numericsolution::truefalse := false), (pretendcasesplitans := false), (rankingused := "not given"), (seriessolution::truefalse := false)})

Parameters

* SYS   - an algebraic object or equation, or a set or list of them representing the system to be solved
* _F_   - the unknowns of the problem, it could be a symbol, or a function or a set or list of them
* explicitsolutions  - optional, can be true (default) or false, to only return solutions when they are explicit

Description: Gsolve is the generic internal solver of the symmetry commands of the PDEtools package, and of the PDEtools:-Solve command. Gsolve automatically handles pdes, odes or algebraic equations; by default it only returns explicit solutions.

Example

> PDEtools:-Library:-Gsolve(a+b=c, b);

                             {b = -a + c}

> PDEtools:-Library:-Gsolve(diff(u(x,t),x,x)*x+diff(v(x,t),x), [u,v](x,t));

                       d
               /   /   -- v(x, t)
              |   |    dx
  {u(x, t) =  |   |  - ---------- dx dx + _F1(t) x + _F2(t), v(x, t) = v(x, t)}
              |   |        x
             /   /

HasDependency(sol::`=`,DEP::{list(name), set(name)})

Parameters

* sol    - an equation
* DEP    - a set or list of names

Description: HasDependency returns true or false, according to whether the right-hand-side of sol depends on all the names indicated in DEP.

Example

> PDEtools:-Library:-HasDependency(f(x,y,z) = x*y + g(x,y), [x,y,z]);

                                false

> PDEtools:-Library:-HasDependency(f(x,y,z) = x*y + g(x,z), [x,y,z]);

                                 true

HasDerivatives(ee,DY,(F := indets({DY, ee},'`PDEtools/F(...)`')),{(derivatives_ee::{set(specfunc(anything,[diff, Physics:-diff])), identical(NULL)} := NULL), (gotofunctionnotation::truefalse := true), (usephysics::truefalse := false)})

Parameters

* ee    - an algebraic object or equation, or a set or list of them
* DY    - a derivative in jetnotation, or in function notation using diff, possibly of order zero (i.e. an unknown function), or set or list of them
* F     - a list of unknown functions defining a jet space, to be used when ee is passed in jet notation
* gotofunctionnotation  - optional, can be true (default) or false, to rewrite ee from jet notation to function notation before proceeding

Description: HasDerivatives returns true or false, according to whether derivatives of ee are derivatives of derivatives of DY.

Example

> PDEtools:-Library:-HasDerivatives(u[x,x,t]*x+u[x], diff(u(x,t), x,t));

                                 true

> PDEtools:-Library:-HasDerivatives(diff(u(x,t), x,x,t)*x + diff(u(x,t), x), diff(u(x,t), x,t));

                                 true

> PDEtools:-Library:-HasDerivatives(u[x,x,t]*x+u[x], u[t,x], u(x,t));

                                 true

> PDEtools:-Library:-HasDerivatives(u[x,x,t]*x+u[x], u[t,t], u(x,t));

                                 false

HideFalseDerivatives(sys)

Parameters

* sys  - an algebraic object or equation, or a set or list of them

Description: HideFalseDerivatives returns a sequence of two objects: sys after hiding in it the false derivatives (DESol, ODESolStruc and PDESolStruc functions) and the equations to use to restore them.

Example

> PDEtools:-Library:-HideFalseDerivatives(f(x) = DESol({diff(y(x),`$`(x,3))-y(x)},{y(x)}) + ODESolStruc(f(b), [{diff(f(b),b)=c}, {b=x, f(b)=y(x)}, {x=b, y(x) = f(b)}]));

    f(x) = _DES1(x) + _ODE1(x),
                          / 3      \
                          |d       |
       {_DES1(x) = DESol({|--- y(x)| - y(x)}, {y(x)}),
                          |  3     |
                          \dx      /

                            d
   _ODE1(x) = f(b) &where [{-- f(b) = c}, {b = x, f(b) = y(x)}, {x = b, y(x) = f(b)}]}
                            db

InfinitesimalGeneratorToList(G::procedure,F::list,(Y := map2(op,0,F)),(X := GetIndepVars(F)),{(jetnotation := "not given"), (prolongation::{nonnegint, identical("not given")} := "not given")})

Parameters

* G   - an infinitesimal generator operator (a Maple procedure)
* F   - a list of unknown functions defining the jet space
* prolongation  - optional, a nonegative integer indicating the prolongation order of the returned list of infinitesimals
* jetnotation   - optional, it's default value is the notation found in G, used to indicated an alternative notation among: jetvariables, jetvariableswithbrackets, jetnumbers or jetODE

Description: InfinitesimalGeneratorToList receives an infinitesimal generator operator (a differential operator) and returns the corresponding list of infinitesimals; in that sense this command implements the inverse operation of PDEtools:-InfinitesimalGenerator.

Example

> PDEtools:-Library:-InfinitesimalGeneratorToList(f -> diff(f,x)/u[x] + t*u[t,t]*diff(f, u) - x*u[t]*diff(f, u[x,t]), [u(x,t)]);

                1
              [----, 0, t u[t, t], 0, 0, 0, -x u[t], 0]
               u[x]

> PDEtools:-Library:-InfinitesimalGeneratorToList(f -> diff(f,x)/u[x] + t*u[t,t]*diff(f, u) - x*u[t]*diff(f, u[x,t]), [u(x,t)], jetnotation = jetnumbers);

                1
              [----, 0, t u[2, 2], 0, 0, 0, -x u[2], 0]
               u[1]

IsAutonomousPDE(PDESYS,F)

Parameters

* PDESYS - a set or list of algebraic expressions or equations
* F      - a set or list of unknowns

Description: IsAutonomousPDE returns true or false, according to whether PDESYS is autonomous; i.e. the independent variables in PDESYS appear only through the dependent variables.

Example

> PDEtools:-Library:-IsAutonomousPDE({diff(u(x,t),x,x) * x + diff(u(x,t),x)}, {u(x,t)});

                                false

> PDEtools:-Library:-IsAutonomousPDE({diff(u(x,t),x,x) * u(x,t) + diff(u(x,t),x)}, {u(x,t)});

                                 true

IsHigherDerivative(a,b,(X := "not given"))

Parameters

* a  - an indexed name where the index is a positive integer, typically representing a derivative in jetnumbers notation
* b  - same as a

Description: IsHigherDerivative returns true or false, according to whether `a` is a derivative of higher or equal order than `b`, where `a` and `b` are indexed objects typically representing derivatives in jet numbers notation.

Example

> PDEtools:-Library:-IsHigherDerivative(v[1,1,1], v[2,2]);

                                 true

> PDEtools:-Library:-IsHigherDerivative(u[2,2], v[1,1,2]);

                                false

IsLinearPDE(PDESYS,F)

Parameters

* PDESYS - a set or list of algebraic expressions or equations
* F      - an unknown, or a set or list of them

Description: IsLinearPDE returns true or false, according to whether PDESYS is linear in F and its derivatives.

Example

> PDEtools:-Library:-IsLinearPDE({diff(u(x,t),x,x) * x + diff(u(x,t),x)^2}, {u(x,t)});

                                true

> PDEtools:-Library:-IsLinearPDE({diff(u(x,t),x,x) * u(x,t) + diff(u(x,t),x)}, {u(x,t)});

                                 false

IsPointSymmetry(S,F::list(`PDEtools/F(...)`),(Y := map2(op,0,F)),(X := GetIndepVars(F)))

Parameters

* S  - a list of symmetry infinitesimals
* F  - a list of unknowns defining the jet space

Description: IsPointSymmetry returns true or false, according to whether S is a list of point symmetry infinitesimals taking F as the unknowns of the problem.

Example

> PDEtools:-Library:-IsPointSymmetry([xi[x] = 0, xi[t]=1, eta[u]=x/u], [u(x,t)]);

                                 true

> PDEtools:-Library:-IsPointSymmetry([xi[x] = 0, xi[t]=1, eta[u]=x/u[x]], [u(x,t)]);

                                false

> PDEtools:-Library:-IsPointSymmetry([xi[x] = 0, xi[t] = 1, eta[u] = x/diff(u(x,t),x)], [u(x,t)]);

                                false

IsReducible(sys1,sys2::{`=`, list(`=`), set(`=`)},F,(Y := map2(op,0,F)),{(rewriteinjetvariables::truefalse := true), (tryhasYshortcut::truefalse := true)})

Parameters

* sys1   - an algebraic object or equation, or a set or list of them, typically representing a differential equation system
* sys2   - an equation, or a set or list of them, typically representing another differential equation system
* F     - a list with the unknown functions of the problem
* rewriteinjetvariables  - optional, can be true (default) or false, to rewrite sys1 and sys2 in jetvariables notation before proceeding
* tryhasYshortcut      - optional, can be true (default) or false, to check first whether sys1 and 'has' any of the function names of F, as a shortcut for 'false'

Description: IsReducible returns true or false, according to whether any of the derivatives found in sys1 is reducible by any derivative found in left-hand-sides of sys2.

Example

> PDEtools:-Library:-IsReducible({u[x,x,t]*x+u[x]}, {u[x,t] = 0}, [u(x,t)]);

                                 true

> PDEtools:-Library:-IsReducible({diff(u(x,t), x,x,t) * x + diff(u(x,t), x)}, {diff(u(x,t), x,t)=0}, [u(x,t)]);

                                 true

> PDEtools:-Library:-IsReducible({diff(u(x,t), x,x,t) * x + diff(u(x,t), x)}, {diff(u(x,t), t,t)=0}, [u(x,t)]);

                                false

JetNumbersToJetVariables(n::Or(posint,list({name, posint}),name),Q::list(name))

Parameters

* n  - a positive integer or a list of them typically representing jet numbers
* Q  - a list of names typically representing 'all' the variables of a jet space

Description: JetNumbersToJetVariables returns the jet variable (or the list of jet variables) corresponding to the jet number(s) q within Q.

Example

> PDEtools:-Library:-JetNumbersToJetVariables([1, 2, 3], [x, t, u]);

                              [x, t, u]

> PDEtools:-Library:-JetNumbersToJetVariables([2, 1, 3], [x, t, u]);

                              [t, x, u]

JetVariablesToJetNumbers(q::Or(name,list({name, posint}),posint),Q::list(name))

Parameters

* q  - a name or a list of names typically representing jet variables
* Q  - a list of names typically representing 'all' the variables of a jet space

Description: JetVariablesToJetNumbers returns the position (or the list of positions) of q within Q, representing the corresponding jet numbers.

Example

> PDEtools:-Library:-JetVariablesToJetNumbers([x, t, u], [x, t, u]);

                              [1, 2, 3]

> PDEtools:-Library:-JetVariablesToJetNumbers([t, u, x], [x, t, u]);

                              [2, 3, 1]

MapHintIntoPDESolution(hinted_solution::set({name, function}),forbbiden_symbols)

Parameters

* hinted_solution   - a set of names or functions to be mapped into arbitrary constants and functions
* forbbiden_symbols - any Maple object containing names not to enter the right-hand-sides of the returned equations

Description: MapHintIntoPDESolution returns a set with equations where each name or function in hinted_solution is equated to an arbitrary constant or function as in - say - f into f, f() into _C1, and f(x) into _F1(x).

Example

> PDEtools:-Library:-MapHintIntoPDESolution({f, _xi[1](), _xi[2](), _eta[1](), _eta[2](x,y)}, [_C1, _F1]);

  {f = f, _xi[1]() = _C2, _xi[2]() = _C3, _eta[1]() = _C4, _eta[2](x, y) = _F2(x, y)}

NormalizeBoundaryConditions(BC0::Or(set({algebraic, equation}),list({algebraic, equation})),F::list(And(function,Not(`PDEtools/known_function`))),{(allowmanyimplicitbc::truefalse := false), (homogeneousformat::truefalse := false)})

Parameters

* BC0    -  set of boundary conditions as equations or algebraic expressions containing the unknowns F (second argument) and possibly their partial derivatives evaluated at points
* F      - a list of unknown functions

Description: NormalizeBoundaryConditions returns the given set of boundary conditions after verifying the conditions for syntactic correctness and normalizing them by rewritting in D notation and solving for F and their derivatives evaluated at points.

Example

> e1 := {v(x,0)+u(0,0) = 1+x*f(x)+c[0], v(x,0)-u(0,0) = 1+x*f(x)-c[0], 3*v(x,0)-D[2](u)(x,0) = 3+3*x*f(x)-D[2](u)(x,0), D[1,1](u)(0,0)(x,y)-diff(u(x,y),y) = -c[2], D[2,2](u)(0,0)(x,y)+diff(u(x,y),`$`(x,2)) = -1};

  e1 := {v(x, 0) - u(0, 0) = 1 + x f(x) - c[0],

        v(x, 0) + u(0, 0) = 1 + x f(x) + c[0],

        3 v(x, 0) - D[2](u)(x, 0) = 3 + 3 x f(x) - D[2](u)(x, 0),

                                 /d         \
        D[1, 1](u)(0, 0)(x, y) - |-- u(x, y)| = -c[2],
                                 \dy        /

                                 / 2         \
                                 |d          |
        D[2, 2](u)(0, 0)(x, y) + |--- u(x, y)| = -1}
                                 |  2        |
                                 \dx         /

> PDEtools:-Library:-NormalizeBoundaryConditions(e1, [u, v](x, y));

  {u(0, 0) = c[0], v(x, 0) = 1 + x f(x),

        D[2](u)(x, y) = D[1, 1](u)(0, 0)(x, y) + c[2],

        D[1, 1](u)(x, y) = -D[2, 2](u)(0, 0)(x, y) - 1}

Normalize_Fn_Cn(sol::{list, set},{(ignore_Cn::truefalse := false), (ignore_Fn::truefalse := false), (set_F_C_in_use::truefalse := true), (symbolsininput::set(symbol) := "not given"), (symbolsinsol::set(symbol) := "not given"), (update_Cn::truefalse := true), (update_Fn::truefalse := true)})

Parameters

* sol - a set or list of algebraic objects or equations, typically representing the solution of a system of differential equations, where _Fn functions and _Cn constants are to be normalized
* ignore_Fn  - optional, to ignore the arbitrary _Fn functions and normalize only the arbitrary _Cn constants
* ignore_Cn  - optional, to ignore the arbitrary _Cn constants and normalize only the _Fn arbitrary functions
* update_Fn  - optional, can be true (default) or false, to correspondingly update or not the values of _Fn being introduced when moving from one equation to the next one in sol
* update_Cn  - optional, can be true (default) or false, to correspondingly update or not the values of _Cn being introduced when moving from one equation to the next one in sol

Description: Normalize_Fn_Cn returns sol2 where sol2 is sol after normalizing the _Cn arbitrary constants and _Fn arbitrary functions by renumbering them as low as possible and in sequence. If nothing is to be done, sol2 = sol.

Example

> sol := {y(x,t) = _C2*x + _F5(t), f(x,t) = _C2 + _F7(x*t)}:

> PDEtools:-Library:-Normalize_Fn_Cn(sol);

          f(x, t) = _C1 + _F1(x t), y(x, t) = _C2 x + _F2(t)

> PDEtools:-Library:-Normalize_Fn_Cn(sol, update_Fn = false);

          f(x, t) = _C1 + _F1(x t), y(x, t) = _C2 x + _F1(t)

> PDEtools:-Library:-Normalize_Fn_Cn(sol, update_Cn = false);

          f(x, t) = _C1 + _F1(x t), y(x, t) = _C1 x + _F2(t)

> PDEtools:-Library:-Normalize_Fn_Cn(sol, update_Cn = false, update_Fn = false);

          f(x, t) = _C1 + _F1(x t), y(x, t) = _C1 x + _F1(t)

PartialDerivatives(F0::{list, name},(dx_difforder := []),{(maxdifforder::nonnegint := `+`(op(dx_difforder))), (nX::nonnegint := nops(dx_difforder)), (includeorderzero::truefalse := false), (onlyhigherorder::truefalse := false)})

Parameters

* F0            - a function name
* dx_difforder  - optional, a list of numbers representing differential order with respect to each independent variable
* nX = ..            - optional, the right-hand-side is a positive number indicating the number of independent variables
* maxdifforder = .. - optional, the right-hand-side is a positive number indicating the maximum differential order; default value is the sum of the numbers in dx_difforder
* includeorderzero - optional, can be true or false (default), to include derivatives of order zero, that is the functions themselves
* onlyhigherorder - optional, can be true or false (default), to return only the partial derivatives of higher order (maxdifforder)

Description: PartialDerivatives returns a sequence of F0[n, m, ...], representing derivatives in jetnotation = jetnumbers, where n, m, ... are not bigger than the differential orders specified in dx_diff_order, and the total differential order is not bigger than the optionally specified maxdifforder.

Example

> PDEtools:-Library:-PartialDerivatives(u, nX=2, maxdifforder = 3);

  u[1], u[2], u[1, 1], u[1, 2], u[2, 2], u[1, 1, 1], u[1, 1, 2],

        u[1, 2, 2], u[2, 2, 2]

> PDEtools:-Library:-PartialDerivatives(u, [1,1,3]);

  u[1], u[2], u[3], u[1, 2], u[1, 3], u[2, 3], u[3, 3], u[1, 2, 3],

        u[1, 3, 3], u[2, 3, 3], u[3, 3, 3], u[1, 2, 3, 3],

        u[1, 3, 3, 3], u[2, 3, 3, 3], u[1, 2, 3, 3, 3]

> PDEtools:-Library:-PartialDerivatives(u, [1,1,3], maxdifforder = 3);

  u[1], u[2], u[3], u[1, 2], u[1, 3], u[2, 3], u[3, 3], u[1, 2, 3],

        u[1, 3, 3], u[2, 3, 3], u[3, 3, 3]

> PDEtools:-Library:-PartialDerivatives(u, [1,1,3], maxdifforder = 3, onlyhigherorder);

            u[1, 2, 3], u[1, 3, 3], u[2, 3, 3], u[3, 3, 3]

> PDEtools:-Library:-PartialDerivatives(u, nX = 3, maxdifforder = 3, onlyhigherorder);

  u[1, 1, 1], u[1, 1, 2], u[1, 1, 3], u[1, 2, 2], u[1, 2, 3],

        u[1, 3, 3], u[2, 2, 2], u[2, 2, 3], u[2, 3, 3], u[3, 3, 3]

ProfitableSymmetry(S,F,(Y::list(name) := map2(op,0,F)),(nY::posint := nops(Y)),{(characteristicQ::assignable := NULL)})

Parameters

* S  - is a list of symmetry infinitesimals
* F  - a list of unknown functions defining the jet space
* characteristicQ  - optional, of type 'assignable', to be assigned the value of CharacteristicQ(S, F, ':-jetnotation' = ':-jetnumbers')

Description: ProfitableSymmetry returns true or false, according to whether S is a profitable symmetry, i.e., one that can be used to diminish the number of independent variables. For Q = CharacteristicQ(S, F, ':-jetnotation' = ':-jetnumbers'), if any of the Q(j) (j=1..nops(F)) does not depend on derivatives of F, then the symmetry is not profitable. Equally, if a symmetry in evolutionary form does not depend on derivatives of F then it is not profitable.

Example

> PDEtools:-Library:-ProfitableSymmetry([t, 0, t*u[x]+u], [u(x,t)]);

                                false

> PDEtools:-Library:-ProfitableSymmetry([t, 1, t*u[x]+u], [u(x,t)]);

                                 true

PutInfinitesimalLabels(S::list(algebraic),F,(Y := map2(op,0,F)),(X := GetIndepVars(F)),{(functionality::Or(list({name, function}),"not given") := "not given"), (jetnotation::identical(true,false,jetnumbers,jetvariables,jetvariableswithbrackets,jetODE) := true), (prolongation::{nonnegint, identical("not given")} := "not given"), (xi_eta::[name, name] := '[_xi, _eta]')})

Parameters

* S  - is a list of symmetry infinitesimals
* F  - a list of unknown functions defining the jet space
* xi_eta = ...        - optional, the right-hand-side is a list with two names to be used as roots of infinitesimal labels
* jetnotation = ...   - optional, default is notation found in S, can be any jet notation in use in PDEtools (see ?PDEtools:-ToJet)
* prolongation = ...  - optional, a positive integer indicating the prolongation order, default is the prolongation of S

Description: PutInfinitesimalLabels returns the given list of infinitesimals after transforming each infinitesimal into an equation, where the rhs is the infinitesimal itself and the lhs is an infinitesimal label identifying the infinitesimal.

Example

> PDEtools:-Library:-PutInfinitesimalLabels([t, 0, t*u[x]+u], [u(x,t)]);

            [_xi[x] = t, _xi[t] = 0, _eta[u] = t u[x] + u]

RecycleArguments(arguments::list,command,argspassed::list)

Parameters

* arguments   - a list of arguments of 'command' to be recycled
* command     - a Maple command that has options implemented as 'keyword parameters' (see ?parameter_classes)
* argspassed  - all the arguments received by command

Description: RecycleArguments applies 'command' to the args passed after having recycled the elements of the first list ('arguments'). The recycling consists of matching the elements of the first list 'arguments' against the optional keyword parameters accepted by 'command' and when there is a single match proceed replacing the element by the match found. When there is more than one match, RecycleArguments instead returns just the sequence of possible matches. When there is no match, RecycleArguments interrupts with a corresponding error message.

Example

> PDEtools:-Library:-RecycleArguments([type = polynomial, dis=false], PDEtools:-Infinitesimals, [diff(y(x),x), y(x), type = polynomial, dis=false]);

     * Partial match of  'type' against keyword 'typeofsymmetry'
     * Partial match of  'dis' against keyword 'displayfunctionality'

  [_xi[x] = 1, _eta[y] = 0], [_xi[x] = x, _eta[y] = 0],

        [_xi[x] = 0, _eta[y] = 1], [_xi[x] = y, _eta[y] = 0],

        [_xi[x] = 0, _eta[y] = y]

> PDEtools:-Library:-RecycleArguments([check, type = polynomial, dis=false], PDEtools:-Infinitesimals, [diff(y(x),x), y(x), check, type = polynomial, dis=false]);

  * Partial or misspelled keyword matches more than one possible eyword. Please select the correct one from below and try again.

                 checkconsistency, checkdegreesyntax

> PDEtools:-Library:-RecycleArguments([ches, type = polynomial, dis=false], PDEtools:-Infinitesimals, [diff(y(x),x), y(x), ches, type = polynomial, dis=false]);

  Error, (in PDEtools:-Library:-RecycleArguments) too many and/or wrong type of arguments passed; first unused argument is: ches

SelectRemoveSpecializable_Fn_Cn(L_Fn_Cn::list,SOL,{(allowzero::truefalse := false)})

Parameters

* L_Fn_Cn  - a list of _Fn functions and/or _Cn constants, where n is an integer, introduced by pdsolve and dsolve in the solutions they return
* SOL      - a set or list of expressions or equations containing the elements of L_Fn_Cn, typically representing the solution of a differential equation system
* allowzero  - optional, can be true or false (default), to consider 'specializable' an object that, when specialized, it cancels other _Fn or _Cn objects in SOL, or perhaps cancels SOL entirely

Description: SelectRemoveSpecializable_Fn_Cn returns two lists obtained splitting L_Fn_Cn into that can (first list) and cannot (second list) be specialized attributing value 0. A _Fn function or _Cn constant cannot be specialized when it leads to division by zero or its specialization automatically removes another _Cn or _Fn from 'SOL'.

Example

> SOL := u(x,t) = (x/_C1 + _C2*_F1(x+t))*_F2(t):

> PDEtools:-Library:-SelectRemoveSpecializable_Fn_Cn([_C1, _C2, _F1, _F2], SOL);

                       [], [_C1, _C2, _F1, _F2]

> PDEtools:-Library:-SelectRemoveSpecializable_Fn_Cn([_C1, _C2, _F1, _F2], SOL, allowzero);

                        [_C2, _F1, _F2], [_C1]

SortDerivatives(dY::list(indexed(posint)),Y::list(name))

Parameters

* dY  - a list of elements of type 'indexed(posint)' typically representing derivatives in jetnumbers notation
* Y   - a list of names, typically the names of the unknown functions defining the jet space

Description: SortDerivatives returns the list dY after sorting it, ascending with respect to differential order (number of indexes); if two derivatives are of the same order then sort and according to the order in the list Y, and if both derivatives are related to the same name in Y then sort according to the order of independent variables (for jet numbers that is equivalent to sort by `<`).

Example

> PDEtools:-Library:-SortDerivatives([v[2,2,3], u[1,2], v[1,2,3], v[1,1], v[]], [u, v]);

           [v[], u[1, 2], v[1, 1], v[1, 2, 3], v[2, 2, 3]]

Specialize_Cn(sol,(excluded::{list(And(symbol,suffixed(_C,nonnegint))), set(And(symbol,suffixed(_C,nonnegint)))} := {}),{(allowzero::truefalse := false)})

Parameters

* sol      - an algebraic expression or equation, or a set or list of them, typically representing the solution of a differential equation system containing arbitrary constants _Cn introduced by dsolve
* excluded - a set of _Cn constants to be excluded from the specialization process
* allowzero  - optional, can be true or false (default), to 'specialize' a _Cn even if, in doing so, it cancels the terms that contain other _Cn constants

Description: Specialize_Cn returns a list of objects obtained specializing the _Cn not found in excluded, making all of them but one equal to zero, and the remaining one equal to 1. In addition, all _Cn that, when substituted by zero, produce division by zero, are also specialized to 1.

Example

> sol := u(x,t) = (x/_C1 + _C2 + _C3*(x + _C4)):

> PDEtools:-Library:-Specialize_Cn(sol);

                 u(x, t) = 2 x + 1, u(x, t) = 2 x + 1

> PDEtools:-Library:-Specialize_Cn(sol, allowzero);

             u(x, t) = x + 1, u(x, t) = 2 x, u(x, t) = x

Specialize_Fn(sol,(excluded::{list(And(symbol,suffixed(_F,nonnegint))), set(And(symbol,suffixed(_F,nonnegint)))} := {}),{(allowzero::truefalse := false), (specializations::{list(procedure), set(procedure), identical("not given")} := "not given")})

Parameters

* sol      - an algebraic expression or equation, or a set or list of them, typically representing the solution of a differential equation system containing arbitrary functions _Fn(...) introduced by pdsolve
* excluded - a set of arbitrary functions _Fn to be excluded from the specialization process
* allowzero  - optional, can be true or false (default), to 'specialize' a _Cn even if, in doing so, it cancels the terms that contain other _Cn constants

Description: Specialize_Fn returns a list of objects obtained specializing the _Fn(...) not found in excluded, making all of them but one equal to zero, and the remaining one equal to each of its arguments.

Example

> sol := u(x,t) = (x/_F1(x) + _C2 + _F3(x*t + _C4)):

> PDEtools:-Library:-Specialize_Fn(sol);

         u(x, t) = x + _C2 + 1, u(x, t) = x + _C2 + x t + _C4

> PDEtools:-Library:-Specialize_Cn(sol, allowzero);

               x                                x
   u(x, t) = ------ + 1 + _F3(x t), u(x, t) = ------ + _F3(x t + 1)
             _F1(x)                           _F1(x)

ToSameVariables(SYS,(F := GetDepVars("not given",SYS,'onlydifferentiatedfunctions = false')),(X := GetIndepVars(F)),{(converttodiff::truefalse := false), (includingzeroderivatives::truefalse := true)})

Parameters

* SYS - an algebraic object or equation, or a set or list of them
* F   - optional - a list of unknown functions defining the jet space, if not given they are derived from SYS
* X   - optional - a list of independent variables, if not given it is derived from F
* includingzeroderivatives  - optional, can be true (default) or false, to include, in the second list in the output, the derivatives that are equal to zero, that are a consequence of having augmented the functionality of some of the functions of F
* converttodiff             - optional, can be true or false (default), to convert SYS to diff notation before proceeding

Description: ToSameVariables returns a sequence of three objects: SYS rewritten with all its functions depending on the same variables, then a list with the extra derivatives equal to zero implied by the conversion, and next another list of equivalences with the old and new functions respectively in the left and right hand sides.

Example

> PDEtools:-Library:-ToSameVariables(u(x)+v(t),[u(x), v(t)],[x, t]);

                      d           d
  u(x, t) + v(x, t), [-- u(x, t), -- v(x, t)],
                      dt          dx

        [u(x) = u(x, t), v(t) = v(x, t)]

> PDEtools:-Library:-ToSameVariables(u(x)+v(t),[u(x), v(t)],[x, t], includingzeroderivatives = false);

       u(x, t) + v(x, t), [], [u(x) = u(x, t), v(t) = v(x, t)]

UpperBounds(PDESYS,F,(X::list(name) := GetIndepVars(F)),{(increasefornonautonomous::truefalse := true)})

Parameters

* PDESYS  - a PDE system; it can contain PDEs, ODEs, and also non-differential equations
* F       - a list of the unknown functions of PDESYS
* increasefornonautonomous  - optional, can be true (default) or false, to increase the upper bounds by 1 in the presence of nonautonomous equations in PDESYS

Description: UpperBounds returns a sequence of sets of equations, where the lhs is a function of F and the rhs is an upper bound for the degree of a solution polynomial in the independent variables.

Example

> sys := diff(f(x,y),x)*diff(g(y),y) + diff(f(x,y),y)*diff(g(y),y) + f(x,y)*(diff(f(x,y),x,x) + diff(f(x,y),y,y)) = x*y:

> PDEtools:-Library:-UpperBounds(sys, [f(x,y), g(y)]);

                       {f(x, y) = 3, g(y) = 2}

> PDEtools:-Library:-UpperBounds(sys, [f(x,y), g(y)], increasefornonautonomous = false);

                       {f(x, y) = 2, g(y) = 1}

YBracketsToY(ans,Y)

Parameters

* ans  - an algebraic expression, equation, or a set or list of them
* Y    - a list with the names, typically the names of the unknown functions definining a jet space

Description: YBracketsToY returns ans after replacing objects of the form y[] by y, where y is a member of Y.

Example

> PDEtools:-Library:-YBracketsToY(f[]*g[]+f[y]*g[]+f[]*(f[x,x]+f[y,y]), [f, g]);

                 f g + f[y] g + f (f[x, x] + f[y, y])

YToYBrackets(ans,Y)

Parameters

* ans  - an algebraic expression, equation, or a set or list of them
* Y    - a list with the names, typically the names of the unknown functions definining a jet space

Description: YBracketsToY returns ans after replacing objects of the form y by y[], where y is a member of Y.

Example

> PDEtools:-Library:-YToYBrackets(f*g+f[y]*g+f*(f[x,x]+f[y,y]), [f, g]);

             f[] g[] + f[y] g[] + f[] (f[x, x] + f[y, y])