(English) Binômes Projet 2 L3IF 2019

Débutants

AL-ASMAR Alice / CONOT Tristan
BAUER Esaie / MEKKI Anes
SIDI ALI CHERIF Mohamed / VARIN Zoe
GENEAU DE LAMARLIERE Paul

Intermédiaires

BAUMERT Sébastien
BERTHE Gaetan / DESRENTES Oregane
CHADDA Amel / PETIT-JEAN Coline
HERVOUIN Mathieu / DUBOIS Loic
MARCILLE Pierre-Marie / MICHEL Mathias
MARETTE Thibault / BERTRAND Jules
MARTIN Firmin / ROCTON Mathis
SORCI Emile / VESSERON Nina

Avancés

ROUSSEAU Guillaume / ALLORANT Baptiste
SAUVAGE Justine / MARTHE Alexandre
CORRADI Quentin / LO IACONO Marine
BATHIE Gabriel / BOILLOT Jerome
ROGET Mathieu / PASQUALE Valentin
GAZULL Yann-Situ / TRON Eliot

Informations M2 – 2019/2020

General Outline

The Master 2 in Computer Science is composed of research courses (CR)  from September 9, 2019 to January 20, 2020, followed by an internship from January 23 to June 15, 2020. Each course corresponds to 30 hours (typically 2 hours per week during 15 weeks, except for special courses). See details below.

Latest Information

Updated schedule and latest info will be available on the read-only password-protected pad :

https://pad.inria.fr/p/r.fe63ced1eb81edb1b8ee6bc300de5990

passwd: m2info19

List of Courses (for full description follow the link CRxx):

  • CR01: Cryptanalysis, Elena Kirshanova and Guillaume Hanrot (ENS Lyon)
  • CR02: Hardware compilation and simulation, Christophe Alias and Matthieu Moy (ENS Lyon)
  • CR03: Combinatorial scientific optimization, Bora Ucar, Fanny Dufossé (ENS Lyon, Grenoble)
  • CR04: Advanced topics in semantics of programming language, Pierre Clairambault and Colin Riba (ENS Lyon)
  • CR05: Automated deduction, and opening to distributed algorithms, Xavier Urbain and Sébastien Tixeuil (Lyon 1, Paris)
  • CR06: Machine learning, Aurélien Garivier (ENS Lyon)
  • CR07Network Information Theory, Jean-Marie Gorce and Samir Perlaza (INSA Lyon)
  • CR08: Graph-based knowledge representation (for complex systems and graph databases), Angela Bonifati and Russ Harmer (Lyon 1, ENS Lyon)
  • CR09: Hidden Markov models for time series classification and filtering, Stéphane Derrode (Centrale Lyon)
  • CR10: Data aware algorithms, Loris Marchal (ENS Lyon)
  • CR11: Modern algorithms for symbolic summation and integration, Bruno Salvy, Gilles Villard and Alin Bostan (ENS Lyon, Inria Saclay)
  • CR12: Parameterized and exact algorithms, Édouard Bonnet and Rémi Watrigant (ENS Lyon
  • CR13: Quantum information and computation, Guillaume Aubrun, Andre Chailloux and Omar Fawzi (ENS Lyon) (Lyon 1, Inria Paris, ENS Lyon)
  • CR14: Numerical methods for computer graphics, Julie Digne and Nicolas Bonneel (Lyon 1)
  • CR15: Advanced Topics in Cryptography, Alain Passelègue (ENS Lyon)
  • CR16: To be provided (ENS Lyon)

Special courses: There are 3 special courses (SCR). The special courses also last 30 hours but instead of having 2 hours per week, they run for 6 hours on Thursdays. Hence each special course runs in ‘compressed form’ for 5 Thursdays of the semester, 6 hours each, and every third Thursday in average. See the pad for the detailed schedule.

  • SCR01: Molecular programming, Nicolas Schabanel (ENS Lyon)
  • SCR02: Mathematical modeling and the numerical simulation of complex mechanical objects, Florence Bertails-Descoubes (Grenoble)
  • SCR03: Topological combinatorics, Frédéric Meunier and Matěj Stehlík (Paris, Grenoble)

Pre-course Meeting: A pre-course meeting will take place on Monday, September 9, 2019 at 9.30am, Amphi B. Attendance to this meeting is mandatory for all students. The general organization of the year and a description of the courses will be provided. Courses start on Monday, September 9, at 1:30pm.

Training Period: A mandatory training period takes place from Monday, January 23 up to mid June. An information session about topics and locations for the training period will be organized in September. Basically, the goal is to research in a laboratory (anywhere on earth), write a report and make an oral presentation in the end.

Schedule: Courses start September 9 at 1:30pm. Autumn holidays are October 28-November 3. Winter holidays are December 23-January 5. Exams will be held on week 3 (starting Monday Jan. 13), for a subset of courses. Again, the detailed weekly schedule will be available on the Inria pad mentioned above. This pad will be updated on a regular basis, check it often.

Rules of the Game: To obtain their degree, CS Master students must complete 60 credits including the internship (30 credits) and four courses (5 credits each) in the above list of CR1 to CR18. To summarize, there are 50 mandatory credits out of 60 and 10 remaining credits that can be picked elsewhere. While a typical choice by many students is 6 CR courses and the internship, the extra courses for the 10 remaining credits can be chosen elsewhere,  e.g. CS courses in the M2 offered by Univ. Lyon 1, or courses from other ENS departments.

Complex Systems: There is an orientation ‘Complex Systems’ that provides a multi-disciplinary choice. See details at

http://www.ixxi.fr/enseignement/master_systemes_complexes

for course offering. For the validation, the rules of the game apply, so students can pick 10 credits from complex systems courses. Note that ‘Complex Systems’ is an orientation, not a separate M2. The only diploma delivered by ENS Lyon is M2 Informatique Fondamentale, and computer science must remain at the heart of the curriculum. In particular, the training period must be oriented towards research in core computer science (possibly applied to other disciplines).

Formal Validation: To meet the quality requirements of our program, all course choices must be approved by the academic tutor and the head of the Master 2 program. Administrative registration to chosen courses is mandatory and takes place in late September, after a trial period.

Please refer to the rules of the Master here

Contact: Yves Robert

P2 L3IF — spécification de fouine

fouine — Syntaxe du langage

Cœur du langage fouine.
• expressions arithmétiques : constantes entières (y compris négatives), somme, soustraction, multiplication ;

• parenthèses ouvrantes et fermantes, construction begin.. end ; sauts à la ligne autorisés ;

• construction let .. in
Deux exemples : let a = 3 in 2*a + a*a et let f x = x*x in f (f 3).

• fonctions : on peut déclarer une fonction avec let f x z = .. ou avec let f = fun x -> fun z -> .. (ou un mélange des deux approches) ; on autorisera aussi fun a b c -> ...
On peut appliquer les fonctions comme dans f s t.
On peut utiliser une fonction directement sans la nommer (« fonctions anonymes ») let x = (fun x -> x) a in ...

• construction let rec (en deux mots), pour définir des fonctions récursives (pas de message d’erreur si la fonction n’est pas récursive). On ne s’intéressera qu’à des définitions récursives de fonctions. Les diverses écritures pour les fonctions seront acceptées (let rec f = fun x ->, et aussi let rec f x y z = .., ou encore let rec f = fun x y z -> ..)

if then else, uniquement avec des tests entre entiers ;
opérateurs à prendre en compte : > >= < <= = <> (vous pouvez ajouter not && ||, mais ça n’est pas imposé).
NB : il n’y a pas vraiment de type bool en fouine, au sens où un calcul renvoie soit un entier, soit une fonction, et les booléens n’apparaissent que dans la construction if then else.
NB2 : en fouine, tout est expression, et 27 est une expression au même titre que (fun x -> 1+2*x) 9.
NB3 : if then else, mais pas de if then tout court.

• Qu’est-ce qu’un programme ?

Un programme est une expression. Cette expression peut contenir des let .. in. Par conséquent, un programme est de la forme let .. = ... in ... ... let .. = ... in BLA.

En l’absence d’utilisation de prInt, un programme ne fait rien de visible (tout comme en Caml, à partir du moment où l’on n’utilise pas l’interprète mais le compilateur).

Il vous est en outre demandé d’autoriser les quatre facilités de saisie suivantes, pour les let.. in qui sont « en surface » (i.e., pas à l’intérieur d’un autre let.. in) :

-1- un ;; peut être utilisé à la place d’un « in » pour une construction let.. in ;
-2- au sein d’un enchaînement de let.. in se terminant par un ;;, il faut omettre le in (pour les let.. in qui sont « en surface ») ;

Ainsi, on peut écrire (et c’est « l’écriture canonique ») :

let a = 3 in
let b = 5 in
let c = 7 in
a*b*c

et, de manière équivalente

let a = 3
let b = 5
let c = 7;;
a*b*c

ou aussi

let a = 3;;
let b = 5
let c =7;;
a*b*c

Mais pas

let a = 3
let b = 5
let c = 7
a*b*c

ni des choses comme

let a = 3
let f x =
   let y = x*x
   let z = x*x*x in
y*y*z

(en effet, ci-dessus, « let y = ..  » et « let z = .. » ne sont pas en surface).

-3- vous devez aussi autoriser une séquence de let.. in sans le BLA final. Une telle entrée sera traduite en la même séquence de let.. in, suivie par « in 0 » ;
-4- vous devez autoriser l’utilisation du caractère « souligné » tout seul, dans des expressions de la forme let _ = ... in (et cela n’est pas réservé aux let.. in de surface). Cette utilisation sert à ne pas nommer une expression que l’on évalue (on l’utilise généralement lorsqu’on fait des effets de bord — affichage à l’écran, écriture dans un fichier, mise à jour de référence ..).

NB : Il serait très maladroit d’avoir plusieurs constructions dans votre interprète pour les diverses écritures possibles d’un let.. in.

• Un programme peut renvoyer un entier, ou une fonction (les conditions booléennes ne peuvent exister que dans les if then else).

Priorités etc. Là aussi, le comportement de Caml sert de référence. La principale difficulté est le traitement des applications lorsqu’une fonction est appliquée successivement à plusieurs arguments.

Vous n’avez en particulier pas le droit d’imposer à l’utilisateur d’ajouter davantage de parenthèses que ce qui est demandé en Caml.

Voici quelques exemples illustratifs :

# let add x y = x+y;;
val add : int -> int -> int =
# 3 + add 2 3;;
- : int = 8
# let k = 3 + (fun x -> x + 1) 5;;
val k : int = 9
# let k = 3 + fun x -> x + 1 5;;
Characters 12-28:
let k = 3 + fun x -> x + 1 5;;
               ^^^^^^^^^^^^^^^^
Error: This expression should not be a function, the expected type is int

La fonction prInt. On ajoute une construction spéciale au langage, pour pouvoir faire de l’affichage et ainsi voir ce que font les programmes. Cette construction s’appelle prInt, c’est une fonction qui affiche son argument entier, va à la ligne, et renvoie pour valeur ce même argument.
Voici un petit exemple :

# 2 + prInt (1+2);;
3
- : int = 5

En Caml (mais pas en fouine), on peut définir prInt comme suit :

# let prInt x = print_int x;print_newline(); x;;
val prInt : int -> int =

On se restreindra à des usages simples de prInt ; en particulier, on ne passera pas la fonction prInt à une fonction.

Affichage.

Vous devez programmer une fonction qui affiche un programme fouine. Afficher le programme saisi en entrée ne donne pas nécessairement le même programme, car il se peut que des transformations élémentaires soient appliquées au passage (par exemple, let f x =.. remplacé par let f = fun x -> ..). Il faudra toutefois que le programme affiché soit accepté par Caml, en supposant que l’on ait défini la fonction prInt comme ci-dessus.

Exécution des programmes.

Plutôt que de décrire formellement la sémantique opérationnelle de fouine, on adopte l’approche “lancez le programme avec Caml, cela vous donnera le comportement attendu”. Vous pouvez interagir avec les encadrants si vous avez des doutes sur un point précis.

Typiquement, de petits programmes comme let a = prInt 5 in a + prInt 7 ou let f x y = x*y in f (prInt 3) (2+prInt 2) vous permettront de vérifier que vous implémentez les choses comme il faut.
À noter qu’un calcul ne renvoie pas un booléen (tout du moins dans la version « de base » de fouine) : on ne manipule des booléens qu’au sein des tests dans des if then else.
NB : fouine n’est pas IMP, le petit langage vu en théorie de la programmation (pour ceux qui ont suivi ce cours) : il ne fait pas sens de séparer les expressions arithmétiques et les commandes, car « tout est expression » en fouine.

Les erreurs que ne connaı̂t pas Caml.
En Caml, un programme est typé, ce qui permet d’éviter d’exécuter des programmes absurdes comme 3 + (fun x -> x+1). Pas de typage en fouine, du coup certainsprogrammes exploseront lors de l’exécution.

Réfléchissez à la gestion de ces erreurs (appelées dynamiques), et proposez une solution plus ou moins satisfaisante. Cela peut aller de messages d’erreur un peu explicatifs dans certains cas (quand une addition fait intervenir une fonction, par exemple) à des choses plus sophistiquées, où l’on indique d’où vient l’erreur
dans le code source.

P2 L3IF — débutants Linux

Dans un terminal

  • la touche « tab » permettent de compléter la commande courante, les flèches haut et bas se promènent dans l’historique des commandes qui ont été saisies
  • tapez make pour compiler; pour « éteindre et rallumer », tapez make clean puis make
  • apprenez à vous promener dans vos répertoires à coups de cd (cd .. vous fait remonter d’un cran)
  • une fois que vos fichiers Caml sont dans un endroit déterminé, et que vous avez mis en place git pour les modifier, vous pouvez les éditer avec ce que vous voulez : vim, emacs, un environnement de développement sophistiqué, ..

Compiler et exécuter du code Caml.

  • on compile en tapant make. Il se débrouille pour comprendre quels fichiers il doit recompiler, et dans quel ordre. Il se sert d’ailleurs d’un sous-répertoire appelé _build, que vous n’avez pas à aller regarder, a priori.
  • quand on tape ./main.native < tests/t1.txt,

    on appelle le programme main.native, qui est dans le répertoire courant (c'est le "./"), en lui faisant manger le contenu du fichier t1.txt qui est dans le sous-répertoire tests

  • On ne "voit" ce que fait un programme Caml qu'à partir du moment où celui-ci interagit avec le monde extérieur. Typiquement, ce sont les fonctions d'affichage qui déclenchent quelque chose de visible. On trouve volontiers quelque chose comme
    let _ = f x y,
    invocation qui signifie "on lance le calcul de f avec x et y, et on ne donne pas de nom au résultat (le "_", c'est "pas de nom"). L'idée ici c'est que le calcul de f aura des effets sur l'univers (modification de certaines références, affichage, ..).
  • Pour faire des open dans l'interprête Caml, il faut les précéder de la commande #load.
    • On lance Caml avec une option pour lui dire de regarder dans le répertoire _build

      ocaml -I _build (il y a un "_" avant le build !)

    • On fait les incantations

      #load "cell.cmo";;

      open Cell;;

      et il connaît alors ce qui est défini dans le fichier cell.ml (à condition que vous ayez compilé cell auparavant).

  • Deux mots sur la question 3 du niveau Débutants du rendu 1.

    Pour récupérer dans un fichier les instructions du petit langage qui sert à modifier les cases du tableur, et les traduire en des valeurs Caml, on s'appuie sur ce que contiennent les fichiers lexer.mll et parser.mly.

    Il y a trois entités : la chaîne de caractères qui correspond au mot que l'on veut reconnaître (p.ex., "MULT", avec les guillemets, car c'est une chaîne de caractères) ; le mot du langage (on dit lexème, ou token) (p.ex., MULT sans guillements) ; et la valeur Caml à laquelle on aboutit (p.ex., M, qui est un constructeur du type oper, défini dans le fichier cell.ml).

    Dans lexer.mll, on associe le lexème MULT à la chaîne de caractères "MULT". Puis, dans parser.mly, on dit que le mot MULT est associé à M, ligne 47, après avoir déclaré vers le début du fichier que MULT est un lexème. On notera en passant que parser.mly contient des règles de grammaire, dans l'esprit de ce que vous avez vu en FDI.

Consulter la réservation des salles

Voici un petit tutoriel sur la réservation des salles à l’ENS de Lyon.

Allez sur http://planningsalles.ens-lyon.fr/

Vous devrez peut-être vous identifier, puis vous verrez quelque chose comme ceci :

Tapez ensuite le nom des salles dont vous voulez faire apparaître la réservation (par exemple, « Salle B1 », « Amphi B » — cf. plus bas), vous verrez quelque chose comme ceci :

Quelques commentaires :

  • Les salles « par défaut » en informatique sont l’amphi B et les salles (de TD) B1 et B2.
  • Les salles E001, 125 et 171 contiennent des ordinateurs sous Linux (pour les TPs).
  • Le planning des salles de maths (amphi A, salles A1 et A2) et des amphis du Département des Sciences de la Matière (amphis C à H) sont consultables également via l’interface décrite ci-dessus.
  • Un point important : lorsqu’on change la liste des salles dont on affiche le planning (soit en ajoutant une salle, soit en en supprimant une), le système nous ramène par défaut à la semaine en cours (tel est le comportement en octobre 2017, tout du moins). Cela est volontiers source de confusion, si vous êtes en train de regarder le planning pour un mois plus tard ; essayez de garder la chose à l’esprit !

Analyse de programmes et vérification de systèmes

Programme de l’UE :

  1. Structures ordonnées
    Ordres et topologies. Points fixes. Approximations et correspondances de Galois. Domaines de Scott
  2. Sémantiques dénotationnelles
    Domaines d’interprétation. Sémantique directe et par continuations.

    Correction et complétude de la Sémantique Axiomatique.
  3. Analyse de programmes
    3.1. Analyses dynamique et statique. Systèmes de types.

    3.2. Interprétation abstraite : principes, élargissement/rétrécissement,
    analyses avant et arrière, analyse polyédrale.
  4. Vérification
    4.1. Logiques modales. Structures de Kripke. Model checking.

    4.2. Systèmes réactifs. Logiques temporelles LTL et CTL.

Intervenants

CB-03 : Arithmétique des ordinateurs

Programme de l’UE

L’arithmétique des ordinateurs s’intéresse à la fois à la conception d’opérateurs arithmétiques, et à leur utilisation fine pour réaliser des fonctions plus complexes.

Ce cours présente un panorama des représentations utilisées en machine pour manipuler les nombres entiers, les réels et les polynômes, ainsi que l’algorithmique associée à chaque représentation pour réaliser les opérations de base (addition, multiplication, division, racine carrée… ) et calculer des fonctions « élémentaires » (logarithme, exponentielle, fonctions trigonométriques, etc.).

On s’intéressera d’abord à la manipulation de nombres en « précision fixée » (entiers, virgule flottante, norme IEEE 754) ainsi qu’à diverses techniques permettant d’augmenter ou de garantir la précision des calculs: on montrera ainsi qu’une arithmétique « approchée » comme la virgule flottante permet de faire des calculs exacts.

On étudiera ensuite la complexité et l’algorithmique des opérations de base sur les polynômes (multiplication, division, évaluation, interpolation), en arithmétique exacte.

Enfin, nous aborderons la question du calcul sur les polynômes en arithmétique approchée. Cela permettra d’une part de présenter les notions fondamentales de conditionnement d’un problème et de stabilité d’un algorithme et, d’autre part, de comprendre pourquoi l’évaluation polynomiale est de plus en plus souvent au coeur des implantations (logicielles ou matérielles) d’opérateurs arithmétiques de base comme la division ou la racine carrée.

Intervenants

  • Jean Michel Muller, DR CNRS (http://perso.ens-lyon.fr/jean-michel.muller/)
  • Claude Pierre Jeannerod, CR INRIA (http://perso.ens-lyon.fr/claude-pierre.jeannerod/)

Quelques ouvrages de référence

  • Ercegovac et Lang, Digital Arithmetic, The Morgan Kaufmann Series in Computer Architecture and Design, 2004
  • D.E. Knuth, The Art of Computer Programming, Volume 2, Addison Wesley 1997
  • Muller, Arithmétique des Ordinateurs, Masson, 1989 (texte intégral accessible à http://prunel.ccsd.cnrs.fr/ensl-00086707)
  • J. von zur Gathen et J. Gerhard, Modern Computer Algebra, Cambridge 2003.
  • Muller, Elementary functions, algorithms and implementation, 2ème édition, Birkhauser, 2006
  • P. Burgisser, M. Clausen, et M.A. Shokrollahi, Algebraic Complexity Theory, Springer 1997.
  • Higham, Accuracy and Stability of Numerical Algorithms, SIAM, Seconde édition, Août 2002
  • Muller, Brisebarre, de Dinechin, Jeannerod, Lefèvre, Melquiond, Revol, Stehlé et Torrès, Handbook of Floating-Point Arithmetic, Birkhauser, 2010

Réseaux

Programme de l’UE :

Le but de ce cours est de présenter certains fondements des réseaux, dans son fonctionnement mais aussi des points de vues algorithmique et
d’évaluation de performances. Le module s’articule autour d’une présentation de l’architecture de l’Internet et des protocoles réseaux,
et des outils/méthodologie d’évaluation de performances. Les notions abordées lors de ce cours sont les suivantes :

  • Notions, principes et les architectures réseaux.
  • Algorithmes d’accès à un médium de communication
  • Méthode statistique pour l’évaluation des performances
  • Evaluation des performances des réseaux sans fil
  • Principe de l’IP et de l’Internet
  • Notions avancés de routage
  • Algorithmes des protocoles de transport (TCP, partage, performance)

Modalité d’évaluation

  • Examen écrit
  • TP ou Mini-projet

Fiche d’évaluation

Intervenants