Rachunek różniczkowy (algebra różniczkowa)

W programach komputerowych takich jak Mathematica pochodne traktuje się inaczej niż ma to miejsce w analizie matematycznej lub fizyce. Pochodna jest pewną operacją, która przekształca jeden wzór matematyczny w drugi (lub przekształca funkcję w inną funkcję - operacje te nie są tożsame o czym była mowa na poprzednim wykładzie). Dzięki takiemu podejściu można zalgorytmizować zarówno różniczkowanie, jak i operację odwrotną: całkowanie. Pojęcie pochodnej w tym języku jest tożsame z tym znanym z analizy i fizyki, ale nie wymaga wprowadzenia pojęcia granicy.

Pochodne wyrażeń (,,funkcji’’) elementarnych

Pierwsze pochodne najprostszych wyrażeń

Poleceniem służącym do różniczkowania wzorów matematyczych jest D. Jego składnia jest bardzo prosta: 
pierwszy argument - to co  chcemy zróżniczkować
drugi argument      - po czym będziemy różniczkować.

Np: aby zróżniczkować (x^2) po x:

D[x^2,x]

Aby zróżniczkować Sin[ω t] po ,,czasie’’ t:

D[Sin[ω t],t]

Zwracam na uwagę na częsty błąd:

D[Sin[ωt],t] (* ŹLE !!! *)

Z matematycznego punktu widzenia, wyrażenie powyżej nie zawiera symbolu t, natomiast zawiera symbol dwuliterowy ωt. Pomyłka polega na braku znaku mnożenia pomiędzy ω a t, czego można łatwo uniknąć jawnie wpisując go jawnie:

D[Sin[ω*t],t]

Szkolny wzór na pochodną (x^n):

D[x^n,x]

D[Exp[x],x]

D[2^n,x]

D[2^x,x]

D[1/x,x]

D[Sqrt[x],x]

D[x^(1/2),x]

D[Log[x],x]

D[ArcTan[x],x]

Polecenie D nie upraszcza wyrażeń:

D[(x^2+1)/(x^2-1),x]

Simplify[%]

Tabela pochodnych x do potęgi całkowitej:

Table[(Superscript["x",n])'==D[x^n,x],{n,-3,5}]//TableForm

D[x^Pi,x]

D[0,x]

D[Log[1-Sqrt[1+x]],x]

Przykład funkcji nieróżniczkowalnej: wartość bezwzględna

Przy ręcznym całkowaniu studenci masowo produkują wyrażenia zawierające logarytm naturalny |x|. Mathematica traktuje |x| jako wyrażenie niemożliwe do zróżniczkowania:

D[Log[Abs[x]],x]

Wzór powyżej zawiera symbol Abs’ , co jest wyrazem faktu, iż pochodna funkcji Abs nie została zdefiniowana. Nie można więc np: obliczyć jej wartości czy narysować wykresu:

Abs'

Abs'[1]

Refine[%,x>0]

N[%]

Jak zwykle, to na nas spoczywa kontrola nad sensownością używanych wyrażeń. Formalnie możemy podobnie jak Abs zróżniczkować, powiedzmy, okrąg o promieniu r:

D[Circle[{0,0},r],r]

Mathematica nie wyświetla żadnych błędów, chociaż różniczkowanie w powyższym przykładzie jest absurdem.

Druga pochodna i pochodne wyższych rzędów

Poniżej trzy sposoby obliczania drugich pochodnych:

D[Sin[x],x,x] (* pochodna po x, i jeszcze raz po x *)

D[D[Sin[x],x],x] (* pochodna z pochodnej *)

D[Sin[x],{x,2}] (* druga pochodna *)

Obliczenie n-tej pochodnej można zapisać również jako składanie operatora obliczającego wyrażenie pochodne (mam nadziej, że po ostatnim wykładzie poniższa składnia jest jasna):

Nest[D[#,x]&,Sin[x],2]

N-ta pochodna wielomianu i wyższe są równe zeru:

NestList[D[#,x]&,x^8,16]

To samo z uzyciem Table:

Table[
D[x^8,{x,n}],{n,0,16}] (* tabela n-tych pochodnych x^8 od n=0 do n=16 *)

W odróżnieniu od wielomianów, funkcje wymierne w wyniku różniczkowania mogą być coraz bardziej skomplikowane:

NestList[D[#,x]&,(x^2+1)/(1-x^2),16]//Simplify

Różniczkowanie hiperpotęg prowadzi do bardzo długich wyrażeń:

D[x^x,{x,6}]

Simplify[%]

Integrate[%,x]

Wyższe pochodne f. tryg. powtarzają się cyklicznie:

Table[D[Cos[x],{x,n}],{n,0,12}]

N-ta pochodna Exp[λ t] po ,,czasie’’ t jest równoważna mnożeniu przez (λ^n):

Table[D[Exp[λ t],{t,n}],{n,0,12}]

%/Exp[λ t]

Przykład: znajdź wzór na n-tą pochodną 1/(1+x)

Próby znalezienia wzoru ogólnego na n-tą pochodną prowadzą do bezsensownych wyrażeń:

D[Exp[x],{x,n}]

D[Sin[x],{x,n}]

D[Sin[x],{x,4n}]

FullSimplify[%,n∈Integers&&n>0]

Ale możemy wyliczyć n=tą pochodną dla każdego n:

Table[D[1/(1+x),{x,n}],{n,1,23}]

Widać jasno, że n-ta pochodna składa się z czynnika 1/(1+x)^(n+1) oraz pewnej liczby w mianowniku. Polecenie Numerator wybierze same liczniki:

Numerator[%]

Dla jednych wzór na powyższe liczby jest oczywisty, dla innych nie. Mathematica pozwala na podjęcie próby ,,odgadnięcia’’ wzoru:

FindSequenceFunction[%,n]

Upraszczamy znaleziony wzór zakładając, że n jest liczbą całkowitą i większą od 1:

FullSimplify[%,n∈Integers&&n>1]

Okazało się, że liczba w liczniku to (-1)^n n! Otrzymujemy więc wzór:

wzor=D[1/(1+x),{x,n}]==(-1)^n n!/(1+x)^(n+1)

wzor/.n->12

Table[wzor,{n,1,12}]

wzor/.n->10^3

Prawdziwość wzory dla nawet kilkudziesięciu tysięcy wartości n nie jest dowodem. Można to zrobić, np: inducyjnie. Znajomość wzoru ogólnego pozwala np: przyspieszyć uzyskanie wyniku 500 razy:

D[1/(1+x),{x,2^16}];//Timing

(-1)^n n!/(1+x)^(n+1)/.n->2^16;//Timing

%%/%

Szkolne wzory na różniczkowanie funkcji

Reguły różniczkowania

Mathematica pozwala także na operowanie pochodnymi abstrakcyjnych funkcji. Poniżej szkolne reguły różniczkowania:

Pochodna sumy funkcji jest sumą pochodnych:

D[f[x]+g[x],x]

W wyniku pojawil się symbol f’ (f prim), oznaczający pochodną funkcji  f. Więcej szczegółów na ten temat dalej. Pochodna funkcji mnożonej przez stałą to stała razy pochodna funkcji:

D[ a f[x],x]

Pochodna iloczynu funkcji:

D[f[x]*g[x],x]

Wzór na pochodną ilorazu:

D[f[x]/g[x],x]

W szkolnej wersji jest zwykle sprowadzony do wspólnego mianownika:

Together[%]

Wzór na pochodną funkcji złożonej, przy wykorzystani 3 różnych zapisów składania funkcji:

D[f[g[x]],x]

D[f@g@x,x]

D[x//g//f,x]

Wzór na pochodną wyrażenia hiperpotęgowego:

D[f[x]^g[x],x]

Można uzyskać także bardziej egzotyczne wzory:

D[f[g[x]/h[x]+h[x]^f[x]],x]

D[1/(1/f[x]+1/g[x]),x]//Simplify

D[f[x]/g[x]+g[x]/f[x],x]//Simplify

Różniczkowanie funkcji vs różniczkowanie wyrażeń

Stosowanie poleceń D i Derivative

Wzory matematyczne różniczkujemy poleceniem D:

D[Sin[x],x]

Jeżeli zastosujemy polecenie D do nieznanej funkcji, otrzymamy funkcję ,,primowaną’’:

D[f[x],x]

Podobne zachowanie spotkaliśmy wcześniej przy nieróżniczkowalnej funkcji Abs:

D[Abs[x],x]

Jeżeli przyglądniemy się dokładniej notacji z ,,primem’’, okazuje się, iż jest to skrócona notacja polecenia Derivative (ang: pochodna):

f'[x]//FullForm

Polecenie Derivative jest operatorem różniczkowym, zamieniającym funkcję w funkcję, np:

Derivative[1][Sin]

lub to samo w zapisie skróconym:

Sin'

W wyniku dostajemy funkcję szkieletową (czystą). Aby otrzymać jej wzór, należy podziałać funkcją na argument np: x:

Sin'[x]

Zwracam uwagę, że poniższa notacja (stosowana bezkrytycznie na tablicy lub kartce), jest zupełnie bezsensowna, gdyż usiłujemy operator Derivative zastosować do wzoru matematycznego:

Sin[x]' (* ŹLE ! *)

D[ Sin,x] (* ŹLE, bezsensowna notacja *)

Poniższe wyrażenia są poprawne:

D[Sin[x],x] (* polecenie różniczkujące wzory matematyczne ( D ) zastosowane do wzoru matematycznego ( Sin[x] *)

Sin'[x] (* operator różniczkowy ( ' ) zastosowany do funkcji ( Sin ), a funkcja pochodna ( Sin' ) zastosowana do argumentu x *)

Polecenie Derivative[n] jest operatorem n-tej pochodnej:

Derivative[4][Sin]

f[x_]:=x+1/x

f'

Pochodną funkcji stałej jest funkcja zwracająca dla dowolnego argumentu zero:

(1&)'

Obliczanie pochodnej w punkcie

Przykład 1: Oblicz n-tą pochodną sinusa w punkcie x=Pi

Dobrym treningiem jest obliczanie pochodnych w punkcie. Powiedzmy, że interesuje nas n-ta pochodna funkcji Sin w punkcie
x=Pi. Możemy najpierw zróżniczkować wyrażenie Sin[x], a potem podstawić do wyniku x->Pi:

Table[D[Sin[x],{x,n}],{n,0,8}]

%/.x->Pi

Albo poleceniem Derivative podziałać na funkcję Sin, otrzymując funkcję pochodną, do której wstawiamy argument Pi:

Table[Derivative[n][Sin][Pi],{n,0,8}]

Zadziwiająco częsty jest poniższy błąd, wynikający z niezrozumienia tematu:

D[Sin[Pi],x] (* ŹLE, to NIE JEST pochodna Sin[x] w punkcie x=Pi !!!! *)

D[Sin[x],x]/.x->Pi (* DOBRZE *)

Sin'[Pi] (* DOBRZE *)

Przykład 2: Oblicz z definicji pochodną w punkcie x=x0 dla funkcji cos, ln, 1/(1+x), ...

W analizie matematycznej i  pochodną w punkcie x0 definiujemy jako granicę:

pochodnaDef=Limit[(f[x0+Δx]-f[x0])/Δx,Δx->0]

Podstawmy do tej definicji funkcję

pochodnaDef/.f->Cos

Sprawdzimy wzór za pomocą reguł różniczkowania:

f'[x0]/.f->Cos

{pochodnaDef,f'[x0]}/.f->Log

{pochodnaDef,f'[x0]}/.f->(1/(1+#)&)

Przykład 3: Narysuj prostą styczną do wykresu funkcji w pewnym punkcie

Plot[{Cos[x],Cos'[1](x-1)+Cos[1]},{x,-2Pi,2Pi}]

Manipulate[Plot[{Cos[x],Cos'[x0](x-x0)+Cos[x0]},{x,-2Pi,2Pi},PlotRange->{-2,2}],{x0,-Pi,Pi,0.01}]

Manipulate[Plot[{f[x],f'[x0](x-x0)+f[x0]},{x,-2Pi,2Pi},PlotRange->{-2,2}],{{x0,1},-Pi,Pi,0.01},{f,{Sin,Cos,Tan,#^2&,1/#&,Log,#^#&}}]

Przykład 4: Oblicz pochodne funkcji Exp[-1/x] dla x=0

Definiujemy funkcję:

f=Exp[-1/#]&

Próbujemy obliczyć wartość pierwszej pochodnej w zerze:

f'[0]

Okazało się, że w wyniku otrzymaliśmy symbol nieoznaczony Indeterminate. Wynika on z próby wykonania operacji 0/0:

f'[x]

Możemy obliczyć granicę (przypominam, że jest to granica prawostronna!):

Limit[f'[x],x->0]

Limit[f'[x],x->0,Direction->1] (* tak należałoby obl. granicę lewostronną (od liczb ujemnych) *)

Limit[f'''[x],x->0]

Możemy obliczyć n-tą pochodną:

Table[Limit[Derivative[n][f][x],x->0],{n,1,12}]

Jest to ciekawy przykład funkcji o wszystkich pochodnych równych zeru. Jeżeli rozszerzymy ją do x<=0 funkcją zerową, to otrzymamy funkcję nieskończenie wiele razy różniczkowalną w zerze, ale nieanalityczną (szereg potęgowy składałby się z samych zer).

Plot[f[x],{x,0,1/3}]

Szeregi Maclaurina i Taylora

Jednym z podstawowych zadań w których potrzebujemy automatycznego obliczania pochodnych w punkcie jest rozwijanie funkcji w szeregi potęgowe. Najprostszym z nich jest szereg Maclaurina.

Przykład 1: Rozwiń Sin[x] w szereg Maclaurina i porównaj wykres rozwinięcia z oryginalem

Najszybszym sposobem obliczenia szeregu Maclaurina w programie Mathematica jest użycie polecenia Series (ang. szereg ):

szereg=Series[Sin[x],{x,0,15}]

Powyższe polecenie na dwa argumenty. Pierwszy to wzór matematyczny który chcemy rozwinąć w szereg. Drugi argument to lista zawierająca opis rozwinięcia:
pierwszy element listy ( x ) - zmienna względem której rozwijamy w szereg (po niej różniczkujemy)
drugi element listy ( 0 ) - punkt w którym liczymy pochodne (współczynniki rozwinięcia); dla szeregu Maclaurina jest to zero
trzeci element listy ( 15 ) - najwyższa potęga, która ma pojawić się w rozwinięciu (najwyższa liczona pochodna)

Oprócz rozwinięcia w wyniku produkowanym przez Series znajduje się także symbol O (O duże). Symbol ten oznacza, mówiąc w uproszczeniu, wielkość infinitezymalnie małą.

?O

Aby się go pozbyć używamy polecenia Normal:

sinus=Normal[szereg]

Plot[{Sin[x],sinus},{x,-2Pi,2Pi}]

sinusek[x_,n_]:=Normal@Series[Sin[t],{t,0,n}]/.t->x

sinusek[x,3]

Manipulate[Plot[{Sin[x],Evaluate[sinusek[x,n]]},{x,-2Pi,2Pi},PlotRange->{-3/2,3/2}],{n,0,32,1}]

Przyklad 2: Rozwiń dowolne wyrażenie f[x] w szereg Maclaurina, a następnie podstaw zamiast f wybrane funkcje, np: Sin, Log itp.

maclaurin1=f[0]+f'[0] x^1 /1! + f''[0] x^2/2!+f'''[0]x^3/3!

maclaurin1/.f->Sin

maclaurin2=Sum[Derivative[n][f][0]*x^n/n!,{n,0,5}]

maclaurin3=Series[f[x],{x,0,6}]

maclaurin2/.f->Sin

Series[Sqrt[x],{x,0,3}]

maclaurin2/.f->Sqrt

maclaurin2/.f->(Sqrt[1+#]&)

maclaurin2/.f->(Sqrt[1+#^2]&)

Oblicz (∑_(n=0)^∞)(((((-1))^n) (x^(2 n+1)))/((2 n+1)!))

W wielu przypadkach sumy jak w treści zadania można po prostu obliczyć poleceniem Sum:

Sum[x^n/n!,{n,0,Infinity}]

Sum[x^n/n!^2,{n,0,Infinity}]

Sum[x^(2n)/n!,{n,0,Infinity}]

Można w niektórych przypadkach posłużyć się następującą metodą. Najpierw obliczamy pewną skończoną ilość wyrazów:

Sum[((-1)^n*x^(2*n + 1))/(2*n + 1)!, {n, 0, 12}]

Interesują nas tylko współczynniki przy kolejnych potęgach, które możemy wydobyć poleceniem CoefficientList (ang: lista współczynników ):

CoefficientList[%,x]

Polecenie FindGeneratingFunction spróbuje znaleźć funkcję, w której rozwinięciu pojawiaja się powyższe współczynniki:

FindGeneratingFunction[%,x]

Okazało się, że jest to funkcja Sin. Ten przykład także jest rozwiązywalny dla polecenia Sum:

Sum[(-1)^n x^(2*n + 1)/(2*n + 1)!, {n, 0, Infinity}]

Spróbuj rozwinąć w szereg Maclaurina √x, (x^x) lub Exp[-1/x]

Nie wszystkie funkcje są rozwijalne w szereg. Dla wyrażenia (x^x) otrzymujemy:

Series[x^x,{x,0,5}]

Powyższe wyrażenie NIE JEST szeregiem potęgowym. Jest to tzw. szereg uogólniony. Szereg Maclaurina nie istnieje:

maclaurin2/.f->(#^#&)

Aby zrozumieć powyższe zachowanie, obliczmy pochodne wzoru x^x:

Table[D[x^x,{x,n}],{n,0,6}]//Simplify

Następnie obliczamy granicę, do której dążą pochodne:

Limit[%,x->0]

Okazało się, że wszystkie pochodne x^x w zerze dążą do nieskończoności. Podobnie jest dla pierwiastka:

Series[Sqrt[x],{x,0,4}]

Poniżej inny patologiczny przykład. Tym razem wszystkie pochodne są równe zeru.

Series[Exp[-1/x],{x,0,3}]

maclaurin2 /. f->(Exp[-1/#]&)

Table[D[Exp[-1/x],{x,n}],{n,0,7}]

Limit[%,x->0]

Rachunki z użyciem symbolu O[x] (wielkości infinitezymalnie małe)

Series[Exp[x],{x,0,2}]

Sqrt[%]

Series[Sin[x],{x,0,3}]^2

Series[Sin[x]^2,{x,0,3}]

%+O[x]

O[x]^2+O[x]^4

r=1+x+O[x]^2

r^2

Sqrt[r]

(r+x)/(r-x)

4/3 Pi (R+dR + O[dR]^2)^3 - 4/3 Pi R^3

Funkcje odwrotne

Mathematica pozwala w dosyć sensowny sposób operować funkcjami odwrotnymi. Podstawowe polecenie to InverseFunction (ang: funkcja odwrotna):

InverseFunction[f]

Podstawowa definicja f. odwrotnej mówi, że złożona z oryginalem daje identyczność:

Composition[f,InverseFunction[f]][x]

f@InverseFunction[f]

%@x

InverseFunction[f][f[x]]

Wiele f. odwrotnych jest obliczana automatycznie:

InverseFunction[Sin]

W przypadku funkcji które nie są różnowartościowe, InverseFunction  zwraca tylko jedną, losowo wybraną, gałąź:

InverseFunction[#^2&]

Jak widać wyżej, nie jest to gałąź, której oczekiwaliśmy...Można sobie z tym poradzić zawężając dziedzinę:

InverseFunction[ConditionalExpression[#^2,#>0]&]

Więcej przykładów:

InverseFunction[#&]

InverseFunction[1/#&]

InverseFunction[Exp]

InverseFunction[#^#&]

InverseFunction[Exp[-#^2]&]

Funkcją odwrotną do wielomianu jest w ogólności Root:

InverseFunction[#^5+#+3&]

Funkcją odwrotną można się posługiwać nawet, gdy jej wzór nie istnieje:

inv=InverseFunction[Cos[#]-#&]

inv[Pi]

N[%]

Czasem udaje się nawet uzyskać ścisły symboliczne wynik:

inv[1]

Możemy taką funkcję rysować:

Plot[inv[x],{x,-4,4}]

Możemy obliczyć pochodną:

inv'[x]

inv'[1]

Próba rozwinięcia w szereg ujawnia niedopracowanie tej funkcji:

Series[inv[x],{x,1,2}]

Błąd programu polega na złym obliczaniu 2 pochodnej f. odwrotnej:

inv''[1]

N[%]

Pochodna funkcji odwrotnej

Przykład 1 : Wyprowadź wzór na pochodną ArcSin oraz Log

Mathematica podaje następujący wzór an pochodną funkcji odwrotnej InverseFunction[f] :

pochodna=InverseFunction[f]'

Do powyższego wzoru wstawiamy Sin:

pochodna/.f->Sin

%[x]

D[ArcSin[x],x]

Mathematica skuteczniej operuje na wzorach niż na funkcjach:

wzor=pochodna[x]

wzor/.f->Sin

Poniżej wyprowadzenie wzoru na pochodną funkcji Log (logarytm naturalny):

wzor/.f->Exp

D[Log[x],x]

wzor/.f->ArcCos

Simplify[%,Sin[x]>0]

Spróbujmy dokładniej przeanalizować wzór na pochodną funkcji odwrotnej. Niech f=Exp.

(1/(f'[(f^((-1)))[x]]))

Wtedy (f^((-1)))[x]oznacza funkcję odwrotną do Exp czyli Log:  (f^((-1)))[x]=Log[x] ( (f^((-1)))=Log ). Z kolei f’ to pochodna funkcji Exp która, jak wiadomo, przy różniczkowaniu nie zmienia się. Czyli f’=Exp. Wstawiając to do wzory powyżej mamy:

1/Exp[Log[x]]

Przykład 2 : Wyprowadź wzory na n-tą pochodną funkcji odwrotnej dla n<5

Table[
Derivative[n][InverseFunction[f]][x]//Together,
{n,0,4}]

%/.(f^((-1)))[x]->Y

Pochodna całki oznaczonej o zmiennej granicy całkowania

Oblicz pochodną po czasie wyrażenia (∫_(g(t))^(h(t)))f(x)dx oraz wyrażenia (∫_(g(t))^(h(t)))f(x,t)dx

(∫_(g(t))^(h(t)))f(x)\[DifferentialD]x

D[%,t]

(∫_(g(t))^(h(t)))f(x,t)\[DifferentialD]x

D[%,t]

Pochodne cząstkowe

Przykład 1: oblicz wszystkie drugie pochodne cząstkowe wzoru (x^3+y)/(x+y^2)

Pochodne cząstkowe obliczamy poleceniem D:

wzor=(x^3+y)/(x+y^2)

D[wzor,x,x] (* druga pochodna po x *)

Simplify[%]

D[wzor,y,y] (* druga pochodna po y *)

Simplify[%]

D[wzor,x,y] (* druga pochodna mieszana, najpierw po x, potem po y *)

Simplify[%]

Pochodne mieszane powinny dać taki sam wynik:

D[wzor,x,y]==D[wzor,y,x]

Na koniec przykład automatycznego obliczania pochodnych. Definiujemy listę zawierającą wszystkie zmienne:

zmienne={x,y}

Generujemy tablicę drugich pochodnych, po i-tej i j-tej zmiennej:

Table[D[wzor,zmienne[[i]],zmienne[[j]]],{i,1,2},{j,1,2}]//Simplify

TableForm[%]

Przykład 2: oblicz pochodną po t wyrażenia F[ f[t] + g[t]*h[t] ] a następnie sprawdź otrzymany wzór dla kilku wybranych funkcji jednej zmiennej np: F=Exp, f=Sin, g=Log, h=Sqrt itp.

Rozważmy pewne wyrażenie złożone, dla ustalenia uwagi niech będzie to:

F[f[t]+g[t]*h[t]]

Obliczamy jego pochodną po czasie:

wzor=D[F[f[t]+g[t]*h[t]],t]

Otrzymaliśmy wzór wynikający z zastosowania reguły łańcuchowej. Sprawdźmy czy jest poprawny, wstawiając przykładowe konkretne funkcje zamiast F, f, g i h:

funkcje={F->Exp, f->Sin, g->Log, h->Sqrt}

Po wstawieniu funkcji otrzymujemy standardowe zadanie z różniczkowania:

F[f[t]+g[t]*h[t]]/.funkcje

D[%,t]

Ale funkcje te możemy podstawić także do otrzymanego wcześniej wzoru:

wzor/.funkcje

Jak widać obie metody dały ten sam wynik:

%-%%

Pochodne symboliczne, np: wyprowadzenie równań Lagrange-Eulera dla L=1/2 x’[t]^2 - 1/2 x[t]^2

Mathematica liczy pochodne w sensie symbolicznym, względem dowolnego wyrażenia. Poniżej pochodne po wyrażeniach typu f[t]:

D[F[f[t]+g[t]*h[t]],f[t]]

D[F[f[t]+g[t]*h[t]],g[t]]

D[F[f[t]+g[t]*h[t]],h[t]]

Jest to bardzo przydatne przy obliczaniu równań Lagrange-Eulera w mechanice klasycznej. Lagrangian jest wyrażeniem złożonym z funkcji czasu, ich pochodnych po czasie, oraz innych zmiennych. Np: dla oscylatora harmonicznego ma on postać:

L=1/2x'[t]^2-1/2 k x[t]^2

Równania L-E mają postać pochodnych po x’[t] oraz x[t], przy czym w notacji tradycyjnej pochodne po czasie oznaczamy kropką, a argument t pomija się. Równania mają postać

D[ D[L,x'[t]], t]==D[L,x[t]]

Clear[L]

Na przykładzie abstrakcyjnego Lagrangianu możemy zobaczyć jak wygląda operator Derivative dla funkcji wielu zmiennych:

lagrangian=L[t,x[t],x'[t]]

D[D[lagrangian,x'[t]],t]==D[lagrangian,x[t]]

Ponieważ L jest pewną funkcją 3 zmiennych, operator pochodnej wskazuje jakiego rzędu jest pochodna względem pierwszego, drugiego i trzeciego.
Np: (L^((0,0,2))) oznacza drugą pochodną po trzecim argumencie, natomiast  (L^((0,1,1))) pochodną mieszaną względem 2 i 3 argumentu.

(*) Zamiana zmiennych w wyrażeniach różniczkowych

Zamiana zmiennej niezależnej: teoria

Bardzo często stajemy przed zadaniem, polegającym na dokonaniu transformacji typu x=ϕ[t] w wyrażeniu zawierajacym zmienne, funkcje i ich pochodne:

G[x,y[x],y'[x],y''[x], ....]

Rachunki dla x, y[x] i y'[x] są trywialne. Zaczynając od wyrażenia y''[x] robią się bardzo długie i nudne. Z powodu fatalnej tradycyjnej notacji często prowadzą do błędów i ,,machania rękami''. Otóż zwykle funkcję przetransformowaną oznacza się identycznym symbolem jak funkcję oryginalną, np:

(dy/dx)=(1/(ϕ'[t]))    (dy/dt)                    (NIEPOPRAWNIE !)

Faktycznie, symbol ,,y'' po lewej i prawej stronie to różne funkcje jednego argumentu ! Papier przyjmie taką notację, Mathematica nigdy. W ogólności, notacja z użyciem ,,nieskończenie małych'' wielkości typu dy, dx, dt itp. nie nadaje się do użycia w Mathematice. Musimy posługiwać się pojęciami formalnymi: funkcji jednej zmiennej i operatora pochodnej działającego na funkcje.  Poprawnie napiszemy więc:
y'[x]=(1/(ϕ'[t]))    Y'[t]           (DOBRZE !)
gdzie:
x=ϕ[t], czyli t=(ϕ^(-1))[x]
oraz
y[ϕ[ζ]]=Y[ζ], czyli y[η]=Y[(ϕ^(-1))[η]].

Inny formalnie poprawny zapis transformacji pochodnej poprzez zamianę x=ϕ[t] to:
y'[x]=(1/(ϕ'[t]))(y@ϕ)'[t] 
gdzie @ w Mathematice oznacza złożenie funkcji (Composition, @, //). Funkcja Y jest więc złożeniem funkcji y i ϕ:

Y = y@ϕ .


W Mathematice procedura zamiany jest następujące:
a) Używając ReplaceAll, czyli /. ,  podstawiamy x->ϕ[t]
b) podstawiamy następnie za funkcję y-> (Y[InverseFunction[ϕ][#]]&), gdzie Y oznacza złożenie funkcji y@ϕ

Oczywiście aby zamiana zmiennych była możliwa, funkcja musi spełniać pewne założenia, o czym Mathematica ostrzega.

Przykład 1: podręcznikowe wzory na transformację pochodnych

Off[InverseFunction::ifun] (* Polecenia On / Off włączają / wyłączają ostrzeżenia, w tym wypadku o użyciu funkcji odwrotnej *)

y'[x] /. x->ϕ[t] /. y->(Y[InverseFunction[ϕ][#]]&) (* transformacja pierwszej pochodnej *)

y''[x] /. x->ϕ[t] /. y->(Y[InverseFunction[ϕ][#]]&) (* transformacja drugiej pochodnej *)

Factor[%]

D[y[x],{x,3}] /. x->ϕ[t] /. y->(Y[InverseFunction[ϕ][#]]&) (* transformacja trzeciej pochodnej *)

D[y[x],{x,6}] /. x->ϕ[t] /. y->(Y[InverseFunction[ϕ][#]]&) ;(* transformacja wyższych pochodnych *)

FullSimplify[%]

Przykład 2 : w wyrażeniu (równaniu) (x^2) y’’[x] - y[x] zamień zmienną niezależną wg. wzoru x=Exp[t]

eqA=x^2y''[x]-y[x]

eqA /. x->Exp[t]

eqA /. x->Exp[t] /. y->(Y[InverseFunction[Exp][#]]&)

Simplify[%]

PowerExpand[%]