%% LyX 1.3 created this file.  For more info, see http://www.lyx.org/.
%% Do not edit unless you really know what you are doing.

\input{makcyber}

\renewcommand{\bc}{\begin{center}}
\newcommand{\ec}{\end{center}}


\renewcommand{\tt}{\texttt}



\begin{document}

 \setlength{\parindent}{0mm}

\title{Découverte de MuPAD}

\author{Guillaume CONNAN - Lycée Jean Perrin (Rezé)}

\date{24 mai 2005}

\maketitle 

 \setlength{\parindent}{0mm}

\tableofcontents

 \section{Introduction}
 
 
MuPAD est un logiciel conçu initialement par des
chercheurs de l'université allemande de Paderborn. Ce n'est pas
tout à fait un logiciel libre comme nous allons le voir, mais presque.
En effet, le logiciel est composé de deux grands ensembles : un
noyau (kernel) qui dépend de chaque ordinateur et qui n'est pas
accessible aux utilisateurs (il gère par exemple le mode d'affichage
selon le système d'exploitation) et une bibliothèque de fichiers
décrivant chaque algorithme de calcul en mode texte, c'est à dire
affichable et modifiable sur n'importe quel éditeur de texte. Ainsi,
chaque utilisateur peut vérifier, réparer, améliorer la partie
mathématique du logiciel et c'est ce qui nous importe vraiment, nous
qui sommes plus mathématiciens qu'informaticiens.


Par exemple, nous pouvons regarder comment MuPAD calcule le reste de
la division euclidienne de $a$ par $b$  à l'aide de l'instruction
\texttt{irem(a,b)} en éditant le fichier correspondant dans le
répertoire \texttt{/usr/local/MuPAD/share/lib}

\tt{ \$Date: 2000/06/16 07:34:55 \$  \$Author: tonner \$ \$Revision:1.3\$}

          \tt{ irem(b,a) liefert bei Eingabe zweier ganzer Zahlen a und b
           den ganzzahligen (natuerlichen) Rest bei Division von b durch
           a.}


\tt{ irem:= proc(b,a) begin}


  \tt{  if args(0) <> 2 then
        error("expecting two arguments")}

   \tt{ end\_if;}


   \tt{ if domtype(b) = DOM\_INT then}


       \tt{  if domtype(a) = DOM\_INT then}


          \tt{  return( b - a*specfunc::trunc(b/a) )}


       \texttt{ elif testtype( a,Type::Numeric ) then
            error("Integer expected")}


        \texttt{else
            return( procname(b,a) )}


   \tt{     end\_if}
\tt{    elif testtype( b,Type::Numeric ) or domtype(a) <> DOM\_INT
and testtype(a,Type::Numeric) then}

\texttt{        error("Integer expected")}


   \texttt{ else
        return( procname(b,a) )
    end\_if}


\texttt{end\_proc:}



\vspace{1cm}

Certains connaissent déjà le minimum vital en programmation et
voient en gros de quoi il retourne. Pour les autres, nous allons
étudier les boucles très rapidement. Mais tout le monde peut
comprendre qu'il est possible de modifier ce texte pour le
personnaliser. Par exemple, on peut remplacer la ligne

\tt{ error("Integer expected")}

par

\tt{ error("Bougre d'âne ! Il faut renter deux entiers")}

qui est plus conviviale.


On peut aussi y trouver un intérêt mathématique (qui est assez
limité dans l'exemple précédent) : par exemple, on peut se demander
comment MuPAD teste si un entier est premier à l'aide de
\tt{isprime(n)} qui renvoie \tt{TRUE} ou \tt{FALSE}.  Cette question
peut être étudiée avec des élèves comme un point de départ pour
l'étude de la théorie des nombres en terminale.


\vspace{1cm}


Voilà pour la liberté. Mais comme d'habitude, cette liberté entraîne
quelques efforts de notre part (je ne dirai pas qu'elle a un prix,
mais vous voyez ce que je veux dire). Il faut faire quelques efforts
pour installer MuPAD de manière conviviale sur son ordinateur.

Tout d'abord il faut télécharger la version 3.1 pour linux : elle
est gratuite et se présente sous la forme d'un fichier rpm
récupérable à l'adresse 

\begin{center}
\tt{http://research.mupad.de/download.html.}
\end{center}


Une fois installé, il restera à s'occuper du logiciel chargé de
tracer les graphiques, mais nous verrons ça la prochaine fois.

Une fois votre PATH complété en tapant par exemple 

\begin{center}
\tt{ln -sf /usr/local/MuPAD/share/bin/* /usr/local/bin}
 \end{center}
 
 vous pouvez lancer l'application de
plusieurs manières :

\begin{itemize}

\item par la commande \tt{mupad} à partir d'un terminal
\item par la commande \tt{xmupad} que nous utiliserons aujourd'hui
et qui permet de travailler de manière plus conviviale sous X avec
une barre de menu assez spartiate (germanique...), mais bon, c'est
déjà pas mal. Un seul souci : MuPAD est allemand et ne connait donc
pas les accents. Les barres de menus seront donc infestées de ?? ,>>
et autres signes caballistiques. Pour vous en débarrasser, il suffit
d'utiliser un éditeur de texte pour modifier le script de
\tt{xmupad} qui se trouve sur mon ordi dans
\tt{/usr/local/MuPAD/share/bin/xmupad} sans oublier de modifier les
droits de propriété de \tt{bin} et \tt{xmupad}. Vous y trouverez une
ligne

\tt{export LC\_CTYPE=C}

que vous remplacerez par

\tt{export LC\_CTYPE="fr\_FR"}


\item vous pouvez utilisez des éditeurs de textes externes comme par
exemple TeXmacs qui, si MuPAD est installé, contient  dans le menu
\tt{texte} un sous-menu \tt{Session} où vous trouverez une option
\tt{MuPAD}. Vous serez alors dans un environnement très convivial,
avec toutes les options d'édition imaginables.

\item il existe également l'environnement Mupacs qui permet
l'utilisation de MuPAD dans le célèbre emacs. Vous trouverez des
renseignements sur le site \tt{mupacs.sf.net}

\end{itemize}

Il existe encore d'autres possibilités, mais celles-ci suffiront
pour commencer à travailler (enfin !)

Il reste à débrider la mémoire du noyau en allant chercher une license sur le site 

\tt{https://www.mupad.org/muptan/muptan.php}

Il suffira ensuite, une fois sous xmupad, de taper l'instruction suivante pour la license du lycée Jean Perrin par exemple :

\mup{register("7BSE91","112100-44A20-C176F-.....-.....")}




\vspace{1cm}

Bien, nous supposons maintenant que tout va bien et que vous avez
une version de MuPAD exploitable et correctement installée.

Nous allons bientôt
découvrir les fonctionnalités utiles à des élèves de lycée (ou plus
vieux) d'un logiciel de calcul formel appelé aussi  CAS (Computer
Algebra System) comme l'est MuPAD. Les niveaux de chacun étant divers, les activités sont de niveaux variés pour que chacun y trouve son compte.

























\section{La prise en mains}


Avant tout, nous aurons besoin de connaître quelques outils
techniques. Il faut savoir que MuPAD est doté d'un
fichier d'aide au format dvi extrèmement complet et clair, même s'il
est écrit en anglais. On y accède par une icône ou en tapant

\mup{?truc;}

pour avoir un renseignement sur \tt{truc}. Le petit ";" est là pour
dire à MuPAD que l'on veut que le résultat de l'instruction
s'affiche. Si l'on veut que MuPAD reste muet, on terminera par ":".

Vous pouvez accéder à une aide plus personnelle en me contactant 

\tt{descopau@yahoofr}

ou, si le problème est plus ardu, en vous inscrivant à la liste d'aide en français à l'adresse

\tt{http://www.aful.org/wws/compose\_mail/mupad/}





\subsection{Sauvons nos fichiers}

Pour faire de l'import-export de sessions mupad, le plus souple est de les enregistrer en mode texte pour pouvoir utiliser MuPAD au choix à partir d'un terminal, de xmupad ou d'un éditeur de texte.

Pour cela, vous pouvez par exemple créer un répertoire DocMuPAD et spécifier à MuPAD les chemins d'accés et de sortie en tapant pour les sorties 

\mup{WRITEPATH:="/home/moi/DocMuPAD";}
ou simplement \mup{WRITEPATH:="DocMuPAD";}

et pour les entrées

\mup{READPATH:="/home/moi/DocMuPAD";}
ou \mup{READPATH:="DocMuPAD";}

Ensuite, pour écrire  on tapera

\mup{machin:=[diff(cos(x)/(1+x\p 2),x)];}
\mup{write(Text,"test",machin);}

Maintenant, redémarrer le noyau et taper

\mup{read("test");}

Sinon, ouvrez MuPAD dans un terminal en vous plaçant dans le fichier de sauvegarde que vous aurez créé et un Ctrl S sauvera les fichiers dedans.

Vous pouvez même exporter vos résultats au format \LaTeX 

\mup{truc:=generate::TeX(\%);}

\mup{write(Text,"/home/moi/DocTeX/test.tex",truc)}




Et comme j'écris sous \LaTeX, voyez le résultat :

\bc

$\ds\left[- \frac{\sin\left(x\right)}{x^2 + 1} - \frac{2\
\, x\, \cos\left(x\right)}{{\left(x^2 + 1\right)}^2}\right]$


\ec

 ou tout simplement


\mup{generate::TeX(3/2);}

\subsection{Saisie des instructions}

On peut copier, coller comme sur toute machine unix en sellectionnant avec la souris par exemple puis en appuyant sur le bouton du milieu de la souris. On peut répéter une instruction tapée précédemment en utilisant la flèche haute, seulement si l'on est dans un terminal. On peut rappeler le dernier résultat donné par MuPAD en tapant \%, le n-ième résultat précédent en tapant \%n. MuPAD reste sourd tant qu'on a pas validé son résultat par la touche << entrée >>. Si l'on veut passer à la ligne sans que MuPAD n'enregistre tout de suite notre résultat, on appuie simultanément sur <<~shift~>> et <<~entrée~>>.

\mup{1+2} \mup{1+2;}  \mup{1+2:} \mup{\%*5;} \mup{1+2} \mup{ 3+4}  \mup{1+2;3+4;5+6:7*9;} \mup{\%3\textasciicircum 5} 

%On peut placer des commentaires en fin de ligne qui ne seront pas lus par MuPAD mais par vos %étudiants pour les aider à comprendre un programme

%\mup{32 + \# ceci est le symbole de l'addition \# 3 ;}
%\mup{32 / 8 ; \textbackslash\textbackslash Toujours plus fort  : une division !}
%\mup{2\textasciicircum 5; 2**6; \textbackslash\textbackslash deux manières de désigner %l'opération puissance}

Nous verrons bien d'autres caractères-clefs en temps utile. 





\subsection{variable et type}

Une variable est le nom d'un emplacement permettant de stocker un objet d'un type donné ( nombre entier, vecteur, courbe, ...la liste est longue ! ). On utilise pour cela la saisie <<~:=~>> Quand on écrit :

\mup{ a:=3/4;b:=3*x\p 3-2*x+7;}

                            

  on affecte à la variable <<~a~>> le nombre 3/4  et à <<~b~>> le polynôme $3x^3-2x+7$. Tant que ces variables n'auront pas été libérées de leur affectation elles conserveront ces valeurs .
  
  \mup{2*a; b+4*a;}
  
  Pour les libérer on écrit :

  \mup{delete(a);}
  
  \mup{2*a; b+4*a;}On peut placer des commentaires en fin de ligne qui ne seront pas lus par MuPAD mais par vos étudiants pour les aider à comprendre un programme

\mup{32 + \# ceci est le symbole de l'addition \# 3 ;}
\mup{32 / 8 ; \textbackslash\textbackslash Toujours plus fort  : une division !}
\mup{2\textasciicircum 5; 2**6; \textbackslash\textbackslash deux manières de désigner l'opération puissance}

  
  
 On peut toutes les libérer simultanément en faisant \tt{reset()},mais il est recommandé de bien réfléchir avant... 
     On retiendra qu' écrire  \tt{ a:=x} ne signifie pas donc pas <<~a égale x~>> mais  <<~ à a on affecte la valeur x~>>. La nuance réside dans le fait qu'il n'y a pas symétrie. Vérifiez le rapidement en tapant successivement 
     \mup{ r:=20;}  puis  \mup{32:=q;} 
     En mathématiques , il n'est pas possible d'appliquer n'importe quel traitement à n'importe quelle variable (par exemple , on ne peut extraire la racine carrée d'un vecteur !), il en va de même en informatique . Avant d'appliquer une commande MuPAD à un groupe de variables , il faudra donc se demander 
     \been
     \item si elles sont bien du type qui convient 
     \item contrôler la syntaxe employée. 
      \een
        
Pour cela, on peut interroger MuPAD sur  le type d'une variable donnée


\mup{ type(3); type(3.0); type(6/2); type(1+2);type(3/2);type(I);type([I]) }


Le domaine \tt{DOM} renvoyé est le domaine informatique du caractère rentré. Vous aurez peut-être l'occasion un jour de faire la différence avec \tt{Dom} qui renvoie un domaine ayant des propriétés mathématiques et permettra de calculer avec des matrices à coefficients entiers, ou de calculer modulo 13 par exemple. 


\subsection{Travail sur les expressions numériques}

Amusons-nous un peu :

\mup{3\p (4\p 5);}

\mup{sqrt(3);}

Pas très parlant peut-être...alors utilisons la commande \tt{float} qui renvoie l'approximation décimale d'un nombre

\mup{float(sqrt(3));}

Et si l'on veut être plus précis

\mup{DIGITS:=1515; float(sqrt(3));}

La valeur par défaut de \tt{DIGITS}, qui donne le nombre de chiffres significatifs d'une approximation numérique est 10.

\mup{float(PI);}

Observez maintenant

\mup{reset();}

\mup{(2+sqrt(3))\p 32);}

Merci MuPAD, dîtes-vous. Très puissant ce logiciel ! Mais il suffit de lui demander ce que vous voulez vraiment 

\mup{expand(\%);}

Il n'est pas la peine de rappeler aux brillants anglicistes que vous êtes la signification du terme \tt{expand}.




Nous verrons d'autres fonctions du même type au moment de survoler
les outils algébriques.









\subsection{Résolution d'équations}

L'outil général est \tt{solve}

\mup{solve(x\p 2-4*x+3=0,x); solve(x\p 2-x+3=0,x);}

C'est assez classique et on retrouve cet outil sur les calculatrices
de base. Ce qui l'est moins, c'est la capacité de résoudre des
équations dépendant de paramètres.

\mup{S:=solve(x\p 2 - s*x\p 2+p=0,x):}

Vous avez remarqué que les solutions des premiers
exemples sont affichées entre accolades. Interrogeons MuPAD :

\mup{type(solve(x\p 2-4*x+3=0,x));}

La réponse \tt{DOM\_SET} nous indique qu'il s'agit d'un ensemble.
Nous verrons dans le paragraphe suivant consacré au calcul de 7! que
ceci a une grande importance. Pour en revenir à notre équation du
deuxième degré, l'ensemble des solutions comportera deux éléments,
ou plutôt opérandes en langage MuPAD. Nous pouvons demander à notre
logiciel préféré le premier élément de cet ensemble grâce à la
commande

\mup{op(S,1);}

qui affiche le premier opérande de l'ensemble \tt{S}.

Nous pouvons être également amenés à résoudre des équations non pas
sur $\bbc$ mais sur un intervalle donné. Par exemple, si nous
voulons résoudre l'équation $x^2=4$ sur $\bbr^+$, nous indiquerons à
MuPAD que notre $x$ doit être positif

\mup{assume(x>0);}

\mup{solve(x\p 2=4,x);}

On peut sinon utiliser les ensembles habituels avec les notations
suivantes

\bc

\begin{tabular}{|l l|l l|l l|}
  \hline
  % after \\: \hline or \cline{col1-col2} \cline{col3-col4} ...
  $\bbn$ & \tt{NonNegInt} & $\bbn^*$ & \tt{PosInt} & $-\bbn^*$ & \tt{NegInt} \\

  $\bbz$ & \tt{Integer} & $2\bbz$ & \tt{Even} & $2\bbz+1$ & \tt{Odd} \\

  $\bbq$ & \tt{Rational} & $\bbq^{*+}$ & \tt{PosRat} & $\bbq^{*-}$ & \tt{NegRat} \\
  $\bbr$ & \tt{Real} & $\bbr^+$ & \tt{NonNegative} & $\bbq^+$ & \tt{NonNegRat} \\
  $\bbr{*+}$ & \tt{Positive} & $\bbr{*-}$ & \tt{Negative} & $\bbc^*$ & \tt{NonZero} \\
  $i\bbr^*$ & \tt{Imaginary} & $i\bbz^*$ & \tt{IntImaginary} & $\bbp$ & \tt{Prime} \\
  \hline
\end{tabular}
\ec

\mup{assume(x in Type::Positive): solve(x\p 2-4=0,x);}


On peut résoudre également des systèmes linéaires

\mup{reset():solve(\{x+2*y+a*z=-1,a*x+y+z=2,2*x+a*y-z=3\},\{x,y,z\});}

Il existe des outils d'algèbre linéaire plus adaptés que nous
verrons plus tard.

On peut résoudre des inéquations

\mup{solve(x\p 2-2*x-4>=2*x,x);}

des équations trigonométriques

\mup{solve(cos(x)=sin(x),x);}

À vous d'imaginer d'autres situations...

Un <<~étudiant~>> taquin m'a par exemple proposé

\mup{solve(cosh(x)=I*sinh(x),x);}















\subsection{Simplifications et ré-écritures}

Voici un petit test booléen qui utilise la commande \tt{is} et ici l'égalité ( à distinguer de l'affectation \tt{:=} )

\mup{is(1+1=2);}

Continuons

\mup{is((x-1)*(x+1)=x\p 2-1);}

Tu parles d'un logiciel de calcul formel...

En fait, MuPAD ne comparera deux polynômes que s'ils sont sous forme développée. Les choses se compliquent s'il s'agit de polynômes à plusieurs indéterminées et dépendant de paramètres. Nous verrons ça plus tard...

Observons plutôt

\mup{y\p 2 +a*(x+z)*(x-z)+(x\p 2-y\p 2);}
\mup{x+a*(x+z)-(a-1)*(x+z);}

Ces problèmes viennent du codage informatique de certaines expressions. Nous n'entrerons pas dans les détails.

Voyons plutôt quelques commandes utiles. Nous avons déjà vu \tt{expand} qui développe une expression et qui peut être utile ici

\mup{expand(\%);}

\mup{expand((x+a+b)\p 3);}

Pour nous, $x$ est de manière conventionnelle la variable et $a$ et $b$ des paramètres. Ce n'est pas aussi évident pour MuPAD. Il suffit de lui expliquer que nous voulons privilégier $x$ grâce à la commande \tt{collect}

\mup{collect(\%,x);}

Notons, tant que nous y sommes que la commande \tt{expand} a d'autres talents cachés

\mup{expand(cos(a+b)); expand(sinh(3*x));}

En fait, ce n'est pas une surprise : MuPAD développe des formules du binôme en exponentielle.

Il existe parallèlement \tt{factor} qui se comprend bien. Explorez à l'aide de l'aide la commande \tt{combine} aux multiples talents.

\mup{combine(arctan(2*x)+arctan(y)+arctan(z),arctan);}

Dans le même ordre d'idée, \tt{partfrac} décompose une fraction en éléments simples.

Notez enfin que la commande \tt{simplify} peut parfois s'avérer utile car elle combine plusieurs des fonctions précédentes.

Il y a beaucoup à dire sur les polynômes car de nombreuses fonctions utiles existent, par exemple \tt{coeff, degreevec, ground, lcoeff, ldegree, lmonomial, lterm, monomials,
 nterms, nthcoeff, nthmonomial, nthterm, poly, poly2list, tcoeff,...}. En arithmétique des polynômes aussi \tt{gcd,lcm,gcdex,divide}. 
 
Ouvrons une petite parenthèse sur \tt{factor} : tout le monde sait que la factorisation de $X^2-2$ ne sera pas la même sur $\bbq[X]$ et sur $\bbr[X]$. MuPAD, lui, factorise sur $\bbq[X]$, parfois sur $\bbq[a,X]$, sachez-le.

\mup{factor(X\p 2-2);}

Pour ruser, on peut utiliser \tt{solve}

\mup{solve(x\p 2-2=0,x);}

Si nous ne pouvons pas factoriser dans $\bbr[X]$, on peut le faire dans $\bbz[X]$ par exemple en changeant le <<~ domaine~>>. Nous n'en parlerons pas tout de suite...















\subsection{Nombres complexes}

Nous nous contenterons d'un rapide survol de commandes qui se comprennent d'elles-mêmes.

La vedette du paragraphe est le nombre \tt{I} qui vérifie \tt{I*I=-1}

Observez 

\mup{expand((3+4*I)\p 2); Re(3+4*I); Im(3+4*I); conjugate(3+4*I); abs(3+4*I);}
\mup{exp(I*PI/3); rectform(exp(I*PI/3)*(1+I)\p 2); arg(6+2*I*sqrt(3));}
\mup{float(exp(I*PI/3))}















\subsection{Calculs en analyse}

Les fonctions usuelles sont notées selon les conventions internationales et se comprennent bien

\mup{cos(PI); sin(PI/4)\p 2; tan(-x); arctan(tan(32*PI)); arctan(tan(a)); }

Un petit rappel :

\mup{assume(-PI/2<a<PI/2): arctan(tan(a));}
 
 \mup{E-exp(1); ln(32*E); expand(ln(32*E)); float(ln(32*E))}
 
 Pour être complet, sachez que MuPAD utilise le logarithme complexe $z\mapsto \ln_{\bbr}|z|+i\arg z$.
 
 \mup{ln(I);}
 
 C'est pourquoi on observe 
 
 \mup{exp(ln(x)); ln(exp(x));}
 
 \mup{log(2,8); log(10,100000);}
 
Puisqu'on en parle, la commande \tt{sqrt} est aussi définie sur $\bbc$

\mup{sqrt(32); sqrt(-32);}

et MuPAD fait mieux que certains élèves de lycée

\mup{(u\p (1/4))\p 4; (u\p 4)\p (1/4); }

Quelques commandes utiles :

\mup{abs(-32); floor(-1.2); frac(-1.2); sign(-1.2); trunc(-1.2); round(1.3); round(1.6); max(1,2,3); min(1,2,3);}

Enfin, nous pouvons calculer sommes et produits 

\mup{sum(k,k=0..32); sum(k, k=0..n); partfrac(\%); sum(1/n\p 2, n=1..infinity);  product((1-1/k),k=2..32);}

Ici, la notation \tt{0..32} symbolise l'intervalle entier $[\![0,32]\!]$.











\subsection{Limites}

Pour les limites, pas de grand mystère

\mup{ limit(sin(x)/x,x=0); limit(x/exp(x),x=infinity); limit(x/exp(x),x=-infinity);}\mup{limit(sin(x)/x,x=infinity); limit((1-1/n)\p n, n=infinity)}
\mup{limit(cos(x),x=infinity); limit(1/x,x=0);}

Pour le dernier calcul, il faut être plus précis

\mup{limit(1/x,x=0,Left); limit(tan(x),x=PI/2,Right);}

Pour information, si vous avez le courage, vous pouvez vérifier dans la librairie que MuPAD calcule les limites à partir de développements en séries.
 

Vous aurez sans doute remarqué que MuPAD attend une expression en argument de la commande \tt{limit}  et non pas une fonction.

Il faudra bien faire la différence entre 

\mup{f:= x+ln(x);}


 où \tt{f} est une expression et 

\mup{g:=x->x+ln(x);}

où \tt{g} est une fonction. En effet

\mup{f(1); g(1); f(2); g(2); x:=2: f; f(2);  g(E);}
 
 MuPAD peut transformer une expression en fonction à l'aide de la commande \tt{fp::unapply(expr,var)}
 
 \mup{h:=fp::unapply(f,x); h(32);}
 
 
 \mup{limit(g(x),x=0);}

Pourquoi ?

\mup{g(x); delete(x): g(x); limit(g(x),x=0); limit(g(x),x=0,Right);}




Après les limites, la continuité, ou plutôt la discontinuité avec la commande \texttt{discont(f(x),x)}

\mup{discont(1/sin(x),x); discont(1/sin(x), x=-10..10);}

Vous aurez remarqué que \tt{-10..10} représente l'intervalle réel $[-10,10]$. 







\subsection{Dérivation}

Là encore, il faudra distinguer expression et fonction, la commande n'étant pas la même

\mup{D(tan); D(tan)(x); diff(tan(x),x);}

Pour les dérivées successives

\mup{diff(tan(x),x,x); diff(tan(x),x\$5);  collect(\%,tan(x)); (D@5)(tan); }

Et si l'on a oublié certaines formules

\mup{D(u*v); D(u/v); D(u@v);}

sachant que \tt{@} est l'opérateur de composition de fonctions.


On a accés de la même manière aux dérivées partielles

\mup{diff(x\p 2*y,x);diff(x\p 2*y,y);diff(x\p 2*y,x,x);diff(x\p 2*y,y,x);}

Enfin, dans le cas de fonctions d'une seule variable, on peut utiliser l'apostrophe \tt{'}

\mup{tan'(x);}










\subsection{Primitives, calcul intégral}

La commande-clef est \tt{int}

\mup{int(ln(x),x); int(1/sin(t),t);}

MuPAD n'est pas omniscient

\mup{int(exp(x\p 3),x);}

On peut calculer des intégrales sur des segments

\mup{int(1/(1+t\p 2), t=0..1);  int(exp(x\p 3),x=0..1); float(\%);}

\mup{int(ln(t\p 2),t=-1..1); int(ln(t),t=0..1); }

ou sur des intervalles non bornés

\mup{int(1/t\p 2,t=1..infinity); int(1/t,t=-1..1);}

Notez que MuPAD calcule les intégrales au sens des intégrales impropres et non pas au sens de Lebesgue

\mup{int(sin(t)/t,t=0..infinity);}

On peut calculer des intégrations par parties quand MuPAD semble bloqué ou effectuer des changements de variables. Ces commandes ne sont pas dans la librairie standard. Il faut aller les charger dans la librairie \tt{intlib} en tapant 

\mup{intlib::byparts(int(expression,variable),ordre)}

ou, si on est amené à utiliser cette librairie à plusieurs reprises, on la charge en tapant 

\mup{export(intlib);}

Enfin, on peut calculer des intégrales multiples

\mup{int(int(2*r*cos(t)\p 2,t=0..2*PI),r=0..R);}

\subsection{Développements limités et généralisés}

On peut utiliser \tt{taylor}

\mup{taylor(tan(x),x=0,15); taylor(1/(1+x\p 2),x=-2,15); taylor(f(x),x=0,5);}

Notez que MuPAD utilise des grands O. 

On peut effectuer des opérations sur les développements

\mup{taylor(sin(x),x=0,15)/taylor(cos(x),x=0,15);}


effectuer des développements généralisés

\mup{taylor(sqrt(x+sqrt(x\p 2+1))-sqrt(x+sqrt(x\p 2-1)),x=infinity,5);}

Si vous n'avez besoin que de  la partie polynomiale du développement, utilisez la commande \tt{expr}

\mup{expr(taylor(tan(x),x=0,9));}








\subsection{\'Equations différentielles}


Nous ne ferons qu'effleurer les possibilités de MuPAD en ce domaine. La résolution se fait en deux étapes qu'on peut d'ailleurs combiner.

Tout d'abord, il s'agit de saisir l'EDO à l'aide de la commande 

\bc
\tt{ode(\{équation,CondInit\},FonctionInconnue(Variable)}
 \ec
 
 On peut le rentrer de manière naturelle

\mup{ode(y''(t)+4*y(t)=sin(t),y(t));}

et MuPAD traduit sous la forme $f(y'(t),y(t),t)=0$

\mup{ode(- sin(t) + 4 y(t) + diff(y(t), t, t), y(t))}


Il ne reste plus qu'à résoudre à l'aide de la commande \tt{solve}

\mup{solve(\%);}

Nous nous contenterons de cette approche algébrique.


\subsection{Les nombres entiers}

Ici encore, nous nous contenterons d'un survol. Des activités spécifiques sont proposées dans les chapitres suivants. 

Les commandes de base sont \tt{a div b} et \tt{a mod b} qui renvoient respectivement le quotient et le reste de la division euclidienne de \tt{a} par \tt{b}.

Il y a aussi \tt{gcd(a,b)} et \tt{lcm(a,b)} qui donnent respectivement le pgcd et le ppcm des entiers \tt{a} et \tt{b}. 

On peut obtenir la factorisation en produit de facteurs premiers à l'aide de \tt{factor(n)}

\mup{factor(123456789);}

On peut tester si un entier est premier

\mup{isprime(123456789); isprime(3803);}

Il y a aussi 

\mup{nextprime(123456789);}

Il y a surtout un grand nombre de fonctions dans la librairie \tt{numlib} que je vous conseille d'explorer. 














 
 \subsection{Algèbre linéaire}
 
 Ce domaine est abondamment exploré par MuPAD. Chacun pourra l'approfondir selon ses besoins. Donnons quelques lignes générales.
 
 Tout d'abord, avant de construire des matrices, MuPAD a besoin de savoir sur quel anneau vous voulez travailler.
 
 Par exemple, en rentrant
 
 \mup{Mq:=Dom::Matrix(Dom::Rational);}
 
 vous indiquez que vous allez travailler avec des coefficients rationnels, la dimension de votre espace n'entrant pas en ligne de compte.
 
 Nous verrons que faire du \tt{Mq} ensuite. \'Enumérons d'abord  différents domaines. L'anneau de base peut être
 
 \bel
 
 \item \tt{Dom::Integer} pour $\bbz$
 
 \item \tt{Dom::IntegerMod(13)} pour $\bbz/13\bbz$
 
 \item \tt{Dom::Rational} pour $\bbq$
 
 \item \tt{Dom::Real} pour des réels sans approximation
 
 \item \tt{Dom::Float} pour les approximations numériques des réels
 \item \tt{Dom::Complex} pour les complexes
 \item \tt{Dom::DistributedPolynomial([x],Dom::Integer)} pour travailler dans l'anneau des polynômes à coefficients entiers.
 
 
 \el
 
 Pour travailler dans un anneau quelconque, et si l'on veut utiliser des paramètres, il suffira de rentrer
 
 \mup{M:=Dom::Matrix()}
 
 Maintenant, il reste à renter les matrices.
 
 On peut la rentrer << à la main >> par lignes en rappelant le domaine dans lequel on travaille.
 
 Ici, nous travaillerons par exemple dans le domaine \tt{Mq} précédemment défini.
 
 \mup{A:=Mq([[1,2,3],[4,5,6],[7,8,9]]);}

\mup{B:=Mq([[1,0,1],[0,1,0],[1,1,2]]);}

puis effectuer les opérations usuelles

\mup{A+B; A*B; 1/B; 1/A; B\p 10; A*B-B*A; }

On peut créer des matrices de tailles diverses

\mup{a:=Mq(4,1,[1,2,3,4]);}

Les matrices sont en fait des listes\footnote{Suite d'éléments ordonnés écrits entre crochets} de listes, donc en particuliers des listes. On les traitera donc comme telles. Nous étudierons plus précisément les listes au chapitre suivant, mais sachez que vous pouvez appliquer une fonction à tous les coefficients d'une matrice à l'aide des commandes \tt{map(A,f)} et \tt{zip(A,B,f)}

\mup{M:=Dom::Matrix(); C:=M([[1,0,2],[0,3,0],[4,5,6]]); F:=map(C,cos); G:=zip(C,F,(x,y)->2*x\p 2-y);}

Pour la suite, nous aurons besoin de charger la volumineuse librairie \tt{linalg}

\mup{export(linalg);}

Impossible de parler de toutes les commandes. Faites-vous une idée en tapant

\mup{?linalg;}

On peut au moins parler du déterminant, du polynôme caractéristique

\mup{det(A); det(B); charpoly(A,X);}


des valeurs propres

\mup{eigenvalues(F); \# pour rigoler...\#}

Accordons quelques instants aux résolutions de systèmes linéaires. Plusieurs méthodes d'entrée sont possibles.

Tout d'abord, nous pouvons rentrer les systèmes de manière naturelle grâce à la commande \tt{expr2Matrix(liste des équations, liste des variables)} (en anglais expréchione tou matrix) qui transforme comme son nom l'indique une expression en matrice. On peut rentrer en troisième argument optionnel le domaine des coefficients, par exemple \tt{Dom::Integer}. Ainsi

\mup{S:=expr2Matrix([x+2*y+3*z=4,y+7*z=6,x+y+z=3],[x,y,z]);}



puis

\mup{matlinsolve(S);} affiche le triplet solution, s'il existe.

Nous aurions pu sinon rentrer une matrice carrée représentant le système linéaire et une matrice colonne afin de résoudre l'équation $AX=B$.

\mup{A:=M([[1,2,3],[0,1,7],[1,1,1]]); B:=M(3,1,[4,6,3]); matlinsolve(A,B);}




















\subsection{Et le reste}

Il est impossible d'être exhaustif. Nous n'avons exploré qu'à peine 1\% des commandes de MuPAD. Explorez l'aide, les librairies, pour vous rendre compte que MuPAD est très riche et contient des modules exploitables bien au-delà du premier cycle universitaire. Notons simplement que nous n'avons pas évoqué la librairie \tt{stats} pourtant très importante que les spécialistes pourront décortiquer.





















\section{Quelques exercices de MAO (maths assistées par ordinateur)}

\exot{Noyau, image}

Qu'est-ce que l'endomorphisme de $\bbr^2$ d'expression analytique canonique

$$\bsyc x'&=&-\fr{1}{5}x-\fr{2}{5}y\\y'&=&\fr{3}{5}x+\fr{6}{5}y \esyc$$

Vous aurez besoin de déterminer la matrice A associée, le noyau de A grâce à \texttt{nullspace(A)} qui  en renvoie une base, l'image avec
\texttt{basis(A)}. Ensuite, à vous d'essayer des petits calculs sur A pour deviner sa nature.


\exot{Puissances de matrices}

\been

\item
 Soit $\ds A=\frac{1}{3}\bmat
0&-2&-2\\
2&0&-1\\
2&1&0 \emat $.



\been
\item
Calculer $A^2,A^3$ et $A^4$.
\item \m $\{A,A^2,A^3,A^4\}$ est un groupe pour le produit matriciel de $\mathcal{M}_3(\bbr)$.
%\item Que peut-on dire de ce groupe ?
\een


\item
Pour chacune des matrices $A$ suivantes, calculer $A^n$ pour tout $n\in\bbn$. \been
\item $\bmat 1&a\\ 0&1\emat$ avec $a\in\bbr$.
\item La matrice $J_p$ de $\mathcal{M}_p(\bbr)$ dont tous les
coefficients sont égaux à 1. \een \een

\exot{Inverse d'une matrice}

Soit $A=\bmat 1&0&a\\ 1&a&-1\\a&0&1 \emat$. Pour quelles valeurs de $a$, la matrice $A$ est-elle inversible. Calculez alors l'invesre de $A$.


\exot{EDO}

 Testez  MuPAD sur les équations suivantes \been
\item $(x+1)y'-xy=0$
\item $(1+x^2)y'+xy=3x^3+3x\qquad (1+x^2)y'+xy=1$
\item $xy'+2y=x/(1+x^2)$
\item $y'=|y|$
\item $\sqrt{1-x^2}y'-y^2-1=0$
\item $y''-3y'+2y=xe^x+\sin(x)$
\item $x^2y''+3xy'+y=0$
\een


\exot{Division euclidienne de polynômes}

\been

\item 
On voudrait conjecturer à l'aide de MuPAD le reste de la division euclidienne de $A$ par $B$ sachant que $A=\pa{(\sin t)X+\cos t}^n$ par
$B=X-1$.

Déterminez ce reste pour des valeurs particulières de $n$. Conjecture~? Prouvez votre conjecture...

Reprenez le même exercice avec $B=X^2+1$. Pour vous aider dans votre conjecture, vous pourrez utiliser la fonction \texttt{combine(expr,sincos)}
qui permet de linéariser une expression trigonométrique et la fonction \texttt{coeff(p,x,n)} qui permet d'isoler le coefficient
du polynôme p en $x^n$.


\item Montrez que $A=X+3X^2+5X^3+5X^4+3X^5+X^6$ divise $B=(X+1)^{6n+1}-X^{6n+1}-1$. Vous pourrez utilisez au choix la fonction
\texttt{solve(equation,inconnue)} ou \texttt{factor(polynome)} pour trouver les racines de $A$.

\een



\exot{Avec sommation}

Trouvez la valeur de $\ds\sum_{n=1}^{+\infty}\fr{1}{1^2+2^2+\cdots+n^2}$





\exot{Trigo}

Résolvez l'équation $\arccos(x)=\arcsin(2x)$

\exot{\'Etudes de fonctions}

\been

\item \'Etudiez la fonction $x\mapsto x\arctan(x)$ en portant une attention particulière au comportement asymptotique.

\item \'Etudiez $x\mapsto \sqrt[5]{(x^2-1)^2(x+11/3)}$.

\een


\exot{Ipp}

On pose $I_n=\int_0^{\pi/2}\sin^nt\,\text{d}t$. Exprimez $I_{n+2}$ en fonction de $I_n$.


\exot{Système}

Résoudre $\bsyc x+ay+z+t&=&1\\x+y+az+t&=&b\\x+y+z+at&=&1 \esyc$


\exot{Mini-chaînes de Markov...}


\subsubsection*{Aidons la mafia}

Les chaînes de Markov sont issues de la théorie des probabilités et utilisent des outils d'algèbre linéaire qui nous intéressent aujourd'hui. Elles permettent de simuler des phénomènes aléatoires qui évoluent au cours du temps. Nous allons les découvrir à travers l'étude d'un exemple simple.

Zlot, Brzxxz et Morzgniouf sont trois villes situées respectivement en Syldavie, Bordurie et Bouzoukstan. Des traficants de photos dédicacées du groupe ABBA prennent leur marchandise le matin dans n'importe laquelle  de ces villes pour l'apporter le soir dans n'importe quelle autre. On notera pour simplifier $V_1$, $V_2$ et $V_3$ ces villes et $p_{ij}$ la probabilité qu'une marchandise prise le matin dans la ville $V_i$ soit rendue le soir dans la ville $V_j$. La matrice $(p_{ij})_{1\ie i \ie 3\\ 1\ie j\ie 3}$ est appelée \textit{matrice de transition} de la chaîne de Markov. Que s'attend-on à observer sur les colonnes d'une matrice de transition ?

Supposons que $P$ soit connue et vaille $$P=\bmat 0,8 &0,3 &0,2\\ 0,1&0,2&0,6\\ 0,1&0,5&0,2\emat$$

Les traficants se promenant de ville en ville, il peut être utile de visualiser leurs déplacements par le  \textit{diagramme de transition} suivant

\begin{center}
\includegraphics[height=5cm]{Makov.1} 
\end{center}


On notera $x_i^{(k)}$ la proportion de traficants qui se trouvent au matin du jour $k$ dans la ville $V_i$. En probabilités, on appelle \textit{vecteur d'état} tout élément $(x_1,\cdots,x_n)$ de $\bbr^{+n}$ tel que $x_1+\cdots+x_n=1$. 

Ainsi, $x^{(k)}=\pa{ x_1^{(k)},x_2^{(k)},x_3^{(k)}}$ est un vecteur d'état.

On montre que les vecteurs d'état de la chaîne sont liés par la relation

$$x^{(k)}=P\cdot x^{(k-1)}$$

et donc

$$x^{(k)}=P^k\cdot x^{(0)}$$


Supposons que le chef de la mafia locale dispose de 1000 traficants qui partent tous le matin du jour 0 de la ville de Zlot. Quelle sera la proportion de traficants dans chacune des villes au bout d'une semaine ? d'un mois ? d'un an ?

\bigskip

Le parrain voudrait que la  proportion moyenne  de traficants soit stable d'un jour sur l'autre. Il recherche donc les vecteurs d'état $x$ vérifiant l'équation $P\cdot x=x$. Vous apprendrez après l'été à résoudre de manière systématique ce genre de problème. Nous allons pour l'heure nous débrouiller sans appui théorique mais avec Maple et la fonction \texttt{linsolve(A,B)} qui permet de résoudre les équations du type AX=B avec A une matrice, B un vecteur connu et X le vecteur inconnu. Comment procéder ?

\subsubsection*{Météo}

\`A Morzgniouf, les jours sont soit secs, soit pluvieux. On désigne par $E_1$ l'état sec et $E_2$ l'état pluvieux et par $p_{ij}$ la probabilité qu'un jour soit dans l'état $E_i$ sachant que le jour précédent était dans l'état $E_j$. Les scientifiques Bouzouks ayant observé les phénomènes météorologiques des trent-deux dernières années à Morzgiouf ont établi la matrice de transition suivante

$$P=\bmat 0,750&0,338\\0,250&0,662\emat$$

Sachant qu'il fait beau aujourd'hui, quelle est la probabilité qu'il pleuve dans dix jours ?




\vspace{2cm}



Il est temps de passer aux choses sérieuses avec cette activité de niveau Terminale.
















\setcounter{num}{0}







\section{Initiation à la programmation : 7 manières de calculer 7!}


\been

\item Bien sûr, on peut commencer par faire \mup{7!;}
mais le calcul de $7!$ n'est qu'un prétexte pour découvrir sur un
exemple simple la syntaxe de programmation MuPAD.

\item On pourrait alors taper \mup{1*2*3*4*5*6*7;} mais les choses
pourraient se compliquer au moment de calculer $3232!$

\item Nous allons donc utiliser une boucle $for$ avec indice
numérique : nous partons de 1, puis nous multiplions par 2, puis
nous multiplions le produit précédent par 3, etc. Cela donne

\mup{p:=1: for k from 1 to 7 step 1 do p:=p*k end\_for;}
 
 Ce programme
n'est pas optimum. En fait, dans une boucle \tt{for}, l'instruction  \tt{step} est facultative : elle vaut par
défaut 1. Ici, on peut se contenter de \mup{p:=1 for k from 1 to 7 do
p:=p*k end\_for;}
 

\item Nous aurions pu créer la liste des entiers de 1 à 7 puis
utiliser une boucle $for$ indexée cette fois par les éléments de
la liste. C'est plus compliqué, mais cela nous permet de découvrir
comment MuPAD traite les listes. Il faudra bien distinguer 

\bel
    \item les \textbf{ensembles} (\texttt{set}) qui sont des collections \textsl{non ordonnées} d'expressions
 toutes différentes séparées par des virgules et encadrées
 d'accolades.
 
 \mup{ens1:=\{2,4,1\}; ens2:=\{2,5,8,5\};}
 
 
 On peut effectuer les opérations usuelles sur les ensembles
 
 \mup{ens1 intersect ens2; ens1 union ens2; ens1 minus ens2;}
 l'ensemble vide se note \mup{\{ \}}
 
 
     \item les \textbf{suites} (\tt{sequence}) qui sont des collections
     \textsl{ordonnées} d'expressions, différentes ou non,
     séparées par des virgules et encadrées ou non par des
     parenthèses.
     
     \mup{5,7,5,1,2,3;}
     
     
     On peut aussi utiliser l' opérateur
     \texttt{\$} pour des suites définies par une formule explicite
     
     \mup{p\p 2 \$ p=1..5;}
     \mup{m \$ 5;}
     
     \mup{j\p 2 \$ j=1..n; }
     pose problème.
     \item les \textbf{listes} (\tt{list}) qui sont des collections
     \textsl{ordonnées} d'expressions séparées par des virgules et
     encadrées par des crochets. La différence, c'est qu'une
     suite, en tant que juxtaposition d'expressions, est  en quelque sorte <<~en lecture seule~>>, alors
     qu'une liste est une expression en elle-même et pourra donc
     <<~subir~>> des opérations algébriques.

     Notez au passage quelques fonctions utiles
     \mup{s1:=i \$ i=-2..2; s2:=a,b,c,d,e;}
     \mup{l1:=[s1]; l2:=[s2]; \# une liste est une suite entre
     crochets\#}
     \mup{nops(l2); \# nombre d'opérandes \#}
     \mup{l2[3];  \# extrait le 3ème opérande \#}
     \mup{l2[3..5]; }
     \mup{select (l1,x->x>0)}
     \mup{subs(l2,b=32); subsop(l1,2=z); subsop(l2,5=null()); \# pour
     substituer ou supprimer un opérande, null() étant la liste vide \#}
     \mup{map(l2,cos);}
     \mup{zip(l1,l2,(x,y)->x+y);}
     \mup{l3:=l1.l2; \# pour concaténer\#}
     \el

\medskip

Cela donne \mup{reset();} \mup{l:=[k \$ k=1..7]: p:=1: for i from 1 to 7
do p:=p*l[i] end\_for: p;}


\item Nous pouvons utiliser une boucle \tt{while}
\mup{reset();} \mup{p:=1: k:=1: while k<7 do k:=k+1: p:=p*k end\_while:
p;}

\item C'est bien beau, mais que ferons-nous quand il faudra
calculer 32! ou 3232! et tous les autres~? Il faudrait créer un
programme (on dira une \textbf{procédure}) qui donne $n!$ pour
tout entier naturel $n$. 

\mup{reset(); \# je ne vous le dirai plus
\#}
 
 \mup{fac:=proc(n)\\ local p,k; \# nous aurons besoin de
variables locales i.e. internes à la procédure, comme des variables d'intégrations à l'intérieur d'une intégrale \# \\
begin \\
p:=1; \\ for k to n do p:=p*k end\_for; \\ end\_proc: \# termine la procédure
\#}\mup{fac(32);}

\item Le meilleur pour la fin : la \textbf{procédure récursive},
qui s'appelle elle-même
 
 \mup{factr:=proc(n)\\ begin \\ if n=0 then 1 \# une
boucle \tt{if...then...else} pour régler le cas de 0! \# \\ else
n*factr(n-1)\\ end\_if; \# symbolise la fin de la boucle \# \\ end\_proc:}
\mup{factr(32);} En fait, ce mécanisme correspond à une suite
numérique qui s'écrirait mathématiquement $u_n=n\times u_{n-1}$.



\een
























\section{Des petits exercices de programmation}


\subsection{Les énoncés}

\exo Déterminez une procédure \texttt{E:=proc(x)} qui, à un réel
positif $x$, associe sa partie entière.

\exo Déterminez une procédure \texttt{ab:=proc(x)} qui, à un réel
$x$, associe sa valeur absolue.

\exo Déterminez une procédure permettant de calculer la moyenne
des éléments d'une famille de nombres réels.

\exo Pour $n\in\bbn^*$, on considère $a_n=1+1/n$ et
$b_n=a_n^{{a_n}^{.{^{.{^{.{^{a_n}}}}}}}}$, avec <<~$n$ fois
$a_n$~>>.

Par exemple, $b_2=(3/2)^{3/2}$.

\been
\item Déterminez une procédure qui calcule $b_n$ à partir de $n$.
\item On admet que la suite $(b_n)$ est décroissante et converge
vers 1. Déterminez une instruction qui permette de déterminer le
plus petit entier $n$ tel que $b_n\ie 1,001$.\een




\exo Vous savez peut-être que la suite $(S_n)_{n\in\bbn}$ de terme
général
$$S_n=\ds\sum_{k=0}^n\fr{1}{k!}$$
est croissante et converge vers $e$. Nous l'admettrons dans cet
exercice. \been
\item Déterminez une procédure \texttt{S=proc(n)} qui, à un entier
naturel $n$, associe $S_n$. N'oubliez pas les gages habituels :
vous n'utiliserez ni la fonction prédéfinie \texttt{sum}, ni les
procédures calulant $n!$ vues précédemment.
\item Déterminez une procédure \texttt{seuil:=proc(p)} qui, à un
entier naturel $p$, associe le plus petit entier naturel $n$ tel
que $|S_n-e|\ie10^{-p}$. Vous aurez besoin de savoir que $e$ se
dit \texttt{exp(1)} en Maple. \een

\exo Déterminez une procédure \texttt{sol:=proc(a,b,c)} qui, à une
équation $ax^2+bx+c=0$, associe son ensemble des solutions.

\exo Déterminez une procédure \texttt{test:=proc(l)}, \texttt{l}
étant une liste d'entiers, qui teste si ses éléments forment une
suite croissante.

\exo Vous connaissez tous la formule du triangle de Pascal.
Déterminez donc une procédure récursive \texttt{c:=proc(n,p)} qui
calcule les coefficients du binôme. Testez avec \texttt{c(32,3)}
et \texttt{c(3,32)}.



\subsection{Des solutions}
\setcounter{num}{0}

{Les solutions proposées} sont loin d'être les seules.
Vous avez vu par exemple sept méthodes pour calculer 7!, et il en
existe d'autres. Et puis, les solutions proposées ne sont pas
forcément les meilleures : n'hésitez pas à faire part de vos
idées.


\exo \mup{E:=proc(x) begin
local n;
n:=0;
while n<x do n:=n+1 end\_while: n-1;
end\_proc:
}


\exo \mup{ab:=proc(x) begin
if x>=0 then x else -x end\_if;
end\_proc:}


\exo \mup{moy:=proc(l)
local s,k; begin
s:=0;
for k from 1 to nops(l) do s:=s+l[k] end\_for: s/nops(l);
end\_proc:}

Notez qu'il faut rentrer une liste en argument, donc entre crochets. Vous remarquerez que nous sommes confrontés à un petit problème technique : nous avons plutôt l'habitude d'utiliser des approximations numériques pour les moyennes. Il existe pour cela la fonction \texttt{float(nombre)}. Le nombre de chiffres par défaut est 10. On peut le faire varier grâce à la variable \tt{DIGITS:= nombre}. Remarquez enfin que MuPAD fait la différence entre \tt{1/3} et \tt{1/3.0}. Par exemple, comparez \texttt{(1/3+2/3)-1}
 et \tt{1/3+2/3.0)-1}

 

\exo  \mup{bn:=proc(n)
local a,b,k; begin
a:=1+1/n;
b:=1;
for k from 1 to n do b:=a\p b end\_for:
b
end\_proc:
}


Le résultat est un peu illisible. On peut utiliser la fonction \tt{simplify(nombre)}, mais le résultat est un peu faiblard. Mieux vaut faire intervenir \tt{float} dans la procédure.


\exo
 
" ...le plus petit entier tel que..." nous fait penser à une boucle
while
 
 \mup{m:=1:
while bn(m)>1.001 do m:=m+1 end\_while:
m;}


\exo

La ruse est d'introduire deux variables en plus de l'indice : t
pour le terme et s pour la somme


\mup{S:=proc(n)
local s,t,k; begin\\
s:=1: t:=1:
for k from 1 to n do t:=t/k: s:=s+t \\
end\_for:
s
end\_proc:}



Par curiosité, essayez
\mup{float(S(32)-exp(1));}

Comment y remédier~?


Passons à la question suivante :

\mup{DIGITS=1000:\\
seuil:=proc(s)
local n; begin\\
n:=0:
while float(exp(1)-S(n))>float(1/10\textasciicircum s) do n:=n+1 end\_while: 
n;
end\_proc:}




\exo

Rien de très difficile mathématiquement parlant, mais cela
nous permet de découvrir la fonction elif, contraction de else if qui
permet d'accéder à une sous-boucle if.


\mup{sol:=proc(a,b,c)
local d,x1,x2: begin\\ 
d:=b\p 2-4*a*c:\\
if d>0 then  x1:=(-b-sqrt(d))/(2*a): x2:=(-b+sqrt(d))/(2*a):
elif d=0 then  x1:=-b/(2*a): x2:=x1 :
else  x1:=(-b-I*sqrt(-d))/(2*a): x2:=(-b+I*sqrt(-d))/(2*a) :
end\_if;
if d<>0 then print("Les solutions sont ".expr2text(x1). "et " .expr2text(x2)):
else print ("La solution est ".expr2text(x1)):
end\_if;
end\_proc:}

Il y a bien sûr plus court


\mup{solv:=proc(a,b,c) begin\\
solve(a*x\p 2+b*x+c=0,x);
end\_proc:}














\section{Premier exemple d'application en terminale : méthode de Newton et dichotomie}

Vous savez de quoi il s'agit, donc je me contente de donner le résultat :


On construit un programme dépendant de la donnée d'une fonction \texttt{f}, d'une précision \texttt{e} et d'un premier terme \texttt{u0}.

\mup{Newton:=proc(f,e,u0)} \mup{ local un,aun,fp,k;} \mup{ begin} \mup{ fp:=D(f);\# fp est la dérivée de f} \mup{ k:=0; \# On règle le
compteur des itérations à zéro} \mup{aun:=u0; \# l'ancien un vaut au départ u0} \mup{ un:=u0-f(u0)/fp(u0);\# calcul du terme suivant}
\mup{ while abs(un-aun)>e do
 \# tant que la précision n'est pas atteinte, on réitère}
\mup{aun:=un; un:=un-f(un)/fp(un);} \mup{ k:=k+1;\# un tour de plus au compteur} \mup{ end\_while;}
\mup{print(Unquoted,expr2text(float(un))." est la solution trouvée à ".expr2text(e)."  près après ".expr2text(k)." itérations");}
\mup{end\_proc:}

On regarde ce que cela donne

\mup{Newton(x->x\p 2-2,10\p (-4),2);}

\bs


Pour la dichotomie, la procédure dépend toujours de \texttt{f} et \texttt{e} et aussi des bornes \texttt{a} et \texttt{b} de l'intervalle

\mup{dicho:=proc(f,e,a,b)}


\mup{ local aa,bb,k;}


\mup{ begin}


\mup{ aa:=a;bb:=b; \# les anciennes bornes valent au départ a et b }

\mup{ k:=0; \# le compteur est mis à zéro}

 \mup{while (bb-aa)>e do}

     \mup{if sign((f((bb+aa)/2)))=sign((f(bb))) then   bb:=((aa+bb)/2):}

     \mup{else  aa:=((aa+bb)/2):}

     \mup{end\_if:}

\mup{ k:=k+1;}

\mup{ end\_while;}

\mup{ print(expr2text(float((bb+aa)/2))." est la solution trouvée à ".expr2text(e)." près après ".expr2text(k)." itérations");}

\mup{ end\_proc:}

Il ne reste plus qu'à appliquer et à comparer

\mup{dicho(x->x\p 2-2,10\p (-4),1,2);}



























\section{Deuxième exemple d'application en terminale : arithmétique}

\textsl{Voici des extraits d'activités que j'ai proposées en terminale cette année.}

\subsection{Tests et cribles}


Nous pouvons  tester si un nombre est premier :

\sm

\mup{test1:=proc(n)}

\mup{ local L;}

\mup{ begin}

\mup{ L:=[]; \# On crée une liste, vide au départ, pour y placer les éventuels diviseurs de n\# }

\mup{ for i from 2 to floor(sqrt(n)) do \# floor signifie partie entière \# }

\mup{ if n mod i = 0 then L:=L.[i]: end\_if \# si le reste est nul, on ajoute i à la liste \#}

\mup{ end\_for;}

\mup{ if L=[] then print(expr2text(n). " est premier" ); \# si L est vide,  n est premier \# }

\mup{ else print(expr2text(n).  " n'est pas premier" ); end\_if}

\mup{ end\_proc:}

\sm

\mup{test1(1321235158);}

                      "1321235158 n'est pas premier"
\sm

\mup{test1(101!+1);}

 Error: Computation aborted; during evaluation of 'test1'

\sm

Ce test a donc des limites et nécessitera de nombreuses améliorations.



\bigskip




 Mais nous pouvons faire mieux~:~nous pouvons obtenir rapidement une liste des
$petits$ entiers premiers inférieurs à un nombre donné $n$ : on écrit les entiers de 2 à $n$ et on barre les multiples des nombres
premiers inférieurs à $\sqrt{n}$. Les entiers restant sont premiers. Nous ne sommes pas les premiers à avoir eu cette idée, Eratosthène
l'a eu avant nous en 240 avant JiCé.



\mup{Erato:=proc(n)} \mup{ local x,i,y,P;} \mup{ begin} \mup{ x := array(1..n); \# On crée une liste de n nombres \#}

\mup{ for i from 1 to n do}

\mup{ x[i]:=1;  \#ces nombres valent tous 1 au départ\#}

 \mup{ end\_for;}

 \mup{x[1]:=0;    \#1 n'est pas premier donc on le "raye" en lui associant 0\#}

\mup{ for y from 2 to floor(sqrt(n)) do    \#on teste les entiers jusqu'à Vn (floor = partie entière)\#}

 \mup{if(x[y]=1) then     \#si le yème nombre n'est pas barré\#}

 \mup{for i from 2 to floor(n/y) do}

 \mup{x[i*y]:=0;   \#on barre tous ses multiples\#}

 \mup{end\_for;}
 \mup{end\_if;}
 \mup{end\_for;}
 \mup{P:=[];     \#on crée une liste vide\#}
 \mup{for i from 1 to n do}
 \mup{if(x[i]=1) then P:= P.[i];   \#on ajoute tous les entiers non barrés\#}
 \mup{end\_if;}
 \mup{end\_for;}
 \mup{P;    \#on affiche la liste des entiers restant : ils sont premiers\#}
 \mup{end\_proc:}

\sm

Cela nous donne :

\sm

\mup{Erato(100);}

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]




\subsection{Décomposition des entiers en produit de nombres premiers}




Pour obtenir un programme donnant la décomposition d'un entier donné, nous allons utiliser la procédure \texttt{Erato} mise au point
précédemment qui renvoie la liste des entiers premiers inférieurs à un nombre donné.







\mup{decompo:=proc(n)}

\mup{ local L,l,D,N;}

\mup{begin}

\mup{ D:=[]: L:=Erato(n): l:={op(L)}: N:=n:} \# l est l'ensemble des nombres premiers inférieurs à n \#

\mup{  while not(contains(l,N)) do} \# tant que N n'est pas premier \#

\mup{   for k from 1 to nops(L) do} \# nops(L)= nb d'éléments de L \#

\mup{    if N mod L[k]=0 then D:=D.[L[k]]; \# si le kième premier divise N, on le rajoute à la liste\#}

\mup { N:=N div L[k]; \# on divise N par ce nb premier \#}

\mup{     break; \# on recommence à la 5ème ligne des fois que le kième premier divise encore n\#}

\mup{      end\_if; end\_for; end\_while;}

\mup{      D:=D.[N]; \# on n'oublie pas n si n est premier}

\mup{      end\_proc:}

\sm

\mup{decompo(50);}

                  \mup{               [2, 5, 5]}



\sm

Pour être honnête, il existe la fonction \texttt{factor} qui donne directement la décomposition en produit de facteurs premiers.

\mup{factor(50);}


                 \mup{               2 5$^2$}








\subsection{Petit théorème de Fermat}



Nous avons mis au point sur le modèle du crible d'Eratosthène une méthode permettant de tester si un entier est premier ou non. Cela
marche assez bien pour des petits nombres, mais cette méthode devient impraticable s'il s'agit de tester un entier d'une centaine de
chiffres. Nous allons nous occuper dans cette section de deux problèmes imbriqués : d'une part trouver des méthodes permettant de
vérifier rapidement si un nombre est premier et d'autre part réfléchir à d'éventuelles méthodes permettant de <<~fabriquer~>> des nombres
premiers aussi grands que l'on veut.

\sm


 <<~\textit{A thing of beauty is a joy for ever. Its loveliness increases; it will never Pass into
nothingness}~>> écrivait John Keats 217 ans après la naissance de Pierre de Fermat, dont le Petit Théorème demeure un joyau de la
théorie des nombres, malgré les innombrables découvertes effectuées depuis dans ce domaine. S'il est qualifié de petit, c'est qu'une
conjecture célèbre du même Fermat, restée indémontrée pendant des siècles, s'est accaparée le titre de \textsl{Grand Théorème de Fermat}.

$$ x^n+y^n=z^n\quad \text{n'a pas de solution dans }\bbn^3\quad\text{pour } n>2$$

Dans la marge d'un manuscrit, Fermat prétendait en avoir trouvé la démonstration mais manquer de place pour l'écrire. Il a pourtant fallu
attendre 1995 pour qu'Andrew Wiles le démontre en utilisant des outils surpuissants : l'entêtement d'une multitude de chercheurs a abouti
à la démonstration de ce théorème, mais surtout a permis de développer d'importants outils en théorie des nombres. Quant à lui trouver
des applications, le problème reste ouvert.

\sm

Au contraire, notre petit théorème, bien moins <<~médiatique~>> et à la démonstration  abordable, a eu de très nombreuses et importantes
conséquences : nous allons en étudier quelques-unes.

\sm

Mais tout d'abord, comment l'idée de son théorème est venu à l'esprit de l'ami Pierre~?

Au cours de ses nombreuses recherches, Fermat s'est intéressé aux nombres de Mersenne\footnote{Nous en reparlerons plus abondamment un
peu plus loin} qui sont les nombres de la forme $M_n=2^n-1$, avec $n$ un entier premier. On savait déjà que $M_{11}$ était composé
$$2^{11}-1=2047=23\times89\ (i)$$
Mais c'est Fermat qui remarqua que $$2^{23}-1=8388607=47\times178841\ (ii)$$

Il sauta aux yeux de Fermat qui vivait parmi les entiers, que $47=2\times23+1$ en observant $(ii)$ ce qui lui mit la puce à l'oreille
pour observer que $23=2\times11+1$ dans $(i)$. Qu'en dire~? Que le plus petit diviseur premier d'un nombre composé $2^p+1$ est de la
forme $2p+1$~?

Le problème, c'est que $2^{29}-1=536870911=233\times1103\times2089$, et donc, ça ne marche pas. D'ailleurs, ce n'est pas ce qui attira
l'attention de Fermat. Il remarqua en effet que dans $(i)$, non seulement $23=2\times 11+1$ mais aussi $89=8\times11+1$. De même dans
$(ii)$, $47=2\times 23+1$ et $178\,481=7\,760\times23+1$. Il conjectura donc que tout diviseur premier de $2^p-1$ est congru à 1 modulo
$p$.

\sm

Mais l'ami Pierre ne s'arrêta pas là. On a $2^{11}\equiv 1[23]$, mais on a le même résultat avec $2^{22}$, $2^{33}$, etc. De même,
$2^{11}$, $2^{22}$,...,$2^{88}$, etc. sont tous congrus à 1 modulo 89. Et puis $2^{23}$, $2^{46}$, etc. sont congrus à 1 modulo 47 et
enfin $2^{23}$,...,$2^{178\,480}$, etc. sont aussi tous congrus à 1 modulo $178\,481$.

\sm

Oui, et alors. Et bien, pour ces quatre nombres premiers, on a $2^m\equiv 1[p]$, mais surtout, dans chaque cas, l'un de ces $m$ est
$p-1$.

En bref, pour les nombres premiers 23, 89, 47 et 178481, on a $2^{p-1}\equiv 1[p]$. Est-ce vrai pour $tous$ les entiers~? Nous qui avons
un bel ordinateur, menons une petite enquête :

\mup{fer:=proc(a,n) local k;}

\mup{begin}

\mup{for k from 1 to n do}

\mup{[ithprime(k),pmod(a,ithprime(k)-1,ithprime(k))]; \# ithprime(k) donne le kème nb premier}

\mup{end\_for; end\_proc:}

\sm

\mup{fer(3,15);}

\begin{center}

[[2, 1], [3, 0], [5, 1], [7, 1], [11, 1], [13, 1], [17, 1], [19, 1],

   [23, 1], [29, 1], [31, 1], [37, 1], [41, 1], [43, 1], [47, 1]]

\end{center}




Occupons nous maintenant du théorème lui-même, énoncé pour la première fois par Fermat en 1640 dans une lettre adressée au fameux Frère
Marin Mersenne.

\ENC{\Thm}{Soit $p$ un nombre premier et $a$ un entier non divisible par $p$. Alors $a^{p-1}-1$ est divisible par $p$, ou, en d'autres
termes $$a^{p-1}\equiv1[p]$$}

Comme d'habitude, Fermat affirma avoir la démonstration mais ne pas avoir la place de l'écrire à son correspondant\footnote{Fermat
était-il malhonnête ou avare de son encre~?}


Il existe de très nombreuses démonstrations de ce théorème. Nous en verrons trois, une maintenant, une à titre d'exercice et une comme
cas particulier d'un théorème plus général, le théorème d'Euler.

\sm

La plus rapide consiste à montrer que $a^{p-1}(p-1)!=a\times 2a\times 3a\times\cdots\times (p-1)a$ est congru à $(p-1)!$ modulo $p$ puis
d'en déduire le résultat. Nous aurons besoin d'établir deux petites propriétés\footnote{Un petit exercice d'entraînement consiste à les
démontrer}.

\ENC{\Prop}{Soit $p$ un nombre premier et $a$ un entier, alors $p$ divise $a$ OU $p$ et $a$ sont premiers entre eux.}

\ENC{\Prop}{Soit $p$ un nombre premier et $a$ et $b$ deux entiers. Si $p$ divise $ab$, alors $p$ divise $a$ ou $p$ divise $b$.}



Considérons donc les multiples successifs de $a$ jusqu'à $(p-1)a$ et appelons $r_k$ le reste de la division de $ka$ par $p$.

\bel
\item Montrons d'abord qu'aucun $r_k$ n'est nul : en effet, si $p$ divisait $ka$, alors il diviserait $a$ ou $k$, or il ne divise pas $a$
par hypothèse et il ne divise pas $k$ car $k\ie p-1$.

\item Montrons maintenant que ces restes sont deux à deux distincts : s'il existe deux entiers $k$ et $k'$ tels que $r_k=r_{k'}$, alors
$ka\equiv k'a[p]$, puis $a(k-k')\equiv0[p]$, ce qui veut dire que $p$ divise $a(k-k')$. On peut donc conclure comme tout à l'heure.

\item On obtient donc que $a^{p-1}(p-1)!=a\times 2a\times 3a\times\cdots\times (p-1)a\equiv r_1\times r_2\times \cdots\times r_{p-1}[p]$.
Or les $r_k$ sont $p-1$ entiers distincts compris entre 1 et $p-1$ : il s'agit donc exactement des entiers de 1 à $p-1$ à l'ordre près,
donc leur produit est égal à $(p-1)!$

On obtient donc que $a^{p-1}(p-1)!\equiv (p-1)!\,[p]$

\item Pour conclure, on montre facilement que $p$ est premier avec $(p-1)!$. Or $p$ est premier avec $(a^{p-1}-1)\bigl((p-1)!\bigr)$ et on utilise
une troisième fois le théorème de Gauss pour conclure que $p$ divise $a^{p-1}-1$. \el

\sm

Et maintenant...une petite illustration MuPAD, évidemment...

On utilisera la fonction \texttt{ n mod d } qui renvoie le reste de la division de \texttt{n} par \texttt{d}.

\mup{2\p (97-1) mod 97;}

\begin{center}
                                  1
\end{center}




Choisissons maintenant  un nombre premier quelconque grâce à la fonction \texttt{nextprime}

\mup{p:=nextprime(10\p 20);} 100000000000000000039

puis un nombre entier quelconque inférieur à $10^{12}$

\mup{random();} 321110693270

calculons $a^{p-1}$ modulo $p$

\mup{a\p (p-1) mod p;}

\begin{center}

Error: Overflow/underflow in arithmetical operation

\end{center}

C'est trop gros : serions-nous donc encore une fois condamnés aux petits nombres~? Eh bien non, il est temps d'utiliser notre cerveau~!
Et aussi l'algorithme d'exponentiation rapide vu précédemment.

\label{pmod}

 \mup{pmod:=proc(a,n,p)
 local B,A;}

\mup{begin}

\mup{ A:=a mod p:
 B:=1; \# Pour simplifier car on travail modulo p}


 \mup{while n<>0 do}


 \mup{  if n mod 2=0
      then A:=(A*A mod p); n:=n/2 \# si n pair, on élève au carré et on divise la puissance par 2}

  \mup{ else B:=(B*A mod p); n:=n-1 \# sinon, on enlève une puissance pour obtenir une puissance paire}


 \mup{end\_if
 end\_while;}

 \mup{B}

\mup{ end\_proc:}

Cette fois-ci on a la réponse, et en plus, instantanément~!

\mup{pmod(321110693270,100000000000000000039-1,100000000000000000039);}

                                     1

Comme quoi, quand on arrive aux limites des possibilités calculatoires d'un ordinateur, rien ne vaut un bon cerveau.

\sm

C'est bien joli tout ça, amis à quoi ça peut servir~?

Prenons un grand nombre, assez compliqué pour avoir l'air premier, par exemple

\mup{n:=10\p 100*random()\p 3+32!+32*random()+13;}

n:=17416995007052249019952126647441817600000000000000000000000000000000000000
0000000000000000000000000\\0263130836933693530167241908282577229



Est-ce que ce nombre de 136 chiffres est premier~? Si tel est le cas, alors $2^{p-1}\equiv1\,[p]$\footnote{pourquoi~?}

Jetons donc un coup d'œil

\mup{pmod(2,n-1,n);}

10929185996403668155132301645171677938973308556359031603915090554003250963
7112385597262131870063544874\\4642860847610628382268616793816279


Ouh la la, ça ne fait pas 1~! Donc $n$ n'est pas premier, et la réponse a été donnée immédiatement, en quelques mili-secondes~! C'est
quand même assez fort : on arrive, grâce au \textit{petit} théorème de Fermat, à montrer qu'un entier de 136 chiffres pris au hasard
n'est pas premier\footnote{Ça peut paraître impressionnant comme ça, mais MuPAD s'avérera ridiculement minable quand il s'agira de tester
des nombres d'un million de chiffres. Mais bon, c'est un début...}.


Maintenant, que se passe-t-il si le résultat est effectivement 1~? Cela fait-il de $n$ un nombre premier~?


%Par Suzanne  c'est  ma doudou d'amour et ROSE aussi c'est ma doudou d'amour








Par exemple, vérifiez que $2^{341-1}\equiv 1\,[341]$, et pourtant $341=11\times 31$. On dit que 341 est $pseudopremier$.


Voici un petit programme pour trouver les premiers nombres pseudo premiers :

\mup{pseudo:=proc(a,n) local i,L;}

\mup{ begin}

\mup{ L:=[];}

\mup{ for i from 3 to n step 2 do if not(isprime(i)) and pmod(a,i-1, i)=1 then L:=L.[i];}

\mup{ end\_if; end\_for:}

\mup{ L;}

\mup{ end\_proc:}

\mup{ pseudo(2,2000);}

\begin{center}
                  [341, 561, 645, 1105, 1387, 1729, 1905]
\end{center}

\mup{pseudo(3,3000);}

\begin{center}

 [91, 121, 671, 703, 949, 1105, 1541, 1729, 1891, 2465, 2665, 2701, 2821]

\end{center}


 Pour des nombres
plus grands, il n'est pas facile de savoir s'ils sont réellement premiers. Puisqu'on ne sait pas a priori s'ils le sont, on les appelle
des nombres probablement premiers  de base $a$. Certains sont PP d'une seule base. Par exemple


\mup{pmod(2,340,341)}

\begin{center}
          1
\end{center}

\mup{pmod(3,340,341);}

                              \begin{center}
                              56

\end{center}


Ainsi, nous pouvons multiplier les bases pour éliminer les candidats. Malheureusement, il existe encore une infinité de nombres qui sont
PP dans toutes les bases ,tout en étant composés :

\ENC{\Def}{Un entier composé $n$ est un \textbf{nombre de Carmichael} si $a^{n-1}\equiv 1[p]$ pour tout entier $a$ premier avec $n$}





Pour se donner un ordre de grandeur, il y a un peu plus d'un million de nombres premiers inférieurs à 25 milliards, mais seulement
$21\,853$ pseudo premiers et parmi eux $2\,163$ nombres de Carmichael. C'est peu, mais c'est toujours trop~!

Malheureusement, les choses se compliquent un peu par la suite et nous devons jeter l'éponge à notre niveau faute d'outils algébriques.

Nous pouvons seulement démontrer quelques lemmes menant à des tests fort puissants mais pour l'instant hors d'atteinte.






\subsection{Système RSA}

Nos amis Ronald \textbf{R}ivest, Adi \textbf{S}hamir et Leonard \textbf{A}dleman  mirent au point en 1977 un système de codage alors qu'ils essayaient au départ de montrer que ce qu'ils allaient
développer étaient une impossibilité logique : aah, la beauté de la recherche...Et savez-vous quel est la base du système~? Je vous le
donne en mille : le petit théorème de Fermat !
Mais replaçons dans son contexte les résultats de R, S et A. Jusqu'il y a une trentaine
d'années, la cryptographie était l'apanage des militaires et des diplomates. Depuis, les banquiers, les mega business men et women, les
consommateurs internautes, les barons de la drogue et j'en passe ont de plus en plus recours aux messages codés. Oui, et alors ? Le
problème, c'est que jusqu'ici, l'envoyeur et le destinataire partageait une même clé secrète qu'il fallait faire voyager à l'insu de tous
: les états et l'armée ont la valise diplomatique, mais les autres~?

C'est ici que Whitfield Diffie et Martin Hellman apparaissent avec leur  idée de principe qu'on peut résumer ainsi : votre amie Josette
veut recevoir de vous  une lettre d'amour mais elle a peur que le facteur l'intercepte et la lise. Elle fabrique donc dans son petit
atelier une clé et un  cadenas. Elle vous envoie le cadenas, ouvert mais sans la clé, par la poste, donc à la merci du facteur : le
cadenas est appelé \textit{clé publique}. Vous recevez le cadenas et l'utilisez pour fermer une boîte contenant votre lettre : le facteur
ne peut pas l'ouvrir car il n'a pas la clé. Josette reçoit donc la boîte fermée : elle utilise sa clé, qu'elle seule possède, pour ouvrir
la boîte et se pâmer devant vos élans epistolaires.

\sm

En termes plus mathématiques, cela donne : je fabrique une fonction $\pi$ définie sur $\bbn$ qui possède une réciproque $\sigma$. On
suppose qu'on peut fabriquer  de telles fonctions mais que si l'on ne connaît que $\pi$, il est (quasiment) impossible de retrouver
$\sigma$. La fonction $_pi$ est donc la clé publique : vous envoyez $\pi$(message) à Josette. Celle-ci calcule
$\sigma\bigl(\pi($message$)\bigr)=$ message. Josette est la seule à pouvoir décoder car elle seule connaît $\sigma$.

Tout ceci était très beau en théorie, mais Diffie et Hellman n'arrivèrent pas à proposer de telles fonctions. Mais voici qu'arrivent
Ronald, Adi et Leonard...



\sm

Je vais vous présenter la méthode en effectuant les calculs grâce à MuPAD. Il ne vous restera plus qu'à prouver mathématiquement que tout
ceci fonctionne de manière cohérente...

\sm

Nous aurons tout d'abord besoin d'un programme \texttt{num} qui transforme un message écrit en majuscule en un nombre entier et un
programme \texttt{alph} qui effectuera la démarche inverse. Je vous les livre sans explications car leur fabrication ne nous intéresse
pas arithmétiquement parlant\footnote{Les curieux pourront toujours me demander des éclaircissements}.

\mup{num:=proc(m) local l,L;}

\mup{begin l:=numlib::toAscii(m): L:="":}

\mup{for i from 1 to nops(l) do L:=L.expr2text(l[i]) end\_for:}

\mup{text2expr(L); end\_proc:}

\sm

\mup{num("TU ES LE MEILLEUR");}

\begin{center}

8485326983327669327769737676698582


\end{center}


\bigskip

\mup{alph:=proc(n) local l,L;}

\mup{begin L:=[]: l:=expr2text(n):}

\mup{for i from 0 to length(l)-1 step 2 do L:=L.[text2expr(substring(l,i,2))] end\_for:}

\mup{numlib::fromAscii(L); end\_proc:}

\sm

\mup{alph(67697665327065738432767978718469778083328185693274693276693283657383327779\textbackslash \\
7832806585868269328069847384328469726983837378);}

\begin{center}

  "CELA FAIT LONGTEMPS QUE JE LE SAIS MON PAUVRE PETIT TEHESSIN"

\end{center}



\bigskip

Ceci étant dit, je vais vous montrer comment quelqu'un peut m'envoyer un message crypté en utilisant le protocole RSA, que personne ne
peut comprendre sauf moi, puis comment je vais décrypter ce message.

Avant de m'envoyer un message, on doit connaître ma \textit{clé publique}, connue de tous et constituée d'un couple de nombres $(n,e)$.

Et avant de connaître cette clé, il faut que je la fabrique - secrètement - de la manière suivante :

\bel

\item je commence par fabriquer un nombre premier quelconque mais suffisamment grand

\mup{p:=nextprime(857452321345678945615348675153785313513545313135435153);}

\begin{center}

857452321345678945615348675153785313513545313135435373

\end{center}

\item puis un autre

\mup{q:=nextprime(9574138786465743137483136984548364156838461638468343648634);}

\begin{center}

9574138786465743137483136984548364156838461638468343648643

\end{center}

Ces deux nombres ne sont connus que de moi !



\item je forme le produit de ces deux nombres

\mup{ n:=p*q;}

\begin{center}

82093675273407530411052298901582616385829265287443229928970780910295559020\textbackslash \\ 56474475310091712645082731005145648839

\end{center}

Ce nombre $n$ est mon module public. Il reste à former le nombre $e$ qui est ma puissance de cryptage publique. Là encore, cela se fait
par étapes.

\item je commence par former le nombre phi\_n (tiens, tiens...) de la manière suivante

\mup{phi\_n:=(p-1)*(q-1); }

\begin{center}

82093675273407530411052298901582616385829265287443229833220818522424670856\textbackslash \\ 27722142086573770493107547223666564824


\end{center}


\item c'est là qu'il faut jouer avec la chance : je dois choisir un nombre $e$ premier avec phi\_n. En pratique, je choisis un grand
nombre premier au hasard :

\mup{e:=nextprime(4568531538443156358743168741353);}

\begin{center}
                    4568531538443156358743168741447

\end{center}

Vérifions quand même que $e$ et phi\_n sont premiers entre eux

\mup{gcd(e,phi\_n);}

\begin{center}
1
\end{center}

Ouf!...\footnote{Pouvait-on en être sûr~?}

\item il me reste à calculer ma puissance de décryptage secrète : je l'obtiens en cherchant l'inverse de $e$ modulo phi\_n, c'est à dire,
comme vous commencez à le savoir puisque nous l'avons vu plusieurs fois,
en déterminant un coefficient de Bézout grâce à l'algorithme d'Euclide étendu.

Le problème, c'est que nos nombres sont un peu grands pour faire l'algorithme à la main, mais...heureusement, il y a MuPAD. Il existe en
effet une fonction \texttt{igcdex(x,y)} qui renvoie le PGCD de $x$ et $y$, ainsi que des coefficients de Bézout $u$ et $v$ qui vérifient
donc $ux+vy=x\wedge y$

\mup{igcdex(e,phi\_n); }


\begin{center}

1,

-3361567809152329663900803663149438561922098863965207972589810567505057256\textbackslash \\ 485280235971052358778352121022620510929

   , 1870720065045301962451071430061

\end{center}

Ceci veut dire que $u e+v$ phi\_n$=1$, avec $u$ le deuxième nombre renvoyé par MuPAD et $v$ le troisième. Ainsi $ue\equiv 1$[phi\_n],
mais $u$ n'est pas forcément l'inverse de $e$ modulo phi\_n, car il n'appartient pas forcément à l'intervalle entier
$[\![0,$phi\_n$-1]\!]$. Il suffit de calculer sa classe modulo phi\_n

\mup{d:=-3361567809152329663900803663149438561922098863965207972589810567505057256\textbackslash \\
485280235971052358778352121022620510929 mod phi\_n;}

\begin{center}
48477997181884233772044262270088230766608276647791150107322712847374098291\textbackslash \\ 42441906115521411714755426201046053895


\end{center}




\el


Je suis maintenant prêt à recevoir des messages cryptés selon le protocole RSA et vous êtes prêt(e) à m'en envoyer car j'ai rendu
publique ma clé $(e,n)$.


\bel

\item d'abord vous <<~numérisez ~>> votre message.

\mup{text\_num:=num("ESSAYE DONC DE DECRYPTER CE MESSAGE");}

\begin{center}

6983836589693268797867326869326869678289808469823267693277698383657169

\end{center}

\item comme nous allons calculer modulo $n$, il faut vérifier que text\_num est plus petit que $n$, en utilisant par exemple
\texttt{length}\footnote{Et qu'est-ce qu'on peut faire si text\_num est trop grand~?}

\mup{length(n);}

\begin{center}

                                    112
\end{center}


\mup{length(text\_num);}

\begin{center}

                                    70

\end{center}

\item ensuite, vous calculez ce nombre puissance $e$ et vous regardez quelle est sa classe modulo $n$ grâce à un petit programme mis au
point précédemment.

\mup{crypte:=pmod(text\_num,e,n);}

\begin{center}
35469233150717093648369621564213357837080328406430784459914432556683228305\textbackslash \\ 48957393046529574279084728520248267373

\end{center}

\item je reçois ce message et je le décrypte grâce à ma clé secrète $d$ que je suis le seul à connaître dans tout l'univers

\mup{decrypt:=pmod(crypte,d,n);}

\begin{center}

6983836589693268797867326869326869678289808469823267693277698383657169
\end{center}

\item il ne me reste plus qu'à retrouver mon texte original grâce à la procédure \texttt{alph}

\mup{alph(decrypt);}

\begin{center}

                   "ESSAYE DONC DE DECRYPTER CE MESSAGE"

\end{center}


Ça marche !




\el



Oui, bon, mais je devine que mille questions se bousculent déjà dans vos têtes : comment ça marche? Pourquoi ça marche ? Comment casser
le système~? etc.


Pour vous aider, voici quelques questions intermédiaires.

\been

\item Que vaut $\f(pq)$ si $p$ et $q$ sont premiers~?

\item Où intervient le théorème d'Euler~? Pourquoi a-t-on le droit de l'utiliser~? Vous pourrez montrez que si $a^u\equiv a[p]$ et
$a^u\equiv a[q]$, alors $a^u\equiv a[pq]$ en étudiant $a^u-a$.

\item À quelle opération mathématique correspond le <<~cassage~>> naturel du système~? Est-ce un problème facile~?

\item Supposons qu'un même texte en clair  $t$ est envoyé à deux personnes ayant choisi le même nombre $n$ et des exposants $e_1$ et $e_2$
premiers entre eux : on trouve facilement $u$ et $v$ tels que $ue_1+ve_2=1$. Alors les deux messages chiffrés sont $c_1\equiv t^{e_1}[n]$
et $c_2\equiv t^{e_2}[n]$. Montrez que, connaissant $c_1$, $c_2$, $e_1$, $e_2$ et $n$, on peut en déduire $t$, ce qui est fort gênant...


\een


\end{document}
