Off[General::spell1]Off[ParametricPlot::ppcom]Off[$MaxExtraPrecision::meprec]

Beispiele

ganze Zahlen

beispiel 1

FactorInteger[12]

AnzPrimfaktoren[n_] := Length[FactorInteger[n]]

AnzPrimfaktoren[17! + 1]

beispiel 2

Table[Prime[k], {k, 1, 10}]

beispiel 3

Select[Range[1001, 1111], AnzPrimfaktoren[#] == 2&]

lösungen 1-2

Primzahlen[n_] := Table[Prime[k], {k, 1, PrimePi[n]}];

Aufgabe 1

Select[Primzahlen[100], Mod[#, 4] == 1&]Select[Primzahlen[100], Mod[#, 4] == 3&]

Aufgabe 2

PrimzahlenDerForm[4  k + x_ ≤ n_] := 
      Select[Primzahlen[n], Mod[#, 4] == x&]

PrimzahlenDerForm[4  k + 1 ≤ 100]

beispiel 4

QuadratzahlQ[n_] := IntegerQ[Sqrt[n]]

Map[QuadratzahlQ[#]&, {16, 72}]

SetAttributes[QuadratzahlQ, Listable]

QuadratzahlQ[{16, 72}]

beispiel 5

117 - Table[(k^2), {k, Sqrt[117/2]}]

\(SummeZweierQuadrate[n_] := 
      Block[{mengeA, mengeB}, 
        mengeA = Select[n - Table[k\^2, {k, Sqrt[n/2]}], QuadratzahlQ[#]&]; 

        		mengeB = n - mengeA; 
		Thread[{mengeA, mengeB}]]\)

SummeZweierQuadrate[221]

\(SummeZweierQuadrateQ[n_] := 
      Block[{a}, 
		a = n - Table[k^2, {k, 1, Sqrt[n]}]; 
		
        Apply[Or, QuadratzahlQ[a]]]\)

SummeZweierQuadrateQ[117]

SetAttributes[SummeZweierQuadrateQ, Listable]

SummeZweierQuadrateQ[{117, 215}]

beispiel 6

Apply[And, 
      SummeZweierQuadrateQ[PrimzahlenDerForm[4  k + 1 ≤ 1000]]]

Apply[Or, 
      SummeZweierQuadrateQ[PrimzahlenDerForm[4  k + 3 ≤ 1000]]]

beispiel 7

FactorInteger[19845]

Transpose[%]

Primfaktoren[n_] := Transpose[FactorInteger[n]][[1]]

Primfaktoren[19845]

lösungen 4-5

Aufgabe 4

a) mit Apply

Apply[Union, Map[Range[#, 72, #]&, Primfaktoren[72]]]

oder mit Map

\(\(Map[Range[#, 72, #]&, Primfaktoren[72]]
 // Flatten\) // Union\)

b) die Komplementärmenge von a)

Complement[Range[72], %]

Aufgabe 5

\(\(TeilerfremdeZahlen[n_] := 
	
      Complement[Range[n], 
		
        Apply[Union, Map[Range[#, n, #]&, Primfaktoren[n]]]]; \)\)

Length[TeilerfremdeZahlen[72]] == EulerPhi[72]

beispiel 8

Select[Range[1000], PowerMod[2, # - 1, #] == 1 && ! PrimeQ[#]&]

PseudoprimQ[b_Integer, n_Integer] := 
      PowerMod[b, n - 1, n] == 1 && ! PrimeQ[n];

lösungen 6-9

Aufgabe 6

Apply[And, Map[PseudoprimQ[#, 1105]&, {2, 3}]]

Aufgabe 7
den Algorithmus PseudoprimQ erweitern:

PseudoprimQ[b_List, n_Integer] := 
      Apply[And, Map[PseudoprimQ[#, n]&, b]]

PseudoprimQ[{2, 3, 5}, 1729]

PseudoprimQ[{2, 3, 5, 7}, 29341]

Aufgabe 8

Select[Range[29341], PseudoprimQ[2, #]&]

Select[%, PseudoprimQ[{3, 5, 7}, #]&]

Aufgabe 9

PseudoprimQ[TeilerfremdeZahlen[29341], 29341]

erstellen einer graphik

optionen

ParametricPlot[ {t - Sin[t], -Cos[t] + 1}, {t, 0, 2 π}];

ParametricPlot[{t - Sin[t], -Cos[t] + 1}, {t, 0, 2 π}, 
      AspectRatio -> (1/π)];

\(\(ParametricPlot[{t - Sin[t], \(-Cos[t]\) + 1}, {t, 0, 2\ π}, 
	
      PlotStyle -> {RGBColor[0, 1, 0]}, 
	PlotLabel -> "eine Zykloide", 
      
	Ticks -> {{0, π, 2  π}, {1, 2}}, 
	
      AxesLabel -> {"x", None}, 
	PlotRange -> {Automatic, {0, 3}}, 
	
      AspectRatio -> 3/\((2  π)\), 
	Background -> GrayLevel[0.9]]; 
    \)\)

grafikelemente

kreis[t_]:=Graphics[
		{ Circle[{t, 1}, 1], Point[{t, 1}], Hue[0.6], PointSize[0.02], Point[{t - Sin[t], 1 - Cos[t]}],
GrayLevel[0] , Line[{{t, 1},{t - Sin[t],1-Cos[t]}}] },
		PlotRange -> {{0, 2  π}, {0, 2}},
		AspectRatio -> 1/π
		];

Show[kreis[1]];

Show[{kreis[1], kreis[2.3]}];

mehrere Zeichnungen übereinanderlegen

\(\(zykloide[] := 
      ParametricPlot[{t - Sin[t], \(-Cos[t]\) + 1}, {t, 0, 2\ π}, 
	
        PlotStyle -> Hue[0.6], 
	Ticks -> {{0, π, 2  π}, {1, 2}}, 

        	AspectRatio -> 1/π, 
	PlotPoints -> 100, 
	
        DisplayFunction -> Identity
	]; \)\)

\(\(Show[{zykloide[], kreis[1], kreis[2.3]}, 
	
      DisplayFunction -> $DisplayFunction]; \)\)

beispiel einer Animation

\(zykloide[t_] := 
        \(ParametricPlot[{φ - Sin[φ], 
              \(-Cos[φ]\) + 1}, {φ, 0, 2\ π}, 
	
            PlotStyle -> Hue[0.6], 
	
            Ticks -> {{0, π, 2  π}, {1, 2}}, 
	PlotPoints -> 100, 

            	DisplayFunction -> Identity
	]\)[\([1]\)]\);
kreis[t_]:=
		{ Circle[{t, 1}, 1], Point[{t, 1}], Hue[0.6], PointSize[0.02], Point[{t - Sin[t], 1 - Cos[t]}]  ,
	 GrayLevel[0] , Line[{{t, 1},{t - Sin[t], 1 - Cos[t]}}] };

\(\(bild[t_] := 
      Graphics[Flatten[{zykloide[t], kreis[t]}], 
		
        PlotRange -> {{0, 2  π}, {0, 2}}, 
		AspectRatio -> 1/π]; 
    \)\)

film = Table[bild[t], {t, 0, 2  π, 2  π/9}];

<< Graphics`Animation

ShowAnimation[film]

bemerkungen

\(\(graphics[x__] := 
      Block[{xMax, xMin, yMax, yMin}, 
		
        g = Graphics[{x}, PlotRange -> All]; 

        		{{xMin, xMax}, {yMin, yMax}} = FullOptions[g, PlotRange]; 
		
        Graphics[{x}, 
			PlotRange -> All, 
			
          AspectRatio -> \((yMax - yMin)\)/\((xMax - xMin)\)]]; \)\)

\(\(Plot[{Sin[x], Sin[2  x]}, {x, 0, 2  π}, 
	
      PlotStyle -> {{}, {Dashing[{0.01, 0.01}]}}]; \)\)

lösungen

Aufgabe 1

\(\(DisplayTogether[
	
      Plot[x/Log[x], {x, 10, 10000}, 
		PlotStyle -> Hue[0.8]], 
	
      ListPlot[Table[{k, PrimePi[k]}, {k, 10, 10000, 100}]]
	]; \)\)

Aufgabe 2

Solve[x^2 - 2  y^2 + x y - 3  x z == 0 /. z -> 0, y]

Solve[{x^2 - 2  y^2 + x y - 3  x == 0, y == -x/2 + q}, {x, y}]Solve[{x^2 - 2  y^2 + x y - 3  x == 0, y == x + q}, {x, y}]

<< Graphics`ImplicitPlot`

ImplicitPlot[{x^2 - 2  y^2 + x y - 3  x == 0, y == -x/2 + 1, 
        y == x - 1}, {x, -2, 4}, {y, -2, 2}];

berechnungszeiten

die fibonaccifolge

\(\(fib[n_] := 
      Module[{f}, 
		f[1] = \(f[2] = 1\); 
		
        f[k_] := f[k - 1] + f[k - 2]; 
		\(First[Timing[f[n]]]\)[\([1]\)]

        	]; \)\)

fib[15]

berechnungszeit = Table[{n, fib[n]}, {n, 10, 25}]

ListPlot[berechnungszeit];

\(berechnungszeit = 
	
      DeleteCases[berechnungszeit, {_, x_Real /; x <= $MinNumber}]\)

List[#[[1]], Log[#[[2]]]]&/@berechnungszeit

h = Exp[Fit[%, {1, x}, x]]

\(\(DisplayTogether[
	ListPlot[berechnungszeit], 
	
      Plot[h, {x, 5, 25}, PlotStyle -> Hue[0.8]]]; \)\)

bemerkung

\(f[1] = \(f[2] = 1\); 
f[n_] := \(f[n] = f[n - 1] + f[n - 2]\); \)

f[50] // Timing

lösungen

Aufgabe 1

zufallsmatrix[n_] := 
      Table[Random[Integer, {-2^16 - 1, 2^16 - 1}], {k, 1, n}, {j, 1, n}]

det[n_] := Timing[Det[zufallsmatrix[n]]][[1, 1]]

berechnungszeit = Table[{k, det[k]}, {k, 10, 50, 5}]

ListPlot[berechnungszeit];

f = Fit[berechnungszeit, {1, x, x^2, x^3}, x]

\(\(DisplayTogether[
	Plot[f, {x, 10, 200}, PlotStyle -> Hue[.9]], 
	
      ListPlot[berechnungszeit]]; \)\)

Aufgabe 2

sort[n_] := 
      Sort[Table[Random[Integer, {-2^16 - 1, 2^16 - 1}], {k, 1, n}]];

berechnungszeit = 
      Table[{k, Timing[sort[k]][[1, 1]]}, {k, 200, 10000, 200}];

ListPlot[berechnungszeit];

f = Fit[berechnungszeit, {1, x}, x]

\(\(DisplayTogether[
	Plot[f, {x, 200, 10000}, PlotStyle -> Hue[.9]], 

      	ListPlot[berechnungszeit]]; \)\)

Clear[f]

1.Wie hängt die Berechnungzeit von n  ab?
    a) Determinante einer n × n-Matrix
    b) Sortieren einer n-elementigen Liste

differentialgleichungen

das pendel

\(\(diffgl[φ0_] := {
				
        D[φ[t], {t, 2}] + 9.81  Sin[φ[t]] == 0, 
		
        \(φ'\)[0] == 0, φ[0] == φ0}; \)\)

pendel[1] = 
      φ /. 
        NDSolve[diffgl[1], φ, {t, 0, 3}][[1]]Plot[pendel[1][t], {t, 0, 3}];

FindRoot[pendel[1][t] == 1, {t, 2.5}]

\(pendel[1.5] = 
      φ /. 
        \(NDSolve[diffgl[1.5], φ, {t, 0, 3}]\)[\([1]\)]; 

    Plot[{\(pendel[1]\)[t], \(pendel[1.5]\)[t]}, {t, 0, 3}, 
	
      PlotStyle -> {{Hue[0.8]}, {}}]; \)

der harmonische oszillator

DSolve[{x''[t] + (ω^2) x[t] == 0}, x, t]

s = 
      x /. DSolve[{x''[t] + (ω^2) x[t] == 0, x[0] == 1, 
              x'[0] == 0}, x, t] // First

\(\(DisplayTogether[
	Plot[s[t] /. ω -> Sqrt[9.81], {t, 0, 3}], 
      
	Plot[\(pendel[1]\)[t], {t, 0, 3}, 
		PlotStyle -> Hue[0.8]]]; 
    \)\)

die planetenbewegung

\(\(diffgl
       = {
	\(\(x'\)'\)[t] == 
          \(-\ \(\(\ x[t]\)\/\((x[t]\^2 + y[t]\^2)\)\^\(3/2\)\)\), 
	
        \(\(y'\)'\)[t] == 
          \(-\ \(\(\ y[t]\)\/\((x[t]\^2 + y[t]\^2)\)\^\(3/2\)\)\), 
		
        x[0] == 0.5, y[0] == 0, 
		\(x'\)[0] == 0, \(y'\)[0] == 1.63

        					}; \)\)

{x, y} = {x, y} /. NDSolve[diffgl, {x, y}, {t, 0, 4.2}][[1]]

ParametricPlot[{x[t], y[t]}, {t, 0, 4.2}];

T = t /. FindRoot[x[t] == 0.5, {t, 4.1}]

\(planet[t_] := {PointSize[0.02], GrayLevel[0], Point[{x[t], y[t]}]}; 

    sonne = {PointSize[0.07], Hue[0.1], Point[{0, 0}]}; \)

\(\(Show[
      Graphics[
		{Table[planet[t], {t, 0, T, T/25}], sonne} // Flatten

        		]]; \)\)

ein federpendel

\(\(federpendel
       = {
		20\ \(\(x1'\)'\)[t] == 
          \(-\ 0.5\) x1[t] + \((x2[t] - x1[t])\), 
		
        5\ \(\(x2'\)'\)[t] == \(-\((x2[t] - x1[t])\)\), 
		x1[0] == 1, 
        \(x1'\)[0] == 0, x2[0] == 2, \(x2'\)[0] == 0
		}; \)\)

{x1, x2} = {x1, x2} /. 
        NDSolve[federpendel, {x1, x2}, {t, 0, 50}][[1]]

\(\(Plot[{x1[t], x2[t]}, {t, 0, 50}, 
	PlotStyle -> {{Hue[0.8]}, {}}]; 
    \)\)

\(\(Plot[{\(x1'\)[t], \(x2'\)[t]}, {t, 0, 50}, 
	
      PlotStyle -> {{Hue[0.8]}, {}}]; \)\)

lösungen

Aufgabe 1

bild[t_] := Flatten[{sonne, planet[t]}];

\(\(film = 
      Table[
		
        Graphics[bild[t], 
			
          PlotRange -> {{\(-1.3\), 0.6}, {\(-0.8\), 0.8}}, 
			
          AspectRatio -> 1.6/1.9], {t, 0, T, T/25}]; \)\)

ShowAnimation[film]

Clear[x, y, T, s]

Aufgabe 2

schieferWurf={
		(x')'[t]==-((x'[t])^2),(y')'[t]==If[y'[t]≥0,-g-((y'[t])^2),-g+((y'[t])^2)],
		x[0] == 0,y[0] == 0,x'[0] == 30,y'[0] == 20}/.g -> 9.81;

bahn = NDSolve[schieferWurf, {x, y}, {t, 0, 2}]

ParametricPlot[{x[t], y[t]} /. bahn, {t, 0, 1.3}, 
      AxesOrigin -> {0, 0}, PlotRange -> All];

Aufgabe 3

\(k[t_] := 0.5\ ρ[t]\ q[t]\ cw[t]; 

    ρ[t_] := 1.25\ Exp[\(-.00014\)\ x[t]]; 

    cw[t_] := If[t <= t1, 0.25, 0.9]; 
q[t_] := If[t <= t1, 3, 25]; \)

diffgl := 
      x''[t] == g - k[t]/m x'[t]^2 /. {m -> 70, g -> 9.81, 
          t1 -> 30};

s = 
      x /. NDSolve[{diffgl, x[0] == 0, x'[0] == 0}, x, {t, 0, 100}][
          [1]]

\(\(GraphicsArray[{
		
          Plot[s[t], {t, 0, 100}, DisplayFunction -> Identity], 
		
          Plot[\(s'\)[t], {t, 0, 100}, DisplayFunction -> Identity], 
		
          Plot[\(\(s'\)'\)[t], {t, 0, 100}, DisplayFunction -> Identity]}] // 
      Show; \)\)

Clear[s, k, ρ, cw, q, bahn]

Clear[x1, x2, diffgl, x, y, T, s, pendel]

wahrscheinlichkeitsrechnung

ein kartenspiel

7p (1-q)+2 (1-p)q-p q -8(1-p)(1-q)//Expand

ewA[p_, q_] := -8 + 15 p + 10 q - 18 p q

\(\(DisplayTogether[
	Plot3D[ewA[p, q], {p, 0, 1}, {q, 0, 1}], 
	
      Plot3D[0, {x, 0, 1}, {y, 0, 1}]]; \)\)

\(\(DisplayTogether[
	
      Plot3D[ewA[p, q], {p, 0, 1}, {q, 0, 1}, ViewPoint -> {0, 0, 2}], 
	
      Plot3D[0, {x, 0, 1}, {y, 0, 1}]]; \)\)

y[x_] = y /. Solve[ewA[x, y] == 0, y] // First

ewA[5/9, p]

das spiel simulieren

\(karteA := If[Random[] < 5/9, 7, 2]; 

    karteB := If[Random[Integer] == 0, 8, 1]; \)

spiel = Table[{karteA, karteB}, {j, 1, 8000}];

\(gewinnA = 2\ Count[spiel, {2, 1}] + 7\ Count[spiel, {7, 8}]; 

    gewinnB = 8\ Count[spiel, {2, 8}] + Count[spiel, {7, 1}]; 

    \((gewinnA - gewinnB)\)/8000.\)

nützliche algorithmen

Unprotect[Random];
\(Random[p_List] := 
        Block[{x, w, m}, 
		x[1] = p[\([1]\)]; 
		
          x[k_] := x[k - 1] + p[\([k]\)]; 
		m = Array[x, Length[p]]; 

          		w = Union[m, {Random[]}]; 
		
          \(Position[w, _Real]\)[\([1, 1]\)] - 1
		]\);

\(wurf = Table[Random[{1/4, 1/2}], {k, 1, 7000}]; 
wurf // Shallow\)

Count[wurf, #]&/@{0, 1, 2}

%/7000 // N

Häuf[folge_, elemente_] := 
      Count[folge, #]&/@elemente;

Häuf[folge_] := Count[folge, #]&/@Union[folge];

RelHäuf[folge_] := 
      Häuf[folge]/Length[folge] // NRelHäuf[folge_, elemente_] := 
      Häuf[folge, elemente]/Length[folge] // N

RelHäuf[wurf]

lösung

Aufgabe 1

ContourPlot[ewA[p, q], {p, 0, 1}, {q, 0, 1}];

ImplicitPlot[ewA[p, q] == 0, {p, 0, 1}, {q, 0, 1}, 
      AxesLabel -> {"p", "q"}];

\(\(DisplayTogether[
	ContourPlot[ewA[p, q], {p, 0, 1}, {q, 0, 1}], 
	
      ImplicitPlot[ewA[p, q] == 0, {p, 0, 1}, {q, 0, 1}, 
		
        PlotStyle -> Hue[0.8]]]; \)\)

vollständige induktion

der algorithmus

\(\(BeweisDurchInduktion[{x_Equal, y__Equal}, z_] := 
	
      Module[
		{a, k, expliziteForm, rekursiveForm, f, 
			
          InduktionsAnnahme, InduktionsSchritt}, 
		lhs[h_] := h[\([1]\)]; 
        
		rhs[h_] := h[\([2]\)]; 
		
		a = Head[lhs[z]]; 
		
        k = \(lhs[z]\)[\([1]\)]; 
		
		expliziteForm = rhs[z]; 
		
        rekursiveForm = rhs[x]; 
		
		
        f = Function[expliziteForm /. k -> #]; 
		
		
        InduktionsAnnahme = rekursiveForm /. a -> f; 
		
        InduktionsSchritt = 
          InduktionsAnnahme - expliziteForm == 0 // Simplify; 
		
		
        Verankerung = And@@\((\(Simplify[#]&\)/@\(({y} /. a -> f)\))\); 
        
		
		InduktionsSchritt\  && Verankerung
		]; \)\)

\(BeweisDurchInduktion[
	{g[n] == g[n - 1] + a\ q\^n, g[0] == a}, 
      g[n] == \(a\ \((1 - q\^\(n + 1\))\)\)\/\(1 - q\)]\)

fibonacci = {f[n] == f[n - 1] + f[n - 2], f[1] == 1, f[2] == 1};

BeweisDurchInduktion[
	fibonacci,f[n]==((((((1/2) (1 + (Sqrt[5]))))^n) - 
                  ((((1/2) (1 - (Sqrt[5]))))^n))/(Sqrt[5]))]

beispiel

BeweisDurchInduktion[{s[n] == s[n - 1] + (1/(a[n - 1] a[n])), 
        s[2] == (1/(a[1] a[2]))}, s[n] == ((n - 1)/(a[1] a[n]))]

% /. a[n_] -> a[1] + (n - 1) d // Simplify

gegenbeispiele

\(Induktionsbeweis::"verank"
		 = "Die Verankerung misslingt"; 
    
Induktionsbeweis::"schritt" = 
      "Der Induktionsschritt misslingt"; 

    Induktionsbeweis::"!entscheidb" = 
      "Der Induktionsschritt konnte nicht zu Ende geführt werden"; \)

\(\(BeweisDurchInduktion[{x_Equal, y__Equal}, z_] := 
	
      Module[
		{a, k, expliziteForm, rekursiveForm, f, 
			
          InduktionsAnnahme, InduktionsSchritt}, 
		lhs[h_] := h[\([1]\)]; 
        
		rhs[h_] := h[\([2]\)]; 
		a = Head[lhs[z]]; 
		
        k = \(lhs[z]\)[\([1]\)]; 
		expliziteForm = rhs[z]; 
		
        rekursiveForm = rhs[x]; 
		
        f = Function[expliziteForm /. k -> #]; 
		
        InduktionsAnnahme = rekursiveForm /. a -> f; 
		
        InduktionsSchritt = 
          InduktionsAnnahme - expliziteForm == 0 // Simplify; 
		
        Verankerung = And@@\((\(Simplify[#]&\)/@\(({y} /. a -> f)\))\); 
        
		
		
        If[\(! Verankerung\), Message[Induktionsbeweis::"verank"]]; 
		
        If[\(! InduktionsSchritt\), 
          Message[Induktionsbeweis::"schritt"], _, 
          Message[Induktionsbeweis::"!entscheidb"]]; 
		
		
        InduktionsSchritt\  && Verankerung
		]; \)\)

\(BeweisDurchInduktion[
	{s[n] == s[n - 1] + n, s[1] == 1, s[2] == 3}, 
      s[n] == n\^3\/2 - \(5\ n\^2\)\/2 + 6\ n - 3]\)

BeweisDurchInduktion[{s[n] == s[n - 1] + n, s[1] == 1, s[2] == 3}, 
      s[n] == (1/2) ((n^2) + n + 6)]

BeweisDurchInduktion[{s[n] == s[n - 1] + n, s[1] == 1}, 
      s[n] == (1/2) n (n + 1)]

lösungen 1-3

Aufgabe 1

phi = (1/2) ((Sqrt[5]) - 1);

BeweisDurchInduktion[{g[n] == g[n - 1] + g[n - 2], g[1] == phi + 1, 
        g[2] == (((phi + 1))^2)}, g[n] == (((phi + 1))^n)]BeweisDurchInduktion[{h[n] == h[n - 1] + h[n - 2], h[1] == -phi, 
        h[2] == (phi^2)}, h[n] == (((-phi))^n)]

Clear[phi]

Aufgabe 2

\(\(ntesGlied[{x_ == y_, z__Equal}, n_Integer] := 
	
      Module[{a, index, wert}, 
		index = \(#[\([1, 1]\)]&\)/@{z}; 
		
        wert = \(#[\([2]\)]&\)/@{z}; 
		
        Do[a[index[\([k]\)]] = wert[\([k]\)], {k, 1, Length[{z}]}]; 
		
        a[m_] := \(a[m] = y /. {Head[x] -> a, x[\([1]\)] -> m}\); 
	a[n]]; 
    \)\)

ntesGlied[fibonacci, 7]

Aufgabe 3

\(\(BeweisDurchInduktion[{x_Equal, y__Equal}, z_, w_GreaterEqual] := 
	
      Module[
		{a = Head[lhs[z]], k = lhs[w], k0 = rhs[w], 
			
          explizit, rekursiveForm, f, 
			InduktionsAnnahme, 
          InduktionsSchritt}, 
		lhs[h_] := h[\([1]\)]; 
		
        rhs[h_] := h[\([2]\)]; 
	
		expliziteForm = rhs[z]; 
		
        rekursiveForm = rhs[x]; 
		
        f = Function[expliziteForm /. k -> #]; 
		
        InduktionsAnnahme = rekursiveForm /. a -> f; 
		
        InduktionsSchritt = 
          InduktionsAnnahme - expliziteForm == 0 // Simplify; 
		
		
        Verankerung = ntesGlied[{x, y}, k0] == f[k0] // Simplify; 
		
		
        If[\(! Verankerung\), Message[Induktionsbeweis::"verank"]]; 
		
        If[\(! InduktionsSchritt\), 
          Message[Induktionsbeweis::"schritt"], _, 
          Message[Induktionsbeweis::"!entscheidb"]]; 
		
		
        InduktionsSchritt\  && Verankerung
		]; \)\)

noch einen Schritt weiter

\(\(BeweisDurchInduktion[{x_Equal, y__Equal}, z_, w_GreaterEqual] := 
	
      Module[
		{a = Head[lhs[z]], k = lhs[w], k0 = rhs[w], 
			
          expliziteForm, rekursiveForm, f, relation, 
			
          InduktionsAnnahme, InduktionsSchritt}, 
		lhs[h_] := h[\([1]\)]; 
        
		rhs[h_] := h[\([2]\)]; 
		expliziteForm = rhs[z]; 
		
        rekursiveForm = rhs[x]; 
		relation = Head[z]; 
		
        f = Function[expliziteForm /. k -> #]; 
		
        InduktionsAnnahme = rekursiveForm /. a -> f; 
		
        InduktionsSchritt = 
          relation[InduktionsAnnahme - expliziteForm, 0] // Simplify; 
		

        		Verankerung = relation[ntesGlied[{x, y}, k0], f[k0]] // Simplify; 
        
		
		
        If[\(! Verankerung\), Message[Induktionsbeweis::"verank"]]; 
		
        If[\(! InduktionsSchritt\), 
          Message[Induktionsbeweis::"schritt"], _, 
          Message[Induktionsbeweis::"!entscheidb"]]; 
		
		
        InduktionsSchritt\  && Verankerung
		]; \)\)

BeweisDurchInduktion[fibonacci, f[n] ≥ ((((3/2)))^n), 
      n ≥ 11]

bemerkung

n /: IntegerQ[n] := True

IntegerQ[n]

\(Unprotect[IntegerQ, Plus, Times]; 

    IntegerQ[Plus[a_?IntegerQ\ , b__?IntegerQ]] := True; 

    IntegerQ[Times[a_?IntegerQ\ , b__?IntegerQ]] := True; \)

IntegerQ[#]&/@{2 n + 1, 4 n, n - 1, (n + 1) (3 n + 1)}

\(Unprotect[GreaterEqual, Integer, Power]; 

    GreaterEqual[Power[x_ /; x ≥ 0, y_?IntegerQ], 0] := True\)

{(2^n) ≥ 0, (3^(2 n - 1)) ≥ 0, 
      (2.718^(-n)) ≥ 0}

\(Unprotect[Positive, Negative]; 

    Positive[x_ /; x ≥ 0] := True\)Negative[x_ /; -x ≥ 0] := True

\(Unprotect[Times]; 

    GreaterEqual[Times[x_?Positive, y__?Positive], 0] := True\)

{(2^n) (3^(-4 n)) (2.718^(-n)) ≥ 0, 
      (7^n) ≥ 0}

Protect[GreaterEqual, IntegerQ, Integer, Power, Plus, Times, 
      Positive, Negative];

BeweisDurchInduktion[fibonacci, f[n] ≥ ((((3/2)))^n), 
      n ≥ 11]

lösung 4

Aufgabe 4

\(Unprotect[Equal, PolynomialQ]; 

    Equal[x_, 0] := 
      False /; PolynomialQ[x, n_?IntegerQ] && Variables[x] == {n}\)

Protect[Equal, PolynomialQ];

Equal[3 n^2 + 2 n - 1, 0]

BeweisDurchInduktion[{s[n] == s[n - 1] + n, s[1] == 1, s[2] == 3}, 
      s[n] == ((n^3)/2) - ((5 (n^2))/2) + 6 n - 3]