Co je vlastně "řešení problému"?

Rozklad na hierarchicky uspořádané podproblémy, řešení odpodu "probublá" nahoru. 
Tento rozklad je pravděpodobně úloha neřešitelná konečným automatem.
Typickým příkladem takového rozkladu je "slovní úloha".
Klíčové je pochopení pojmu "proměnná" jako základ matematické abstrakce.
Pojem "proměnná" správně chápe 100% programátorů a málo ostatních.
Řešení ve tvaru funkčního programu, který nevyžaduje úpravy a řeší problém automaticky, považujeme za jediné 100% poctivé řešení.
Někdy o rozkladu nevíme  a postup chápeme jako jeden pattern podproblému, např.  vyjádřit proměnnou ze vzorce a dosadit ji do vzorce obsahuje podproblémy typu Solve, ReplaceAll (/.) a Simplify.
Úloha je vlastně téměř vždy zadána fuzzy, např. co vlastně znamená "výraz zjednodušit".
Strojově řešitelné podproblémy bychom měli znát, jinak buď rozklad neuskutečníme vůbec, nebo uskutečníme neoptimálně (doba výpočtu, přesnost, správnost, obecnost řešení a podobně).
Důležitější než znát dokonale konkrétní syntaxe a teorii řešení strojově řešitelných podproblémů je vědět o jejich existenci a hlavních užitečných vlastnostech. Podrobnosti si kdykoli můžete nastudovat.

rce = (((x^2) + a*y)/(y + a*x)) == 
          1;

    vyraz = 3  x - 5  y;

    res = Solve[rce, y]

    vyraz /. res[[1]]

    Simplify[%]

Elementární podproblémy, elementární "slovní úlohy"
* je jich mnoho, například základní operace (vlastně funkce více proměnných)
*Například sčítání

\(\(\(
\)\(\(1 + 1\)\(
\)
    \(1 + a\)\(
\)
    \(a + b\)\(
\)
    \(a + b + c\)\(
\)
    \(Plus[a, b, c, 
      d]\)\(
\)\( (*"Petr má dvě jablka, Uršula tři. Kolik mají jablek dohromady?"*) \)\(
\)
    \( (*Není\ elementární, \ 
      zamlčeně\ předpokládáme\ neexistenci\ společných\ jablek\ *) \)\)\)\)

Úlohy, které již za úlohy i po střední škole považujeme
* je jich mnoho,  úlohy ze středoškolské matematiky včetně geometrie, řad, řešení rovnic rozličných typů a podobně, nerovnic, grafy funkcí nevyžadující diferenciální počet...

Solve[{x + y == 1, x - y == 5}]
Solve[a*(x^2) + b*x + c == 0, x]
<< Algebra`InequalitySolve`
InequalitySolve[x/Abs[x - 1] ≥ 0 && 1/x < x + 1, 
      x]

\(\(\( (*Úlohy\ typu\ "rovnost"*) \)\(
\)\( (*finitně*) \)\(
\)\(Solve[{x + y\^2 == 1, y - x\^2 == 0}] // 
      N
 (*numericky1*) 

    NSolve[{x + y\^6 == 1, y - x\^2 == 0}] // 
      N
 (*numericky2*) 

    FindRoot[
      Cos[x] - x == 0, {x, 0}]


    \)\)\)

Úlohy, které již za úlohy i na vysoké škole  považujeme, jsou řešitelné analyticky a jsme v nich cvičení. Jde vlastně často o převod úlohy na konečné užití speciálních funkcí, nekonečný proces je v nich obsažen. 
* analytické řešení je v jednoduchých případech (LDR, zvláště malých řádů) obecnější a zřetelněji vypovídá   o svých vlastnostech, je vhodnější pro "teoretické" problémy, obvykle je však v reálných úlohách příliš složité či nenalezitelné

DSolve[{y'[t] == -k*y[t], 
        y[0] == y0}, y[t], t]

    DSolve[{y''[t] == ((t^2) - 1)*y[t], 
        y[0] == y0, y'[0] == dy0}, y[t], 
      t]

Úlohy, řešitelné numericky i analyticky a řešitelné pouze numericky
* kdo nerad programuje, se numerickým řešením zpravidla vyhýbá. 
* vyhýbat se jim nemusí, jejich užití je v SW algebraických systémech snadné
* užívat numerické řešení bez alespoň elementární znalosti jejich podstaty může být velmi nebezpečné.

(grafy funkcí  -  
        i zde jsou nebezpečí)

    
\(\(\(Plot[
      1 + 0.01  Sin[x], {x, 0, 
        10}]\)\(
\)\(
\)\( (*interpolace\  - \ když\ známe\ body\ a\ jinak\ nevíme\ nic\ a\ předpokládáme\ mnohé, \ 
      InterpolationOrder\ a\ hladkost\ derivací, \ 
      interpolace\ se\ znalostí\ hodnot\ derivace\ v\ daných\ bodech*) \)\(
\)\( (*proklad\ závislostí\ známého\ tvaru\  - \ definice\ problému, \ 
      příklady\ lineární\ a\ nelineární\ regrese, \ 
      Cases[model, α\__, {0, ∞}]*) \)\(
\)\( (*rešení\ rovnic\ a\ jejich\ soustav, \ 
      lineárních\ a\ nelineárních, \ 
      základní*) \)\(
\)\( (*numerická\ integrace*) \)\(
\)
    \)\)

Plot[1 + 0.01  Sin[x], {x, 0, 10}]
Plot[{1 + 0.01  Sin[x], 0}, {x, 0, 10}]
Plot[{1 + 0.01  Sin[x], 0, 1/x}, {x, 0, 
        10}]

body = 
      Table[{x, x + Random[]}, {x, 10, 20, 1}]

    ListPlot[body, PlotJoined -> True]

int[x_] = Interpolation[body, InterpolationOrder -> 1][
          x];
Plot[int[x], {x, 10, 25}]
Plot[int'[x], {x, 10, 25}, PlotRange -> All]

int[25]

body = 
        Table[{x, x + 60  Random[] + (x^2)}, {x, -10, 20, 
            1}];
pl1 = 
        ListPlot[body, PlotStyle -> {PointSize[0.02], Hue[0.63]}, 
          DisplayFunction -> Identity];
nahr = Fit[body, {1, x, (x^2)}, x]
pl2 = 
        Plot[nahr, {x, -10, 20}, DisplayFunction -> Identity, 
          PlotStyle -> {Thickness[0.008], 
              Hue[0]}];
Show[pl1, pl2, 
      DisplayFunction -> $DisplayFunction]

<< Statistics`NonlinearFit`;
body = 
        Table[{t, 2 + 3*Exp[((-t)/4)] + 0.5  Random[]}, {t, 0, 10, 
            0.125}];
pl1 = 
        ListPlot[body, PlotStyle -> {PointSize[0.02], Hue[0.63]}, 
          DisplayFunction -> Identity];
nahr = 
      NonlinearFit[body, a + b*Exp[((-t)/tau)], 
        t, {a, b, tau}]
pl2 = 
        Plot[nahr, {t, 0, 10}, DisplayFunction -> Identity, 
          PlotStyle -> {Thickness[0.008], 
              Hue[0]}];
Show[pl1, pl2, DisplayFunction -> $DisplayFunction]

<< Statistics`NonlinearFit`;
body = 
        Table[{t, 2 + 3*Exp[((-t)/4)] + 0.5  Random[]}, {t, 0, 10, 
            0.125}];
pl1 = 
        ListPlot[body, PlotStyle -> {PointSize[0.02], Hue[0.63]}, 
          DisplayFunction -> Identity];
v[i_] := (Subscript[α, i]);
model = 
        v[1] + v[2]*Exp[((-t)/v)[3] + v[4]];
\(\(params[model_] := 
        Cases[model, α\__, {0, ∞}];\)\)
params[model]
nahr = 
      NonlinearFit[body, model, t, params[model]]
pl2 = 
        Plot[nahr, {t, 0, 10}, DisplayFunction -> Identity, 
          PlotStyle -> {Thickness[0.008], 
              Hue[0]}];
Show[pl1, pl2, 
      DisplayFunction -> $DisplayFunction]

vyr[x_] = a*(x^2) + b*x + c;
dosabc = Solve[{vyr[x0] == f[x0], 
              vyr[x0 - Δx] == f[x0 - Δx], 
              vyr[x0 + Δx] == 
                f[x0 + Δx]}, {a, b, 
              c}][[1]];
in0 = 
      Integrate[
          vyr[x] /. dosabc, {x, x0 - Δx, 
            x0 + Δx}] // Simplify

n = 333;
struct = 
        Prepend[Append[Table[3 - (((-1))^i), {i, n}], 1], 
          1];
nn = Length[struct];
xmin = -5;
xmax = 5;
fce[x_] := 
        (1/(a*Cosh[(x/a)]^2)) /. a -> 0.1;
Δx = ((xmax - xmin)/(nn - 1));
hodnoty = 
        Table[fce[1.  x], {x, xmin, 
            xmax, Δx}];
int = Δ(x/3)*(struct . hodnoty)

1. *Integrate[fce[x], {x, xmin, xmax}]

pom = (1/(a*Cosh[(x/a)]^2));
Integrate[pom, x];
triala =  .0001;
Plot[pom /. a -> triala, {x, -5, 5}, 
        PlotRange -> All];
NIntegrate[pom /. a -> triala, {x, -5, 5}]

par[
          list_List] := (((Plus @@ ((list^(-1)))))^(-1));
par[{z1, z2, z3}];
ser[list_List] := Plus @@ list;
ser[{z1, z2, z3}];
z1 = par[{r1, I*ω*L}];
z2 = ser[{r4, (1/(I*ω*c1))}];
z3 = par[{z2, r3}];
z4 = ser[{z1, r2}];
prenos[ω_] = 
        (z3/(z3 + z4)) // Simplify;
prenosIdeal[ω_] := 
        0.8 - 0.6*UnitStep[ω - 100];
Plot[{prenosIdeal[ω], 0}, {ω, 0, 300}]

fifbod[ω_] = 
        Abs[Abs[prenos[ω]] - prenosIdeal[ω]];

dilω = 2;
fit = 
        Sum[fifbod[ω], {ω, 0.1, 300, 
            dilω}];
profit = fit /. r1 -> 1000;
hledam = 
        Union[Cases[
            profit, _Symbol, {0, ∞}]];
novhledam = 
        Partition[hledam, 1] /. {a_} -> {a, 0.0001, 1};

res = FindMinimum[profit, novhledam][[2]]

tisk[ω_] = 
        Abs[prenos[ω] /. res] /. 
          r1 -> 1000;
Plot[{prenosIdeal[ω], tisk[ω], 0}, {ω, 0.001, 
        300}]

?NMinimi*

NMinimize[{(x^2) + (((y -  .5))^2), 
        y ≥ 0 && y ≥ x + 1}, {x, y}]

U = 10;
Ri = 5;
NMinimize[{-R*(i^2), U == (Ri + R)*i}, {R, i}]

p11 = 100;
p12 = 500;
p21 = 50;
p22 = 200;
p31 = 100;
p32 = 400;
c1 = 100 + 0.1*P1 + (10^(-3))*(P1^2);
c2 = 
        100 + 0.2*P2 + 0.5*(10^(-3))*(P2^2);
c3 = 200 + 0.05*P3 + 2*(10^(-3))*(P3^2);

tauP = 0.1;
Plot[
      Exp[-(P1 - p11)*tauP] + Exp[(P1 - p12)*tauP], {P1, 0, 600}, 
      PlotRange -> All]

pen3

pen1 = 
        Exp[-(P1 - p11)*tauP] + 
          Exp[(P1 - p12)*tauP];
pen2 = 
        Exp[-(P2 - p21)*tauP] + 
          Exp[(P2 - p22)*tauP];
pen3 = 
        Exp[-(P3 - p31)*tauP] + 
          Exp[(P3 - p32)*tauP];

    
Plot[pen3, {P3, 0, 500}, PlotRange -> All]

Off[FindMinimum::"lstol"];
vahapenale = 1;
Pzad = 1000;
vahavykonu = 1;
fit = 
        c1 + c2 + c3 + vahapenale*(pen1 + pen2 + pen3) + 
          vahavykonu*(((Pzad - P1 - P2 - P3))^2);
FindMinimum[
      fit, {P1, 200}, {P2, 200}, {P3, 200}]
P1 + P2 + P3 /. %[[2]]

Δx = 0.01;
f[x_, y_] = 
        1. *(Cos[y]*Sin[x] + Sin[x]*y);
EulerianStep[{x_, y_}] := {x + Δx, 
          y + f[x, y]*Δx};
start = {0, 1};
NestList[EulerianStep, start, 10000] // ListPlot

?NDSolve

Sin[Pi]

ClearAll[f];
f[x_] := (x^2);
f[2]

ClearAll[f];
f := #(1^2) + #2 &;
f[2, 1]