Distributed, Parallel, and Quantum Computing (M1 DiPaQ)

Prerequisites:

• Familiarity with linear algebra
• Exposure to programming in Python

Course program, plan, content:

Total duration: 21 hours (6 sessions × 3.5 hours + final exam session)

• Session 1 (Lecture): Introduction to quantum computation in the context of the quantum co-processor model. Notion of unitary, measure, quantum circuit.
• Session 2 (Lecture + Lab): lab session for practice, followed by the presentation of Deutsch-Jozsa algorithm.
• Session 3 (Lecture + Lab): lab session for practice, followed by a discussion on circuit and oracle synthesis.
• Session 4 (Lecture + Lab): Quantum Fourier Transform and Phase Estimation: theory and implementation.
• Session 5 (Lecture + Lab): Shor’s factoring algorithm: theory and implementation
• Session 6 (Lecture + Lab): Quantum Amplification (aka Grover’s algorithm): theory and implementation
• Session 7: Final written exam

Learning objectives:

By the end of this course, students will be able to:

• Understand the quantum co-processor model and the general structure of quantum algorithms.
• Know a few basic blocks of quantum algorithms.
• Implement a small quantum algorithm and undestand how it works.

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with hands-on labs on papers and programming labs that allow students to apply and test these concepts in practice.
• Each 3-hour session blends approximately 50% lecture and 50% programming exercises.
• The evaluation combines continuous assessment, based on homeworks, and a written exam.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Technical competence: Ability to navigate quantum computing principles and quantum circuit design.
• Analytical competence: Capacity to analyze quantum algorithms and evaluate their computational complexity.
• Practical competence: Proficiency in implementing quantum programs using platforms like Qiskit.
• Problem-solving competence: Ability to apply quantum logic to solve search and optimization problems.

Bibliography:

• Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum Information: 10th Anniversary Edition. Cambridge: Cambridge University Press.
• Lecturer’s course notes, provided as a PDF file..

Prerequisites:

• Basic C/C++ programming
• Basics of computer architecture
• Familiarity with basic linear algebra concepts
• [M1 DiPaQ] Introduction to parallel algorithms and programming

Course program, plan, content:

Total duration: 21 hours (7 sessions × 3 hours)

This course builds upon the basic concepts of parallel programming introduced in ``[M1 DiPaQ] Introduction to parallel algorithms and programming" and explores more advanced parallelization and code optimization techniques to write efficient code for multicore parallel architectures. The material covered in the course includes:

• An overview of the multicore processor architecture
• Writing efficient low-level code using SIMD instructions
• Memory and cache optimizations
• Advanced code optimization techniques (loop unrolling, branch optimizations, ...)
• Task-based parallelization
• Hybrid parallelization combining SIMD and multicore parallelism
• Parallelization and optimization approaches for dense linear algebra
• Parallelization and optimization approaches for sparse irregular computations
• Introduction to high performance linear algebra libraries (BLAS, LAPACK)

Learning objectives:

By the end of this course, students will be able to:

• Describe modern multicore processor organization, memory hierarchy, and shared cache behavior
• Explain challenges such as cache coherency, NUMA effects, and false sharing
• Diagnose and correct memory-related performance bottlenecks
• Apply cache-aware and cache-tiling optimizations
• Utilize SIMD intrinsics or compiler-driven vectorization effectively
• Design parallel strategies for graph algorithms and sparse matrix computations
• Avoid pitfalls in parallel traversal of irregular data structures
• Apply task-based parallelism for dynamic workloads
• Build scalable parallel algorithms for modern multicore architectures
• Use BLAS and LAPACK routines effectively in real-world applications
• Understand how optimized libraries exploit hardware features

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with hands-on programming labs that allow students to apply and test these concepts in practice.
• Each 3-hour session blends approximately 50% lecture and 50% programming exercises.
• Evaluation is continuous, based on multiple written and programming assignments distributed throughout the course. Students will use parallel computing environment to complete lab work and assignments.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Technical competence: Ability to design and implement high-performance applications optimized for multicore shared-memory architectures.
• Analytical competence: Capacity to identify performance bottlenecks, analyze memory-hierarchy behavior, and apply profiling tools to evaluate multicore execution efficiency.
• Practical competence: Proficiency in using multicore-oriented programming models, SIMD intrinsics, optimized linear algebra libraries, and performance-analysis toolchains.
• Problem-solving competence: Ability to choose appropriate parallelization strategies—including vectorization, cache-aware techniques, and task-based decomposition—to address dense and sparse computational challenges.
• Transferable skills: Experience working with performance-critical codebases, conducting structured experiments, tuning for locality and scalability, and producing reproducible performance results.

Bibliography:

• Grama, A., Gupta, A., Karypis, G., & Kumar, V. Introduction to Parallel Computing: Design and Analysis of Algorithms, 2nd edition. Addison-Wesley, 2003.
• Hennessy, J. L., & Patterson, D. A. Computer Architecture: A Quantitative Approach. Morgan Kaufmann.
• Mattson, T., Sanders, B., & Massingill, B. Patterns for Parallel Programming. Addison-Wesley.

Prerequisites:

• Familiar with linear algebra
• Basics of linear optimization
• Basic of quantum computing

Course program, plan, content:

Total duration: 21 hours (7 sessions × 3 hours )

• Session 1 (Lecture + Lab): Foundations of Combinatorial Optimization: Introduction to Combinatorial Optimization; Problem Formulation: Linear Programming, Integer Programming; Simplex Method: Formulation, Efficiency, Duality.
• Session 2 (Lecture + Lab): Combinatorial optimization: Reformulations, Bounds, Lagrangian relaxation; Metaheuristics: Simulated annealing, Variable Neighborhood search.
• Session 3 (Lecture + Lab): Dynamic Programming: Dynamic programming in combinatorial optimization; Application to knapsack and lot-sizing problems; Bellman’s Principle.
• Session 4 (Lecture + Lab): Introduction to Quantum Computing for Optimization: Basics of quantum computing (qubits, gates, superposition, entanglement); reformulation of combinatorial optimization problems into their quantum counterparts.
• Session 5 (Lecture + Lab): Quantum Optimization Algorithms: Quantum Annealing: Applications in Combinatorial Optimization; Variational Quantum Algorithms (VQAs): QAOA for Optimization.
• Session 6 (Lecture + Lab): Quantum linear programming: Introduction to Quantum Circuit Optimization, applications and implementations.

Learning objectives:

At the end of this course, students will be able to:

• Formulate combinatorial problems and solve their relaxation by simplex algorithm.
• Use dynamic programming and metaheuristic baselines to solve combinatorial optimization problems.
• Encode combinatorial optimization problems as QUBO.
• Explain and assess quantum linear programming approaches.

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with hands-on algorithmic applications that allow students to apply these concepts in practice.
• Each 3-hour session blends approximately 50% lecture and 50% application exercises.
• Evaluation is continuous, based on multiple written exercises distributed throughout the course.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Problem modeling: Translate real-world tasks into combinatorial formulations and QUBO encodings with correct constraint penalties.
• Algorithmic literacy: Understand complexity classes, relaxations (LP/Lagrangian), and approximation guarantees for canonical problems.
• Classical baselines: Design and implement dynamic programming and metaheuristics to benchmark quantum methods.
• Hybrid methods: Combine classical heuristics/relaxations with quantum stages; justify integration choices and measure end-to-end gains.

Bibliography:

• Korte, B., & Vygen, J. Combinatorial Optimization: Theory and Algorithms (6th ed., Springer, 2018).
• Nemhauser, G. L., & Wolsey, L. A. Integer and Combinatorial Optimization (Wiley, 1999).
• Boyd, S., & Vandenberghe, L. Convex Optimization (Cambridge Univ. Press, 2004).
• Nielsen, M. A., & Chuang, I. L. Quantum Computation and Quantum Information (Cambridge Univ. Press, 2010/2011).
• Rieffel, E. G., & Polak, W. H. Quantum Computing: A Gentle Introduction (MIT Press, 2011).

Prerequisites:

• Linear algebra
• Multivariable calculus
• Basics in quantum computing

Course program, plan, content:

Total duration: 21 hours (7 sessions × 3 hours)

• Introductions and background (convexity, differentiability, optimality conditions, convergence rates …)
• Continuous optimization (first order methods: Gradient methods, line search, Acceleration)
• Continuous optimization (second order methods: Newton methods including Quasi-Newton, secant, IRLS)
• Conjugate Gradient Methods
• Linear conjugate gradient
• Solution of linear systems
• Least-Squares Problems
• Linear least Squares (Normal equations, CholeskyQR, SVD-based)
• Non-linear least squares (Gauss-Newton)
• Convexity, Optimality Conditions, and Duality: Convex Functions and Convex Sets, First- and Second-Order Optimality Conditions, Lagrangian, Duality Theory, Gradient methods, Physics Informed neural networks for optimization problems.
• Quantum Approaches for optimization problems: Variational Quantum Eigensolver (VQE), Quantum Approximate Optimization Algorithm (QAOA), Grover’s search for optimization problems.

Learning objectives:

• At the end of this course, students will be able to:
• Model scientific and engineering problems as optimization with clear variables, objectives, and constraints.
• Classify problems by smoothness, convexity, and structure (sparsity, separability) and select suitable algorithms accordingly.
• Derive first- and second-order optimality (KKT) conditions for optimization problems and interpret them for feasibility and stationarity.
• Use learning approaches for solving large size large-scale scientific problems
• Explain and assess quantum optimization problems.

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with hands-on algorithmic applications that allow students to apply these concepts in practice.
• Each 3-hour session blends approximately 80% lecture and 20% application exercises.
• Evaluation is continuous, based on multiple written exercises distributed throughout the course.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Problem modeling: Translate real-world tasks into convex optimization and games.
• Algorithmic literacy: Understand convexity, relaxations, gradient methods for large-scale problems.
• Classical baselines: Design and implement convex programming and game problems under uncertainty.
• Quantum applications and learning: Understand quantum and learning approaches for optimization and game problems.

Bibliography:

• J. Nocedal & S. J. Wright, Numerical Optimization (2nd ed., Springer, 2006).
• S. Boyd & L. Vandenberghe, Convex Optimization (Cambridge Univ. Press, 2004).
• Y. Saad, Iterative Methods for Sparse Linear Systems (2nd ed., SIAM, 2003).
• G. H. Golub & C. F. Van Loan, Matrix Computations (4th ed., Johns Hopkins, 2013).
• A. Beck, First-Order Methods in Optimization (SIAM, 2017).
• Alexander Shapiro, Darinka Dentcheva, Andrzej Ruszczyński — Lectures on Stochastic Programming: Modeling and Theory (2nd ed., SIAM/MPS, 2014)..
• John R. Birge, François Louveaux — Introduction to Stochastic Programming (2nd ed., Springer, 2011).

Prerequisites:

• All the necessary reminders will be given. However, the student should make sure that he knows the basics in linear algebra: vectors, matrices, inner product, norm.
• Moreover, and again even if all the necessary formal objects will be defined and introduced properly, it is a huge plus if the student has a relatively well advanced level in mathematics, let’s say the equivalent of either 2 years of “Math Sup / Mat spé”, or of an L2 in pure mathematics in some university (and even better if it is an L3), or of an L2 or L3 in theoretical computer science (usually, students from purely applied computer science have difficulties to follow the course), or an L3 of fundamental physics, with enough mathematics for physics.

Course program, plan, content:

The course is composed of 5+1 sessions of 3h30min each, which, with the 2h final-exam session, covers a T2. Lecture 6 is not compulsory material to learn for the final exam.

Lecture 1: Postulates of quantum theory
– Their meaning;
– The necessary mathematics;
– Dirac and Coecke notations for these mathematics;
– Several basic results: no-cloning; no-distinguishability.

Lecture 2: Useful linear-algebra theorems

Lecture 3: Density matrices and quantum operations

Lecture 4: Quantum error correction
Several variants of the 3-qubit code; fundamental theorems of quantum error correction.

Lecture 5: Four major topics
Bell inequalities; no-signalling; purification and Stinespring’s theorems; the measurement interpretation.

Lecture 6: Quantum simulation (Hamiltonian, single-particle, many-particle)
Continuous-time (i.e., Hamiltonian) quantum simulation;
Discrete-time quantum simulation (in particular, with quantum walks and quantum cellular automata).

Homework:
In addition to these lectures, there will be a relatively long homework, where the student will get to work on topics such as: superdense-coding protocols, teleportation, QRAC, BB84 key sharing, certified randomness, and others.

Learning objectives:
This course can be seen as a first course in quantum mechanics, but with the style, objects, tools, methods, and objectives, of so-called quantum computation and more broadly information. The course covers, goes up to relatively advanced concepts, but it starts from the basics, it is self-contained, which is why we can still view it as a first course in quantum mechanics. 

Quantum computation and quantum information are fields of study which arised within the second quantum revolution, which was definitively launched by Alain Aspect’s experimental demonstration that Bell’s inequalities where violated in 1982, after which the property of entanglement in quantum mechanics was established as something “real”, that could not be understood with a classical mindset, and in particular with classical probability theory. This established the standard formulation of quantum mechanics as fundamental and unavoidable. 

The objectives of quantum computation and quantum information are to use quantum phenomena to achieve tasks which belong to the field of information handling, that is, essentially, storage, processing or computation, and communication (different types of communication channels, protocols; cryptography). Within this second quantum revolution, many formal tools have been developed to deal with superposition and entanglement, which are the two basic properties of quantum matter.

General course organization and teaching modalities:

The course is composed of 5+1 sessions of 3h30min each, which, with the final-exam session, covers a T2. Lecture 6 is compulsory material to learn for the final exam.

After each lecture, I send the students additional material via a one-way forum (me —> them) on the eCampus page of the course: this additional material is mainly composed of (i) a sum-up of the lecture, with more insight, and of (ii) extended material about techniques and concepts.

Competencies gained in the course:

See the program of the course. In terms of practical skills, the student should know, by the end of the course, how to manipulate (i.e., to do computations with) quantum states in Dirac notations, how to deal with (i.e., to do computations with) entangled systems (so, how to deal with the tensor-product notation, both for states and for operators). The student should also know how to do all this in the case of mixed states, that is, manipulation of density matrices and of quantum operations. The student should know how to use quickly the different linear-algebra theorems presented especially in Lecture 2 (various types of decompositions of states and operators) but not only, as well as the more advanced theorems which are specific to quantum information (see for example, in particular, Lecture 4).

Bibliography:

Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum Information: 10th Anniversary Edition. Cambridge: Cambridge University Press. 

Coecke B, Kissinger A. Picturing Quantum Processes: A First Course in Quantum Theory and Diagrammatic Reasoning. Cambridge University Press; 2017.

Prerequisites:

• Basic notions of algorithms and algorithm analysis (complexity measures, asymptotic notations)
• Familiarity with basic notions of graph theory and elementary graph algorithms
• Familiarity with basic notions of networking and operating systems are recommended
• Some knowledge on distributed algorithms and systems is recommended

Course program, plan, content:

Total duration: 21 hours (6 sessions × 3 hours + 1 presentations/exam session)

• Session 1: Introduction to self-stabilization.
• Session 2: Self-stabilizing Census algorithm.
• Session 3: Transient fault detection technique, tree construction example
• Session 4: Self-stabilizing shortest-path tree construction
• Session 5: Dijkstra’s token circulation.
• Session 6: Proof methods of self-stabilizing algorithms.
• Session 7: Students’ presentations on self-stabilizing algorithms and an oral and written examination on the course material.

Learning objectives:

Self-stabilization is a versatile technique used to overcome any transient failure in a system. The focus of this module is on distributed systems such as the Internet, networks of mobile agents or sensors, and their applications such as the Internet of Things, the Cloud, Bitcoin, etc. Failures and dynamic evolution are the norm in such systems and become more likely at large scales. This could be due to changes in the communication topology, corruptions of the volatile memory of components, etc. Such failures can put the system at an arbitrary configuration (state) at any time during an execution. However, as soon as the failures and dynamic evolution cease, a self-stabilizing algorithm brings the system to a correct operation, without resetting and without an external intervention. In this module, after recalling the basics of distributed algorithms, we study how self-stabilizing techniques are used to make current distributed systems robust.

General course organization and teaching modalities:

• The course lectures combine theoretical material together with illustrating examples and exercises.
• The teaching is interactive, stimulating thinking and memorization.
• Evaluation is based on students’ presentations of scientific works on self-stabilizing algorithms and on an oral and written exam on the course material.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Ability to understand and design self-stabilizing distributed algorithms.
• Ability to analyze self-stabilizing distributed algorithms: prove their correctness and evaluate their complexity.

Bibliography:

• “Introduction to Distributed Algorithms”, G. Tel
• Scientific papers

Prerequisites:

• Basic notions of algorithms and algorithm analysis (complexity measures, asymptotic notations)
• Familiarity with basic notions of networking and operating systems is recommended

Course program, plan, content:

Total duration: 21 hours (6 sessions × 3.5 hours + 1 exam session)

• Session 1: Introduction to distributed algorithms and presentation of the synchronous message-passing distributed model that we will use in the course; complexity measures and other definitions
• Session 2: Leader election on a ring: LeLann, Chang and Roberts algorithm and its variants.
• Session 3: Leader election on a ring: Hirschberg and Sinclair algorithm, Time-slice algorithm, impossibility of LE in an anonymous ring.
• Session 4: Crash consensus and consensus with link failures.
• Session 5: Byzantine consensus.
• Session 6: Network synchronization and distributed BFS tree construction.
• Session 7: Final exam

Learning objectives:

Distributed algorithms are the building blocks of distributed systems and applications, such as the Internet, the Internet of Things, the Cloud, Bitcoin, etc. In addition to the difficulties induced by the geographical distribution and dynamic behavior of their components, these real systems are subject to failures: crashes, memory corruption, behavior of malicious participants, etc. In order to guarantee the correct operation of such systems, a major challenge is to deal both with the dynamics and failures, which drastically increase with large scale deployments. The goal of this course is to introduce students to the domain of distributed algorithms and fault-tolerance, and present methods to deal with the above-mentioned challenges. It addresses in particular a major technique using replication to tolerate a bounded number of failures, by completely masking them.

General course organization and teaching modalities:

• The course lectures combine theoretical material together with illustrating examples and exercises.
• The teaching is interactive, stimulating thinking and memorization.
• Evaluation is based on homework and the final written exam.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Understanding of how distributed systems can be modeled and being able to model such systems.
• Ability to analyze algorithms for such systems: prove their correctness and evaluate their complexity.
• Ability to design such algorithms while overcoming difficulties related to the geographical distribution of processes, network dynamics and failures
• Familiarity with classical fault tolerance approaches.

Bibliography:

• “Distributed Algorithms”, N. Lynch
• “Complexity of Network Synchronization” article 1985 - Baruch Awerbuch.

Prerequisites:

• Basic algorithms and complexity analysis – familiarity with algorithm design, asymptotic analysis, and common data structures.
• Programming in C/C++ – ability to write, compile, and debug programs in C or C++.
• Basic computer architecture – understanding of CPU, memory hierarchy, and instruction execution.

Course program, plan, content:

Total duration: 21 hours (7 sessions × 3 hours)

This course provides an in-depth study of high-performance computing (HPC) techniques targeting modern multicore processors on shared-memory architectures. Students learn how hardware architecture influences software performance and how to exploit shared-memory systems effectively. The course examines advanced SIMD vector instructions, cache-aware optimizations, NUMA behavior, efficient sparse and irregular data processing, and modern task-based parallelization strategies. Students also gain hands-on experience using foundational high-performance linear algebra libraries such as BLAS and LAPACK.

Multicore and shared-memory architecture:

• Multicore and manycore processor organization
• Memory hierarchy and cache behavior
• Cache coherency protocols
• Data races, memory ordering, and synchronization challenges

NUMA behavior and memory locality

• NUMA vs. UMA models
• Memory affinity, thread placement, and locality
• NUMA-aware data structures and allocation strategies

Advanced SIMD vectorization techniques

• SIMD instruction sets and compiler auto-vectorization
• Manual vectorization with intrinsics
• Vectorized implementations of core numerical kernels

Cache-aware and locality-driven optimization

• Loop tiling, blocking, and unrolling
• Working-set analysis and data reuse
• Techniques for reducing false sharing and contention

Dense linear algebra and high-performance matrix computation

• Dense linear algebra patterns
• Roofline reasoning and performance limits
• Progressive optimization of dense matrix multiplication

Sparse and irregular parallel computations

• Sparse matrix formats and memory layouts
• Graph traversal and irregular workload challenges
• Load balancing and synchronization minimization

Advanced task-based parallel programming

• Task decomposition and advanced dependency modeling
• Task scheduling and priorities
• Recursive task-parallellism

Learning objectives:

By the end of this course, students will be able to:

• Describe modern multicore processor organization, memory hierarchy, and shared cache behavior
• Explain challenges such as cache coherency, NUMA effects, and false sharing
• Diagnose and correct memory-related performance bottlenecks
• Apply cache-aware and cache-tiling optimizations
• Utilize SIMD intrinsics or compiler-driven vectorization effectively
• Design parallel strategies for graph algorithms and sparse matrix computations
• Avoid pitfalls in parallel traversal of irregular data structures
• Apply task-based parallelism for dynamic workloads
• Build scalable parallel algorithms for modern multicore architectures
• Use BLAS and LAPACK routines effectively in real-world applications
• Understand how optimized libraries exploit hardware features

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with hands-on programming labs that allow students to apply and test these concepts in practice.
• Each 3-hour session blends approximately 50% lecture and 50% programming exercises.
• Evaluation is continuous, based on multiple written and programming assignments distributed throughout the course. Students will use parallel computing environment to complete lab work and assignments.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Technical competence: Ability to design and implement high-performance applications optimized for multicore shared-memory architectures.
• Analytical competence: Capacity to identify performance bottlenecks, analyze memory-hierarchy behavior, and apply profiling tools to evaluate multicore execution efficiency.
• Practical competence: Proficiency in using multicore-oriented programming models, SIMD intrinsics, optimized linear algebra libraries, and performance-analysis toolchains.
• Problem-solving competence: Ability to choose appropriate parallelization strategies—including vectorization, cache-aware techniques, and task-based decomposition—to address dense and sparse computational challenges.
• Transferable skills: Experience working with performance-critical codebases, conducting structured experiments, tuning for locality and scalability, and producing reproducible performance results.

Bibliography:

• Grama, A., Gupta, A., Karypis, G., & Kumar, V. Introduction to Parallel Computing: Design and Analysis of Algorithms, 2nd edition. Addison-Wesley, 2003.
• Hennessy, J. L., & Patterson, D. A. Computer Architecture: A Quantitative Approach. Morgan Kaufmann.
• Mattson, T., Sanders, B., & Massingill, B. Patterns for Parallel Programming. Addison-Wesley.

Prerequisites:

• Basic knowledge of programming in C or Fortran is required.
• Familiarity with parallel programming concepts, computer architecture is recommended but not mandatory.
• Basic knowledge of Unix is ​​recommended
• Students should be comfortable with compiling programs in a Linux environment.
• Prior exposure to performance optimization or HPC tools will be beneficial but is not a strict prerequisite.

Course program, plan, content:

Total duration: 21 hours (7 sessions × 3 hours)

• Session 1 (Lecture + Lab): Introduction; MPI environment (with exercise); introduction to supercomputer, module and SLURM environment.
• Session 2 (Lecture + Lab): Point-to-point communications (with exercise)
• Session 3 (Lecture + Lab): Collective communications (with exercise).
• Session 4 (Lecture + Lab): Communication model (with exercise).
• Session 5 (Lecture + Lab): Derived types (with exercise).
• Session 6 (Lecture + Lab): Communicators (with exercise).
• Session 7 (Lecture + Lab): Open session based on questions and finalization of projects.

Learning objectives:

At the end of this course, students will be able to:

• Parallelize a code using the MPI library.
• Know how to run a simulation on a supercomputer by using the module environment and the SLURM batch scheduler.
• Understand and effectively optimize communications between MPI processes, intra and inter node.
• Measuring the efficiency and scalability of parallelized code

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with hands-on programming labs that allow students to apply and test these concepts in practice.
• Each 3-hour session blends approximately 50% lecture and 50% programming exercises.
• Evaluation is continuous, based on multiple written and programming assignments distributed throughout the course. Each assignment will be given at the end of each session and must be done for next session. Students will use MPI on the RUCHE supercomputer to complete lab work and assignments.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Mastery of basic MPI concepts: Understanding of the principles of communication between processes and  knowledge of different communication topologies (point-to-point,  collective).
• Using the main MPI functions: Mastery of basic functions for sending and receiving messages, using collective functions and creating derived types.
• Parallel Application Development: Ability to design and implement efficient parallel programs. Performance optimization of MPI applications.
• Error Handling and Debugging: Techniques for debugging MPI programs, including handling common errors and troubleshooting communication problems.
• Practical application: Solving real-world problems using MPI. Implementation of practical projects to reinforce acquired skills.

Bibliography:

• MPI official website : https://www.mpi-forum.org/
• Tutorials on MPI on the IDRIS website : http://www.idris.fr/formations/mpi.html

Prerequisites:

• Prior experience in programming, preferably in C, Fortran, or Python
• Basic familiarity with computer usage and development tools such as text editors, compilers, and command-line interfaces

Course program, plan, content:

Total duration: 21 hours (7 sessions × 3 hours)

• Introduction to C++ and development environment – compiling, linking, running programs, and basic debugging
• Fundamental data types and control structures – variables, constants, arithmetic, logic, loops, and conditionals
• Functions and modular programming – defining functions, parameter passing, recursion, and scope
• Object-oriented programming concepts – classes, objects, constructors/destructors, encapsulation
• Inheritance, polymorphism, and virtual functions – designing reusable and extensible code
  Standard library basics – containers (vector, map, list), iterators, and algorithms
• Memory management and pointers – pointers, references, dynamic allocation, smart pointers
• File I/O and exception handling – reading/writing files, exceptions, and program robustness
• Basic program optimization and debugging techniques – performance considerations, common pitfalls, and testing

Learning objectives:

• Understand and apply the core concepts of the C++ programming language, including variables, control structures, functions, and classes
• Write modular, maintainable, and well-documented C++ programs
• Master object-oriented programming in C++: classes, inheritance, polymorphism, and encapsulation
• Understand and use the C++ Standard Library, including containers, algorithms, and iterators
• Implement dynamic memory management using pointers, references, and smart pointers
• Debug, test, and optimize basic C++ programs for correctness and efficiency
• Develop a solid foundation to approach parallel and high-performance C++ programming in subsequent courses

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with hands-on programming labs that allow students to apply and test these concepts in practice.
• Each 3-hour session blends approximately 50% lecture and 50% programming exercises.
• Evaluation is continuous, based on multiple written and programming assignments distributed throughout the course.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Technical competence: Ability to design and implement functional C++ programs using core language features and standard libraries
• Analytical competence: Capacity to reason about program logic, modular design, and object-oriented structures
• Practical competence: Proficiency in debugging, compiling, and running C++ programs efficiently
• Problem-solving competence: Ability to translate computational problems into working C++ solutions
• Transferable skills: Strong foundation for advanced C++ topics, including parallel programming and high-performance computing
• Students completing this course will have mastered core C++ concepts, object-oriented design, memory management, and the standard library, providing the essential programming foundation needed to tackle data-parallel C++ paradigms using SYCL and oneAPI in heterogeneous computing environments

Bibliography:

• Stroustrup, Bjarne. The C++ programming language, 4th Edition. Addison-Wesley, 2013
• Meyers, Scott. Effective C++: 55 specific ways to improve your programs and designs, 3rd Edition. Addison-Wesley, 2005
• Josuttis, Nicolai M. The C++ standard library: a tutorial and reference, 2nd Edition. Addison-Wesley, 2012

Prerequisites:

• We will recall the important notions about the structure of a graph in the first session; it will be important to be familiar with them for the next sessions.
• Students should know what an algorithm is, how to prove that it is correct, and how to compute its complexity, in time and in space. They should be able to use classical algorithmic strategies, such as greedy algorithms and dynamic programming. Cf. Cormen Introduction to Algorithms if needed: [https://edutechlearners.com/download/Introduction_to_algorithms-3rd%20Edition.pdf](https://edutechlearners.com/download/Introduction_to_algorithms-3rd Edition.pdf)
• Students should be familiar with the most classical data structures and know how to use them: static/dynamic arrays, (doubly) linked lists, binary search trees, hashmaps, ...
• Students should be able to articulate and formalize a reasoning. There will be an important focus on the quality of formulation during the course.

Course program, plan, content:

Total duration: 21 hours (6 sessions × 3.5 hours + 3h exam session). Each chapter lasts between 1 and 2 sessions. The first 6 sessions are composed of lectures and exercise sessions, and the 7th is dedicated to the exam.

• Chapter 1: Graph Theory basics. Introduction of basic structural notions on graphs: (induced) subgraphs, minors, heredity, ...; of classical graph parameters: radius, diameter, minimum/maximum degree, degeneracy, maximum average degree, clique/independence number, Hall ratio, ...; and of some relations linking those parameters. Focus on trees (rooted or not, characterisation), and on graph traversal (Breadth-First Search, Depth-First Search) and their structural properties.
• Chapter 2: Graph Coloring. The Graph Coloring Problem is used as an archetypal example of a hard problem on graphs, and several approaches are considered to attack it: analysis of a Greedy Algorithm depending on the ordering of the input, presentation of Brooks’ Theorem, of perfect elimination orderings (illustrated with interval graphs).
• Chapter 3: Complexity. Time complexity analysis of sequential algorithms, presentation of the notion of NP-hardness, and of Fixed-Parameter-Tractable (FPT) algorithms. Introduction of the LOCAL model for distributed algorithms and the notion of round complexity.
• Chapter 4: Matchings. Introduction of Hall’s Theorem, Berge’s Theorem, and König’s Theorem. Presentation of the Hungarian Method, and of proper edge-colorings of graphs.
• Session 7 (Exam): 3h written exam.

Learning objectives:

At the end of this course, students will be able to prove structural properties on graphs, and use them in order to solve advanced problems on graphs, including (but not restricting to) algorithmic ones. To that end, they will have to understand and be able to apply a subset of methods that are classical in Graph Theory.

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with exercise sessions that allow students to apply and test their comprehension of these concepts in various contexts.
• Each 3.5-hour session blends approximately 60% lecture and 40% exercises.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Technical competence: Ability to derive and leverage structural graph properties in order to design algorithms to solve hard problems on graphs.
• Analytical competence: Capacity to analyze the theoretical performances of an algorithm, including its validity, precision, and complexity.
• Practical competence: Proficiency in formal reasoning and providing a clear presentation thereof.
• Transferable skills: Experience in making a valid chain of thoughts. Abilities in the redaction and the presentation of formal arguments, in the form of a research document.

Bibliography:

• Bondy, J. A., & Murty, U. S. R. (1976). Graph theory with applications (Vol. 290). London: Macmillan.
• Diestel, R. (2025). Graph theory (Vol. 173). Springer Nature.

Prerequisites:

• Background in algorithms and data structures.
• Basic knowledge of discrete mathematics and probability theory is recommended but not mandatory.
• Familiarity with asymptotic analysis (Big-O notation) and complexity concepts.
• Programming experience in a general language (e.g., Python, C++, or Java) is recommended.

Course program, plan, content:

Total duration: 21 hours (6 sessions × 3.5 hours)

• Session 1 (Lecture + Lab): Introduction to randomization (Motivation and examples: why randomization?) Review of basic probability concepts (expectation, variance, independence).  Case study: Randomized QuickSort and its expected complexity.
• Session 2 (Lecture + Lab): Probabilistic analysis tools: linearity of expectation and indicator variables, the coupon collector problem and conditional probability laws.
• Session 3 (Lecture + Lab): Probabilistic Bounds and Applications (Markov, Chebyshev, and Chernoff bounds). The balls-into-bins paradox and implications for load balancing. Verification problems and Bayesian classification examples.
• Session 4 (Lecture + Lab): Introduction to Online Algorithms (The ski-rental problem, Online paging and caching algorithms, Basics of load balancing in online settings).
• Session 5 (Lecture + Lab): Hashing and Streaming Algorithms (Randomized hashing and collision analysis, universal hashing and expected performance, introduction to streaming algorithms and approximate counting).
• Session 6 (Lab): Project presentations and discussions of student projects.
• Session 7 (Final exam): 1h30 written exam.

Learning objectives:

At the end of this course, students will be able to:

• Understand the principles and motivations behind randomized algorithm design.
• Apply probabilistic tools such as the Chernoff and Markov inequalities for performance analysis.
• Analyze the expected performance and probabilistic guarantees of randomized algorithms.
• Design and implement efficient algorithms using randomization as a core technique.

General course organization and teaching modalities:

• The course combines lectures introducing theoretical concepts with exercise labs that allow students to apply these concepts.
• Each 3.5-hour session blends approximately 1h lecture and 2h30 exercises.
• Evaluation is based on one project and one written exam.

Competencies gained in the course:

Upon successful completion, students will have acquired the following competencies:

• Technical competence: Designing random algorithms with probabilistic guarantees.
• Analytical competence: Analyzing the complexity and performance of random algorithms.
• Practical competence: Implementation and empirical evaluation of random algorithms.
• Problem-solving competence: Comparing deterministic and random algorithms.
• Transferable skills: Modeling real-world problems and writing rigorous mathematical proofs.

Bibliography:

• Kleinberg, J., & Tardos, E. (2006). Algorithm design. Pearson Education India.
• Motwani, R., & Raghavan, P. (1996). Randomized algorithms. ACM Computing Surveys (CSUR), 28(1), 33-37.
• Mitzenmacher, M., & Upfal, E. Probability and Computing: Randomization and Probabilistic Techniques in Algorithms and Data Analysis. Cambridge University Press, 2017.
• Vazirani, V. V. Approximation Algorithms. Springer, 2001.

5 hours of lectures on direct and indirect impacts, and several tutorials including an IT equipment inventory, the analysis of CSR reports from major digital groups, assessment of the specific impacts of AI, and a poster session based on scientific articles on the subject.

During this course, students will explore the topic of environmental damages linked to digital technology and various ways to assess and limit these damages. For those attending the course, the aim is to subsequently be able to think critically as computer engineers and know what steps to take to assess the impact of their hardware purchases and software developments and how to reduce this impact.

Students will be able to handle mathematical concepts underlying tools used by practitioners

This class aims at teaching/reminding mathematical basis useful in data science: 
1. vector spaces, linear transformations, 
2. matrices, linear systems, 
3. norms, orthogonality, 
4. eigenvalues, singular value decomposition, 
5. tensors (notions), multivariable calculus
6. etc

Optional exercises will be posted on my webpage (on eCampus, when restored): 
https://perso.ensta-paris.fr/~bonazzoli/teaching.html

Reading recommendations: 
To complement the lectures, you can find plenty of good material on the web about Linear Algebra and Multivariable Calculus, such as:

- Lectures "Introduction to Probability, Statistics, and Machine Learning" by Samuel S. Watson from Brown University (lectures 2, 3, 4), https://data1010.github.io/class/  

- Lectures "Mathematics for Machine Learning" by Garrett Thomas from University of California, Berkeley, https://gwthomas.github.io/docs/math4ml.pdf  

- Book "Mathematics for Machine Learning" by M. P. Deisenroth, A. A. Faisal, C. S. Ong,  published by Cambridge University Press, https://mml-book.github.io/book/mml-book.pdf  

- Notes from Zico Kolter (updated by Chuong Do), Stanford university, "Linear Algebra Review and Reference", https://cs229.stanford.edu/section/cs229-linalg.pdf  

- Videos of Gilbert Strang lectures on Linear Algebra, MIT. https://ocw.mit.edu/courses/18-06-linear-algebra-spring-2010/video_galleries/video-lectures/

- (T1A, Applied Stats): Maximum Likelihood Estimate and related notions
- (T1B, Maths for DS): Basic Linear Algebra, well mastered (tensor product, diagonalization)
- python, numpy.
Ideally, too:
- (OPT9, Hands On ML): it’s a good complement to this class, very good to master sklearn. Here we’ll look inside the algos of sklearn or others.
+ Check out previous years exam to see the level of math-mastery that is expected (of course some of it is covered in this course, but you need good basics).

This course is algorithms-oriented, i.e. we will sketch the great principles of ML at first, and then focus on how algorithms work in practice, including all necessary mathematical aspects.
They are the basic building blocks of more advanced algorithms.
1 Gradient Descent, Linear Regression from scratch
2 Classification with a single layer Perceptron, from scratch. Geometrical interpretation, a word on SGD/mini-batch learning. Discussion on the choice of the loss function, or activation functions. OVR multi-class scheme (quickly)
3 overfitting, train/validation/test split, K-fold CV, regularization: in general, L2, L1.
4 MAP, Bayesian interpretation of Ridge Regression or Lasso one.
5 feature maps ("Kernel trick"), PCA (from scratch, seen as variance maximization), PCA as pre-processing (dimensional reduction)
6 Kernels, Kernelized perceptron, SVM in the separable case (some details omitted). Exercise: Lasso regularization from scratch (pseudo-gradients quickly introduced)

Recommation of reading: 
Pattern Recognition and Machine Learning, Christopher Bishop, 2006 (available online for free)
Hands On Machine Learning with Scikit Learn and TensorFlow, Aurélien Géron 
-> also in French: Introduction au Machine Learning, Aurélien Géron

A practical oriented class, where students apply ML techniques to simple illustrative examples and then to tackle competitive challenges. It will start with an introduction to present (refresh) the ML landscape. Classes will then be articulated to successively focus on the major concepts of practical ML.

Outline:
1. Introduction/refresher on ML
2. Working with real data
3. Discover and visualize the data to gain insights
4. Prepare the data for processing
5. Select and train models
6. Fine-tune models

Recommation of reading:
• Géron (2019) Hands-on Machine Learning with Scikit-Learn, Keras, and Tensorflow: Concepts, Tools, and Techniques to Build Intelligent Systems
• VanderPlas (2017) Python Data Science Handbook: Essential Tools for Working with Data