formations/poo/cours/algo.txt

Algorithmique
=============

Al-Kharezmi, auteur du traité "Kitab al jabr w'al-muqabala", est l'inventeur
des manipulations algébriques (algèbre = **al jabr**).
C'est Léonard de Pise, dit Fibonacci, qui emprunta le nom du célèbre
mathématicien arabe du 9ème siècle, mais l'algèbre existe
depuis bien plus longtemps (Depuis Babylone, puis ensuite l'Egypte ancienne).

.. glossary::


    algorithme

        terme désignant une suite d'opérations constituant un schéma de calcul
        ou de résolution d'un problème. C'est un processus systématique de
        résolution d'un problème permettant de décrire précisément des étapes.
        C'est une suite finie d'instructions permettant de donner la réponse à un
        problème.

L'algorithmique est l'étude et la production de règles et de techniques
qui sont impliquées dans la définition d'algorithmes.

Implémentation d'un algorithme
------------------------------

.. glossary::

    implémentation

        Adaptation de la méthodologie de calculabilité au calcul effectif
        sur une machine abstraite ou via un langage formel.

Il n’y a pas de parcours à sens unique de l’algorithme vers l’implantation.
La quête d’une implantation efficace nous amène souvent à effectuer
un retour vers les algorithmes eux-mêmes, et à en modifier des points
essentiels. L’aspect théorique de réflexion sur les algorithmes,
et l’aspect pratique de l'implémentation sont donc en symbiose.

Un existant émerge de la décomposition structurale d'un
domaine de base. Le fait essentiel, c'est la genèse des genres de l'existant les
uns à partir des autres.

L'essence d'une forme (un algorithme) se réalise au sein d'une matière qu'elle créée
(un langage). L'origine d'une matière fait naître les formes (concepts)
que sa structure dessine.

- Notion structurale de non-contradiction
- Notion extensive de "réalisation dans un champ donné"

Deux aspects réciproques : l'essence d'une forme se réalise au sein d'une
matière qu'elle crée, l'essence d'une matière faisant naître les formes que sa
structure dessine.

Abandonner l'idée trop simpliste de domaines concrets et d'opérations abstraites
qui posséderaient en eux-mêmes comme une nature de matière et une nature de
forme ; cette conception tendrait, en effet, à stabiliser les existants
mathématiques dans certains rôles immuables et ignorerait le fait que les
existants abstraits qui naissent de la structure d'un domaine plus concret
peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.

L'algorithme comme généralisation de la calculabilité
------------------------------------------------------

L'importance croissante de l'informatique comme outil scientifique
impose d'élaborer un nouveau mode de description des méthodes de calcul (appelées algorithmes)
susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
d'implémenter les calculs sur un ordinateur.

Exemple d'algorithme
---------------------

.. raw:: latex

    \begin{algorithm}
    \caption{L'alorithme de Bellman-Kalaba}
    \begin{algorithmic}[1]
    \Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
    \ForAll {$v \in V(G)$}
    \State $l(v) \leftarrow \infty$
    \EndFor
    \State $l(u) \leftarrow 0$
    \Repeat
    \For {$i \leftarrow 1, n$}
    \State $min \leftarrow l(v_i)$
    \For {$j \leftarrow 1, n$}
    \If {$min > e(v_i, v_j) + l(v_j)$}
    \State $min \leftarrow e(v_i, v_j) + l(v_j)$
    \State $p(i) \leftarrow v_j$
    \EndIf
    \EndFor
    \State $l(i) \leftarrow min$
    \EndFor
    \State $changed \leftarrow l \not= l’$
    \State $l \leftarrow l$
    \Until{$\neg changed$}
    \EndProcedure
    \Statex
    \Procedure {FindPathBK}{$v$, $u$, $p$}
    \If {$v = u$}
    \State \textbf{Write} $v$
    \Else
    \State $w \leftarrow v$
    \While {$w \not= u$}
    \State \textbf{Write} $w$
    \State $w \leftarrow p(w)$
    \EndWhile
    \EndIf
    \EndProcedure
    \end{algorithmic}
    \end{algorithm}

Exemple d'algorithme avec son implémentation
---------------------------------------------

Soit l'algorithme de factorielle suivant,

.. raw:: latex

    \begin{algorithm}
    \caption{Algorithme de la factorielle d'un nombre}\label{factorielle}
    \begin{algorithmic}[1]
    \Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
    \BState \emph{parametre} : $n$ entier
    \If{$n = 1$}
    \BState \emph{Sortie} : 1
    \Else
    \BState \emph{Sortie} : $n * \Call{factorielle}{n-1}$ \Comment{On appelle la fonction dans l'algorithme lui-même}
    \EndIf
    \EndFunction
    \end{algorithmic}
    \end{algorithm}

et son implémentation en python :

.. literalinclude:: code/factorielle.py
    :language: python

En voici une autre implémentation (en OCaml) :

.. literalinclude:: code/factorielle.ml
    :language: ocaml

On remarque que le **pseudocode** est très proche de
la syntaxe du python :

.. function:: factorielle(n:int)

::

       if n=1
          return 1
       else
          return n * factorielle(n-1)
       end if

Qualité d'un algorithme
-----------------------

- correction d'un algorithme
- complétude d'un algorithme

Sémantique

    Étude du sens, de la signification d'un langage
    Définir la sémantique d’un langage formel consiste à lui donner une
    signification mathématique.

Sémantique opérationnelle

    on définit la sémantique par sa mise en œuvre sur
    une machine abstraite.

Sémantique dénotationnelle

	on associe à chaque construction syntaxique un
	objet mathématique

Sémantique axiomatique

    chaque construction est décrite par la manière dont
    elle transforme des propriétés ou des prédicats.

Proposition

    une proposition est un énoncé qui est soit vrai, soit faux

**exemple** : ``2 + 3 = 5``. Proposition vraie.

Prédicats

    Une proposition dont la valeur de vérité dépend de la valeur d’une ou plusieurs variables

**Exemple** : ``n est pair`` : vrai pour n = 4 mais faux pour n = 9


Axiome

    une proposition qui est supposée vraie

Un ensemble d’axiomes est consistant s’il n’existe pas de proposition
dont on peut démontrer qu’elle est à la fois vraie et fausse.

Un ensemble d’axiomes est complet si, pour toute proposition, il est
possible de démontrer qu’elle est vraie ou fausse.

Théorème d’incomplétude de Gödel (1931) : tout ensemble
consistant d’axiomes pour l’arithmétique sur les entiers est
nécessairement incomplet.

**Les concepts de base en algorithmique sont les axiomes**

inférence

    règles d’inférence, règles permettant de combiner des axiomes et des
    propositions vraies pour établir de nouvelles propositions vraies.

Démonstration

    vérification d’une proposition par une séquence de déductions logiques
    à partir d’un ensemble d’axiomes.

Lorsque le champ donné (le domaine) ne contient qu'un nombre fini d'individus,
on peut définir un choix de valeur des variables permettant de vérifier la
proposition obtenue par la *conjonction* de tous les axiomes du système proposé.
On dit alors que ce choix *réalise* un système d'axiomes.


Il ne s'agit plus de savoir si la définition entraîne l'existence, mais de
chercher si la structure d'un système d'axiomes (*règles*) peut donner naissance
à un champ d'individus qui soutiennent entre eux les relations définies pas les
axiomes.

Concret et abstrait
--------------------

Il est possible qu'un même genre d'existant joue dans un schéma de genèse le
rôle d'abstrait par rapport à un concret de base, et soit au contraire dans une
autre genèse le concret de base d'un nouvel abstrait.

Une pareille présentation des choses implique un tel renversement par rapport
aux habitudes de pensée classiques, qu'il faut encore insister sur le sens
nouveau que reçoivent ici les expressions de "concret" et "d'abstrait".

Les systèmes d'axiomes sont souvent conçus comme des structures purement
formelles, abstraites. Ces structures sont si profondément engagées dans la
genèse de leurs réalisations, qu'il valait mieux désigner par ces termes les
structures de base.

Un système d'axiome *peut* devenir le concret de base.

Ceci permet d'exprimer non seulement l'engagement du concret dans la genèse de
l'abstrait, mais encore les relations d'imitation qui peuvent exister entre la
structure de cet abstrait et celle du concret de base.

Dans certains cas, la genèse de l'abstrait à partir d'un concret de base
s'affirme jusqu'à réaliser une imitation de structure entre ces genres
d'existants qui naissent l'un de l'autre.

**C'est pourquoi on représente souvent un algorithme en pseudo-code**,
c'est-à-dire en fait dans le mode de représentation (issu du langage préféré de la
personne qui l'exprime) dominant chez la personne qui exprime un algorithme.

Comment rendre un algorithme lisible
------------------------------------

- Le bon algorithme utilise des identifiants explicites.
- Le bon algorithme est structuré.
- Le bon algorithme est indenté.

Complexité d'un algorithme
--------------------------

On peut approximer la complexité des algorithmes.
C'est utile pour pouvoir comparer des algorithmes.

complexité

	estimer la complexité d'un algorithme, c'est estimer le nombre de calculs qu'il utilise.

Si f est la fonction caractérisant exactement le coût d’un algorithme et n
la taille des données, on s’intéresse à la façon dont augment f(n) lorsque n augmente
on va montrer que f(n) n'augmente pas plus vite qu’une autre fonction
g(n). Du point de vue mathématique, on dit que la fonction f est dominée
asymptotiquement par la fonction g ce qui se note f = O(g)

- Complexité temporelle : c’est le nombre d’op«erations effectuées par
  une machine qui exécute l’algorithme.

- Complexité spatiale : c’est le nombre de positions mémoire utilisées par
  une machine qui exécute l’algorithme.