If infolevel is set to a greater integer (possible settings are 1 through 5), more detailed information about the computation method is displayed.

with(DEtools):

with(PDEtools, declare):

declare(y(x), prime=x); # Turn ON the enhanced DEdisplay feature

infolevel[dsolve] := 3;

ode1 := diff(y(x), x)-y(x)^2+y(x)*sin(x)-cos(x);

This ODE is recognized by the system as of Riccati type

odeadvisor(ode1);

and solved accordingly:

dsolve(ode1);

Methods for first order ODEs:
--- Trying classification methods ---
trying a quadrature
trying 1st order linear
trying Bernoulli
trying separable
trying inverse linear
trying homogeneous types:
trying Chini
differential order: 1; looking for linear symmetries
trying exact
Looking for potential symmetries
trying Riccati
trying Riccati sub-methods:
   <- Riccati with symmetry of the form [0, exp(-Int(f,x))/P*(y*P-f)^2] successful

To know more about this type of ODE and related solving methods one can give the extra argument help:

odeadvisor(ode1, help);

A table with all the classifications recognized in Maple is found at odeadvisor, classifications.

A linear ODE

ode_L := sin(x)*diff(y(x), x)-cos(x)*y(x)=0;

Although dsolve has its own strategy and defaults, one can also indicate to dsolve the use of any specific sequence of 'methods' to tackle the ODE. In this example the method for 'linear' ODEs is specified; in addition the optional argument 'useInt' makes dsolve not evaluating the integral appearing in the answer

dsolve(ode_L, [linear], useInt);

Classification methods on request
Methods to be used are: [linear]
----------------------------
* Tackling ODE using method: linear
--- Trying classification methods ---
trying 1st order linear
<- 1st order linear successful

Solutions like this one - before evaluating integrals - are useful to understand how the solution was obtained; integrals can be evaluated afterwards using value

value((7));

This particular linear ODE is also separable, hence it can also be solved via

dsolve(ode_L, [separable], useInt);

Classification methods on request
Methods to be used are: [separable]
----------------------------
* Tackling ODE using method: separable
--- Trying classification methods ---
trying separable
<- separable successful

value((9));

The linear first order ODE of the previous section can be solved by first determining an integrating factor for it

mu := intfactor(ode_L);

Integrating factors turn ODEs exact, that is: the product  times the ODE is a total derivative. One can combine the determination of an integrating factor with indicating to dsolve the use of the method for exact ODEs:

dsolve(mu * ode_L, [exact]);

Classification methods on request
Methods to be used are: [exact]
----------------------------
* Tackling ODE using method: exact
--- Trying classification methods ---
trying exact
<- exact successful

simplify(convert((12), sincos));

For linear ODEs (LODEs) of order 2 or greater, it is possible to calculate integrating factors by solving the adjoint of the LODE. This could be as difficult as the original problem, or much easier, depending on the example. The set of DEtools available permits a discussion of such a strategy in details.

ode := diff(y(x), x, x) =
(y(x)*x+y(x)*ln(x)*x^2+diff(y(x), x)*ln(x)*x^2)/ln(x)/x^2*exp(x)-
y(x)/ln(x)/x^2;

This ODE has the following adjoint

DEtools[adjoint](ode, y(x));

This adjoint equation is in turn solvable by dsolve

dsolve((15));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
   <- BRANCH 2 successful. Symmetry is:, [0, exp(Int(1/x/ln(x),x))]
<- linear_1 successful

Now the solutions to the adjoint equation are integrating factors of the original LODE, so the two independent solutions implied in the general solution above

eval(rhs((16)), {_C1=0, _C2=1});

eval(rhs((16)), {_C1=1, _C2=2});

are integrating factors of ode. These integrating factors could also be found using the intfactor directly

Mu := intfactor(ode);

trying a symmetry of the form [xi=0, eta=F(x)]<- linear_1 successful
Trying an integrating factor as the solution to the adjoint linear ODE
trying a symmetry of the form [xi=0, eta=F(x)]
<- linear_1 successful

How are these integrating factors transformed into a solution to the original problem? By using them to construct two first integrals; that is: two ODEs of lower order (in this case two first order ODEs). For that purpose it is provided the firint command which receives an exact ODE and returns a first integral. The idea is simple: an exact ODE is a total derivative - say dR/dx; firint returns the R + _C1:

firint(Mu[1]*ode);

firint(Mu[2]*ode);

Eliminating y' from these two first integrals (and replacing _C1 by _C2 in one of them) leads to the solution  to this ode. So all this process could be ran interactively, as shown, or in one step

dsolve(ode);

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
   -> Tackling the "Normal Form" of the given linear ODE:
      trying a symmetry of the form [xi=0, eta=F(x)]
   -> Tackling the linear ODE using alternative approaches:
      trying 2nd order exact linear
      trying symmetries linear in x and y(x)
      trying to convert to a linear ODE with constant coefficients
         testing BRANCH 1 ->
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
   -> Tackling the "Normal Form" of the given linear ODE:
      trying a symmetry of the form [xi=0, eta=F(x)]
   -> Tackling the linear ODE using alternative approaches:
      trying 2nd order exact linear
      trying symmetries linear in x and y(x)
      trying to convert to a linear ODE with constant coefficients
         testing BRANCH 1 ->
<- unable to find a useful change of variables
-> Tackling the "Normal Form" of the given linear ODE:
   trying a symmetry of the form [xi=0, eta=F(x)]
-> Tackling the linear ODE using alternative approaches:
   trying 2nd order exact linear
   trying symmetries linear in x and y(x)
   trying to convert to a linear ODE with constant coefficients
      testing BRANCH 1 ->
   trying 2nd order, integrating factor of the form mu(x,y)
   <- 2nd order, integrating factors of the form mu(x,y) successful

There are algorithms in dsolve for determining integrating factors for nonlinear ODEs too:

for second order ODEs, integrating factors depending on two variables (x, y) or (x, y') or (y, y') - when they exist - can be systematically determined;

for third order ODEs, integrating factors depending only on (y'') can also be systematically determined.

For this ODE, three integrating factors are

The product of any of them times the ode is a total derivative, from where a first integral can be obtained; for instance taking the third one

Solving for y'' this reduced ODE,

we are able to calculate more integrating factors (in this case intfactor succeeds again):

and obtain a lower order first integral as in the previous step

Finally, this is a simple first order ODE which can be solved directly, leading to the general solution for the original ode problem:

where in above we map the odetest command over each of the solutions. As a general comment, the integration constants entering the general solution of an ODE are arbitrary, we can always rename , simplifying a bit the solution. This ode here solved using the integrating factor approach can also be solved using the symmetry approach (following the steps shown in the next section).

Also interesting in the integrating factor approach is the inverse problem; that is: to determine the most general ODE family having a given integrating factor (related worked examples are found in redode).

The following worked example aims at illustrating how the solving process can be performed step-by-step, using the symmetry approach, and with instructions easy to re-use. The commands to be used are: symgen (for calculating the symmetries), reduce_order (for reducing the order using these symmetries), and buildsol (to build the solution to the original problem from the solutions to the reduced ODE problems)

This is a fifth order ODE (from Kamke's book, high order ODE example 17):

ode5 := 9*diff(y(x), x, x)^2*diff(y(x), x, x, x, x, x)
- 45*diff(y(x), x, x)*diff(y(x), x, x, x)*diff(y(x), x, x, x, x) +
40*diff(y(x), x, x, x)=0;

Classifying using odeadvisor (classifying ODEs is now a menu option available when "right clicking" on the ODE above)

odeadvisor(ode5);

it is apparent that there are various possible departure points to start reducing the ODE order: the ODE is missing the dependent and independent variables, it also has linear symmetries. In connection with all these starting points there are the symmetries:

X5 := symgen(ode5);

The result above means, basically, that dsolve is able to solve the ODE by itself. With the purpose of illustrating the method, these symmetries are used below interactively to solve the ODE. The simplest manner of doing that is: reduce the order of the ODE by one and restart the discussion around this reduced ODE. When this approach is successful, build the solution to the original problem from the solution to the last reduced ODE. The steps below can be re-used with others ODE examples, as for instance the one solved interactively in the previous section by using integrating factors.

So we start reducing the order using just one of the symmetries above

OFF;    # Turn OFF the enhanced DEdisplay feature

R_5_to_4 := reduce_order(ode5, X5[1], u(t));

The structure of the solution above contains the answer in terms of a new function, u(t), which satisfy the fourth order differential equation being shown.

Now select this fourth order ODE and consider the same cycle again (finding symmetries plus reducing its order again):

ode4 := op([2, 2, 1, 1], R_5_to_4);

X4 := symgen(ode4);

With the symmetries of ode4 in hands we can proceed in the same way to obtain a reduction of order from 4 to 3, now expressing the third order differential equation in terms of a new function s(r)

R_4_to_3 := reduce_order(ode4, X4[1], s(r));

Selecting the third order ODE and calculating its symmetries leads to

ode3 := op([2, 2, 1, 1], R_4_to_3);

X3 := symgen(ode3);

These symmetries can be used to reduced the order further, obtaining a second order ODE - we choose z(v) as new unknown function:

R_3_to_2 := reduce_order(ode3, X3[1], z(v));

ode2 := op([2, 2, 1, 1], R_3_to_2);

One more cycle reduce the problem to a first order linear ODE which is a problem having solution in the general case in terms of integrals

X2 := symgen(ode2);

R_2_to_1 := reduce_order(ode2, X2[1], a(b));

ode1 := op([2, 2, 1, 1], R_2_to_1);

The answer to this easy ODE found at the end of the reduction process is

sol1 := dsolve(ode1);

Now, how could we build the solution to the original fifth order ode5? As follows: first use this solution above to build the solution to ode2 (the second order ODE one step above and rename integration constants which appeared as _C1 in all reductions):

buildsol(subs(_C1=_C2, R_2_to_1), sol1);

The integral can be evaluated via

sol2 := value((47));

And now repeat the process until arriving at the solution to the original fifth order ode

sol3 := buildsol(subs(_C1=_C3, R_3_to_2), sol2);

sol4 := buildsol(subs(_C1=_C4, R_4_to_3), sol3);

sol5 := buildsol(subs(_C1=_C5, R_5_to_4), sol4);

This result can be tested using odetest

odetest(sol5, ode5);

For more examples see dsolve, Lie, , reduce_order and the help pages linked from DEtools, Lie.

Also interesting in the symmetry approach is the inverse problem; that is: to determine the most general ODE family having given symmetries (see equinv), or the symmetries of an 'unknown' ODE when its solution is given (see buildsym). Combining these two tools it is possible to depart from the form of the solution and arrive at the most general ODE problem having the symmetries of that type of solution (examples are found in the mentioned help-pages).