Introduzione a Mathematica

Gianluca Gorni
Università di Udine, Dipartimento di Matematica e Informatica

8. Disequazioni e logica

Ultima modifica: 14 dicembre 2006

Questo file è concepito principalmente per essere letto interattivamente su schermo. Per questo, e anche per risparmiare spazio, gli output di solito sono omessi. L'utente che legge da schermo li deve rigenerare mandando in esecuzione le celle di input una alla volta.
Qualcuno vorrà stampare per leggere su carta: in tal caso apra i gruppi di celle ed esegua tutte le celle prima di stampare. Le celle si possono eseguire tutte in un sol colpo col menu Kernel>Evaluation>Evaluate Notebook

Inizializzazione

Inizializzazione consigliata:

SetOptions[$FrontEnd, 
        CommonDefaultFormatTypes -> {"Output" -> 
              TraditionalForm}];
$FormatType = TraditionalForm;
Needs["Algebra`InequalitySolve`"];

Il "pacchetto" InequalitySolve

Le disequazioni non sono (ancora) ben integrate e consolildate nel nòcciolo di Mathematica, ma si possono trattarecon qualche cautela caricando "pacchetti" aggiuntivi. Il primo si chiama Algebra`InequalitySolve, documentato su Help>Help Browser>Add-ons>StandardPackages>Algebra>InequalitySolve. Il pacchetto si carica con uno qualsiasi dei due comandi seguenti:

<< Algebra`InequalitySolve`

Needs["Algebra`InequalitySolve`"]

(il carattere ` è alt-096).

Nota: nelle versioni di Mathematica dalla 5.0 in poi la funzionalità di InequalitySolve è incorporata in Reduce.

Le varie virgolette nei due comandi sono importanti. La differenza fra i due comandi è che il primo legge sempre il pacchetto, mentre il secondo lo legge soltanto se non è già caricato. È anche importante caricare i pacchetti prima di usare le funzioni che ci sono definite.
Una volta caricato il pacchetto possiamo risolvere la disequazione x - 1 > 2 - 2  x così:

InequalitySolve[x - 1 > 2 - 2  x,x]

Una disequazione di secondo grado:

InequalitySolve[(x^2) - x ≤ 1,x]

Come si risolve il sistema di disequazioni {({{2  x + (x^2) > -1}, {x < 3}}):

InequalitySolve[{2  x + x^2 > -1, x < 3},x]

Una disequazione senza soluzioni:

InequalitySolve[(x^2) < -1,x]

Una disequazione che è sempre vera:

InequalitySolve[x^2 ≥ 0,x]

Disequazioni non algebriche

InequalitySolve riesce a risolvere alcune semplici disequazioni non algebriche:

InequalitySolve[Log[x] > 0,x]

ma il risultato può essere sbagliato:

InequalitySolve[Sin[x] > 0,x]

Per lo più si astiene:

InequalitySolve[Sin[x] + Log[x] > 0,x]

Nelle versioni di Mathematica dalla 5.0 in poi Reduce sa risolvere fino in fondo anche alcune disequazioni non algebriche.

Combinazioni logiche di disuguaglianze

InequalitySolve accetta non solo sistemi di disequazioni, ma anche combinazioni di disequazioni tramite connettivi logici And, Or, Not:

InequalitySolve[Or[x^2 < 1, x^2 > 4],x]

InequalitySolve[Not[x^2 < 1],x]

Invece di Or[a,b,...] si può scrivere a || b ||...; invece di Not[a] si può scrivere !a; invece di And[a,b,...] si può scrivere a && b && ... Ricordiamo che && ha la precedenza su ||. In caso di dubbio mettere le parentesi tonde.

InequalitySolve[(x^2) < 1 || (x^2) > 4,x]

InequalitySolve[! ((x^2) < 1 || (x^2) > 4),x]

Fra i connettivi logici noti a Mathematica c'è anche l'implicazione. in formato ASCII si scrive con Implies:

InequalitySolve[Implies[x > 1, x^2 < 4],x]

L'implicazione si può scrivere anche col simbolo "=>" (Esc=>Esc)

InequalitySolve[x > 1 \[Implies] x^2 < 4,x]

Riuscite a capacitarvi che il risultato di x > 1 => (x^2) < 4 sia x < 2? Per esempio, x == 0 rende vera l'implicazione? Sì, perché "p implica q" equivale a "Not[p && Not[q]]", o a "Not[p] || q". Per x == 0 l'antecedente x > 1 è falso, quindi l'implicazione è vera.
Osservate:

False \[Implies] True

False \[Implies] False

True \[Implies] False

True \[Implies] True

(x > 1 \[Implies] (x^2) < 4) /. x -> 0

(x > 1 \[Implies] (x^2) < 4) /. x -> 2

Disequazioni in due variabili e grafici

InequalitySolve risolve anche disequazioni in più variabili. Un esempio di due disequazioni di primo grado:

InequalitySolve[{y > x, y < 2  x + 1}, {x, y}]

Un sistema di secondo grado:

InequalitySolve[{y > x, x^2 + y^2 < 1}, {x, y}]

Nel pacchetto Graphics`InequalityGraphics` è definito un comando per disegnare l'insieme delle soluzioni di sistemi di disequazioni in due variabili. Carichiamo il pacchetto, con una qualsiasi delle due istruzioni seguenti:

<<Graphics`InequalityGraphics`

Needs["Graphics`InequalityGraphics`"]

e poi usiamo il comando InequalityPlot: l'insieme delle soluzioni è disegnato in colore verdognolo (il colore si può cambiare, volendo):

InequalityPlot[{y > x, y < 2  x + 1},{x, -1, 1},{y, -1, 1}];

InequalityPlot[{y > x, x^2 + y^2 < 1},{x, -2, 2},{y, -2, 2}];

InequalityPlot non fa distinzione fra disuguaglianze strette ("<" e ">") e deboli (" ≤ " e " ≥ "). Un punto sul bordo della regione colorata può soddisfare o no le disuguaglianze; non c'è modo di saperlo guardando soltanto la figura.

Diagrammi di combinazioni logiche

$FormatType = TraditionalForm;

diagramma[comb_] := 
        Draw2D[{InequalityDraw[
              comb /. {p -> ((((x + 1))^2) + (y^2) ≤ 4), 
                  q -> ((((x - 1))^2) + (y^2) ≤ 
                        4)}, {x, -4, 4}, {y, -3, 3}, 
              Curves -> None], 
Circle[{-1, 0}, 
              2], Circle[{1, 0}, 2], 
            Text[p, {-1, 0} + 2 {-1, 1}/Sqrt[2], {1, -1}], 
            Text[q, {1, 0} + 
                2 {1, 1}/
                    Sqrt[2], {-1, -1}]}, 
PlotRange -> {{-4, 4}, {-3, 3}}, AspectRatio -> Automatic, 
          PlotLabel -> comb, Frame -> True, 
          FrameTicks -> None];

diagramma[p];

diagramma[¬ p];

diagramma[p ∧ q];

diagramma[p ∧ ¬ q];

diagramma[¬ (p ∧ ¬ q)];

La definizione di limite studiata come disequazione (argomento complicato)

Definizione di limite. Diciamo che (lim_(x -> +∞))f[
                x] == ℓ se

∀  ϵ > 
            0    ∃  
                n ∈ ℝ    ∀  
                      x ∈ 
                        dom[f]         x > 
                          n  =>  ℓ - ϵ < 
          f[x] < ℓ + ϵ

Consideriamo la seguente funzione:

f[x_] := (x/(1 - x));

Reduce[
      ForAll[x, x > n, 
        Evaluate[l - ϵ < f[x] < l + ϵ]], {l, ϵ, 
        n}]

Sappiamo che questa f[x] tende a ℓ == -1 per x -> -∞. Quindi per ogni ϵ > 0 esite n tale che per ogni x > n si ha che 1 - ϵ < f[x] < 1 + ϵ.
Problema. Trovare una formula esplicita per questo n in termini di ϵ.
Intanto definiamo anche ℓ:

ℓ = -1;

("ℓ" si scrive da tavolozza, oppure con EscsclEsc). L'implicazione da risolvere è

daRisolvere=(x > n) \[Implies] (ℓ - ϵ < 
                f[x] < ℓ + ϵ);

All'implicazione aggiungiamo la condizione ϵ > 0 e risolviamo:

InequalitySolve[ϵ > 0 && daRisolvere, {ϵ, n, 
        x}]

Studiamo il risultato: c'è un ϵ > 0 congiunto con una disgiunzione. Coloriamo diversamente i vari elementi della disgiunzione per farli risaltare:

ϵ > 0&&(n < ((-1 + ϵ)/ϵ) && (x < ((-1 + ϵ)/ϵ) || x > ((1 + ϵ)/ϵ))||n == ((-1 + ϵ)/ϵ) && (x ≤ ((-1 + ϵ)/ϵ) || 
                  x > ((1 + ϵ)/ϵ))||((-1 + ϵ)/ϵ) < 
                n < ((1 + ϵ)/ϵ) && (x ≤ n || 
                  x > ((1 + ϵ)/ϵ))||n ≥ ((1 + ϵ)/ϵ))

(Suggerimento: quando si ha un'espressione lunga e complicata e non è chiaro quali sono i confini di una sottoespressione, inserite il cursore in un punto della sottoespressione, e poi cliccate ripetutamente, oppure tenendo premuto Ctrl battere ripetutamente il punto . : verranno evidenziate le sottoespressioni via via più grandi che contengono il cursore.)

I primi tre elementi della disgiunzione (rosso, verde, blu) contegono delle condizioni sulla x. Invece l'ultimo elemento (quello su sfondo giallo) non dipende da x!. Questo vuol dire che la combinazione di disuguaglianze che avevamo scritto è vera indipendentemente da x qualora n ≥ ((1 + ϵ)/ϵ). Verifichiamo:

InequalitySolve[(ϵ > 0&&n ≥ ((1 + ϵ)/ϵ))\[Implies]daRisolvere,{ϵ, n, x}]

Conclusione: ogniqualvolta ϵ > 0 e \(TraditionalForm\`n ≥ \(1 + ϵ\)\/ϵ\)l'implicazione  x > 
          n  =>  ℓ - ϵ < 
          f[x] < ℓ + ϵ vale per ogni x. La definizione di limite è verificata.

Per visualizzare la situazione ho scritto il programmino seguente, che non vado a spiegare, perché contiene troppe funzioni nuove in una volta. Fidatevi per il momento.

bersaglio[ϵ_?Positive] := 
Module[{n, 
            xmax, ℓ, strisciaGialla, 
            quotaLimite}, 
n = (1 + ϵ)/ϵ; 
xmax = 
            2  n; 
ℓ = -1; 
strisciaGialla = {RGBColor[1, 1, 0], 
              Rectangle[{n, ℓ - ϵ}, {xmax, ℓ + ϵ}]}; 
quotaLimite = {Dashing[{ .02,  .02}], 
              Line[{{0, ℓ}, {2  n, ℓ}}], 
              Line[{{n, 
                    0}, {n, ℓ - ϵ}}]}; 
Plot[
            x/(1 - x), {x, 3/2, 
              xmax}, 
Prolog -> {strisciaGialla, 
                quotaLimite}, 
PlotRange -> {{-1, 
                  xmax}, {Min[ℓ - ϵ, -3], 
                  Max[ℓ + ϵ, 
                    1]}}, 
AxesOrigin -> {0, 
                0}]];

Per ϵ == (1/2) la scelta vincente di n è n ≥ 3. Quando x > n ≥ 3 si ha che ℓ - (1/2) < f[x] < ℓ + (1/2), cioè il grafico di f[x] per x > 3 è compreso nella striscia gialla, centrata a quota ℓ e di semialtezza (1/2):

bersaglio[1/2];

La situazione per ϵ == (1/4):

bersaglio[1/4];

Per ϵ == (1/8):

bersaglio[1/8];

Nelle tre figure le scale orizzontali sono diverse.

Nella versione 5.2 di Mathematica si può scrivere ForAll e Exists e usare Reduce:

Reduce[
      ForAll[x, 
        x > n, -1 - ϵ < 
          (x/(1 - x)) < -1 + ϵ], {ϵ, n}]

Reduce[
      ForAll[ϵ, ϵ > 0, 
        Exists[n, 
          ForAll[x, 
            x > n, ℓ - ϵ < 
              (x/(1 - x)) < ℓ + ϵ]]], ℓ]

La definizione di continuità studiata come disequazione (argomento complicato)

La funzione f[x_] := (x^2) - 1 è continua (è un polinomio). In termini di ϵ e di δ vuol dire che

∀ ϵ>0 ∃ δ>0 ∀x∈ℝ    (Subscript[x, 0])-δ<x<(Subscript[x, 0]) + δ => f[(Subscript[x, 0])] - ϵ < f[x] < f[(Subscript[x, 0])] + ϵ.

Problema: trovare una formula esplicita per il δ in termini di ϵ, quando (Subscript[x, 0]) == 2.
Risoluzione. Definiamo la funzione e il punto (Subscript[x, 0]) = 2:

f[x_] = x^2 - 1;
(Subscript[x, 0]) = 2;

L'implicazione da risolvere è

daRisolvere=(((Subscript[x, 0]) - δ < x < (Subscript[x, 0]) + δ)\[Implies](f[(Subscript[x, 0])] - ϵ < f[x] < f[(Subscript[x, 0])] + ϵ));

Risolviamola:

InequalitySolve[ϵ > 0 && δ > 0 && daRisolvere,{ϵ, δ, x}]

Vediamo che la soluzione è la disgiunzione di tre casi a seconda che 0 < ϵ < 4, ϵ == 4, ϵ > 4.  Nelle disgiunzioni associate ai tre casi mettiamo in evidenza con sfondo giallo quelle che non dipendono da x:

0 < ϵ < 4&&(0 < δ ≤ -2 + (Sqrt[4 + ϵ])||-2 + (Sqrt[4 + ϵ]) < δ ≤ 
                2 - (Sqrt[4 - ϵ]) && (x < (Sqrt[4 + ϵ]) || 
                  x ≥ 2 + δ)||2 - (Sqrt[4 - ϵ]) < δ < 
                2 + (Sqrt[4 - ϵ]) && (x ≤ 
                    2 - δ || (Sqrt[4 - ϵ]) < 
                    x < (Sqrt[4 + ϵ]) || 
                  x ≥ 2 + δ)||δ == 
                2 + (Sqrt[4 - ϵ]) && (x ≤ -(Sqrt[4 - ϵ]) || (Sqrt[4 - ϵ]) < x < (Sqrt[4 + ϵ]) || 
                  x ≥ 2 + δ)||2 + (Sqrt[4 - ϵ]) < δ ≤ 
                2 + (Sqrt[4 + ϵ]) && (x < -(Sqrt[4 - ϵ]) || (Sqrt[4 - ϵ]) < x < (Sqrt[4 + ϵ]) || 
                  x ≥ 2 + δ)||δ > 
                2 + (Sqrt[4 + ϵ]) && (x ≤ 
                    2 - δ || -(Sqrt[4 + ϵ]) < 
                    x < -(Sqrt[4 - ϵ]) || (Sqrt[4 - ϵ]) < 
                    x < (Sqrt[4 + ϵ]) || 
                  x ≥ 2 + δ))||ϵ == 4&&(0 < δ ≤ -2 + 2 (Sqrt[2])||-2 + 2 (Sqrt[2]) < δ ≤ 
                2 && (x < 2 (Sqrt[2]) || x ≥ 2 + δ)||2 < δ ≤ 
                2 + 2 (Sqrt[2]) && (x < 0 || 0 < x < 2 (Sqrt[2]) || 
                  x ≥ 2 + δ)||δ > 
                2 + 2 (Sqrt[2]) && (x ≤ 2 - δ || -2 (Sqrt[2]) < 
                    x < 0 || 0 < x < 2 (Sqrt[2]) || 
                  x ≥ 2 + δ))||ϵ > 4&&(0 < δ ≤ -2 + (Sqrt[4 + ϵ])||-2 + (Sqrt[4 + ϵ]) < δ ≤ 
                2 + (Sqrt[4 + ϵ]) && (x < (Sqrt[4 + ϵ]) || 
                  x ≥ 2 + δ)||δ > 
                2 + (Sqrt[4 + ϵ]) && (x ≤ 
                    2 - δ || -(Sqrt[4 + ϵ]) < 
                    x < (Sqrt[4 + ϵ]) || 
                  x ≥ 2 + δ))

Tutte e tre si riducono all'unica formula 0 < δ ≤ -2 + (Sqrt[4 + ϵ]). Verifichiamo che questa è una δ giusta da inserire nella definizione di continuità:

InequalitySolve[(ϵ > 0 && 
                0 < δ ≤ -2 + (Sqrt[4 + ϵ])) \[Implies] daRisolvere,{ϵ, δ, x}]

Concludiamo che in effetti per ogni ϵ > 0 esiste δ > 0 (basta che \(TraditionalForm\`0 < δ ≤ \(-2\) + \@\(4 + ϵ\)\)) tale che comunque si prenda x si ha che (Subscript[x, 0]) - δ < x < (Subscript[x, 0]) + δ => f[(Subscript[x, 0])] - ϵ < f[x] < f[(Subscript[x, 0])] + ϵ.

bersaglio[ϵ_?Positive] := 
Module[{f, x, 
            x0, δ, xmin, xmax, strisciaGialla, 
            quotaLimite}, 
f[x_] = 
            x^2 - 1; 
x0 = 
            2; 
δ = -2 + 
              Sqrt[4 + ϵ]; 
xmin = 
            Min[-1, x0 - δ]; 
xmax = 
            Max[3, x0 + δ]; 
strisciaGialla = {RGBColor[1, 1, 0], 
              Rectangle[{x0 - δ, f[x0] - ϵ}, {x0 + δ, 
                  f[x0] + ϵ}]}; 
quotaLimite = {PointSize[ .03  ϵ], Point[{x0, f[x0]}], Dashing[{ .02,  .02}], 
              Line[{{0, f[x0]}, {x0, f[x0]}, {x0, 
                    0}}]}; 
Plot[
            f[x], {x, xmin, 
              xmax}, 
Prolog -> {strisciaGialla, 
                quotaLimite}, 
PlotRange -> {Min[
                  f[x0] - ϵ, -1], 
                Max[f[x0] + ϵ, 
                  4]}, 
AxesOrigin -> {0, 
                0}]];

bersaglio[1/2];

bersaglio[1/4];

Con la versione 5.2 di Mathematica si può anche scrivere ForAll

f[x_] = x^2 - 1;
(Subscript[x, 0]) = 2;
Reduce[ϵ > 0 && δ > 0 && 
ForAll[x, 
          Evaluate[(Subscript[x, 0]) - δ < x < (Subscript[x, 0]) + δ], 
          Evaluate[
            f[(Subscript[x, 0])] - ϵ < f[x] < 
              f[(Subscript[x, 0])] + ϵ]], 
{ϵ, δ}]

Reduce[
      ForAll[ϵ, ϵ > 0, 
        Exists[δ, δ > 0, 
ForAll[x, 
            2 - δ < x < 2 + δ, ℓ - ϵ < 
              (x^2) - 1 < ℓ + ϵ]]], 
ℓ]

Esercizi

Risolvere il sistema {({{x > y}, {(x^2) + 2  (y^2) < 1}, {y < (x^2) - x}}) e rappresentare le soluzioni nel piano x y.

Ha qualche importanza l'ordine delle incognite nel risolvere disequazioni in più variabili? Provare per esempio con diseq={x^2+y^2<1,y>x} e InequalitySolve[diseq,{x,y}] e InequalitySolve[diseq,{y,x}].

Trovare l'insieme di definizione della funzione f[x_] = Log[(x^2) - 1]/(x - 2).

Si possono mescolare equazioni con disequazioni? Provare per esempio con {({{x == (y^2)}, {x + y < 1}}).

Confrontare i risultati dei tre strumenti Solve, Reduce e InequalitySolve sull'equazione (x^4) - 3  (x^3) + 3  (x^2) - 3  x + 2 == 0.  Lo stesso per l'equazione parametrica a (x^2) == 1.

Per quali valori del parametro a l'equazione a (x^2) - (a - 3) x + 1 == 0 ha almeno una soluzione compresa fra 0 e 2?

Fra i connettori logici predefiniti in Mathematica c'è anche l'equivalenza? Il simbolo ⇔ si scrive da tastiera con Esc<=>Esc. Provare a definire p_⇔q_:=(p=>q)&&(q=>p) e vedete se funziona.
E cosa dite dell'implicazione inversa ⇐?
Consultare anche Help>Built-in Functions>Programming>Logical Operations.

Sono equivalenti le due espressioni (p&&q)=>r e p=>(q=>r)? Dopo aver definito p_⇔q_:=(p=>q)&&(q=>p) provare a scrivere Simplify[((p&&q)=>r)⇔(p=>(q=>r))].

(Complicato) Studiare la continuità della funzione f[x_] = (((x^2) - 1)/((x^2) + 1)) nel punto (Subscript[x, 0]) == 2, cioè trovare una formula esplicita ottimale di δ in termini di ϵ.
(Nota: per questo problema nella versione 4.1 di Mathematica, InequalitySolve dà un risultato sbagliato).

(Complicato) Non è indispensabile conoscere in anticipo il valore di ℓ per impostare la disequazione: si può mettere ℓ fra le incognite. Per esempio, per la funzione f[x_]=x/(1-x) e x che tende a +∞ possiamo impostare il problema come sol=InequalitySolve[(ϵ > 0 && 
                      x > n) => (ℓ - ϵ < 
                      f[x] < ℓ + ϵ),{ℓ,ϵ,n,x}]. Il risultato della disequazione è parecchio complicato. C'è un modo automatico di scremare le parti indesidarate (quelle che dipendono da x): si definisce la regola (che qui non cerco di spiegare) reg=_[___,x,___]->False, e poi si la si applica al risultato della disequazione: sol/.reg. In complesso:
f[x_]=x/(1-x);
sol=InequalitySolve[ϵ>0&&(x>n=>ℓ-ϵ<f[x]<ℓ+ϵ),{ℓ,ϵ,n,x}];
reg=_[___,x,___]->False;
sol/.reg
il risultato è molto più maneggevole. Si vedrà che i casi ℓ < -1 e ℓ > -1 non sono accettabili, perché non è verificata la condizione ∀ ϵ > 0. Invece il caso ℓ==-1 è buono.