Teaching code

4S008896

Credits

12

Coordinator

Romeo Rizzi

Language

Italian

Scientific Disciplinary Sector (SSD)

ING-INF/05 - INFORMATION PROCESSING SYSTEMS

Courses Single

Authorized

Moodle Seminars 0

The teaching is organized as follows:

Learning objectives

The overall targets of the course is to expose some aspects of the deep and important dialectic exchange between the search for algorithmic solutions and the study of the complexity of problems. Algorithms are the backbone and the substance of information technologies, but at the same time their study goes beyond the "mere" computer science and is pervasive to all the disciplines that are problem-bearers. The design of an algorithm starts from the study of the structure of the problem to be solved and it usually represents the highest achievement of this process. The study of algorithms requires and offers methodologies and techniques of problem solving, logical and mathematical skills. The course therefore aims to provide students with fundamental skills and methodologies for the analysis of problems and the design of the algorithms for solving them. Particular emphasis is given to the efficiency of the algorithms themselves, and the theory of computational complexity plays a profound methodological role in the analysis of problems. With reference to the overall didactic aims of the Master program, the course leads students to deepen and expand the three-year training in the field of analysis and evaluation of problems, algorithms, and computational models, providing a wealth of advanced tools to address non-trivial problems in different IT fields. The students will acquire logical-mathematical skills, techniques, experience and methodologies useful in the analysis of algorithmic problems, from detecting their structure and analyzing their computational complexity to designing efficient algorithms, and then planning and conducting their implementation. Besides that, The course provides the foundations of computational complexity theory, focussing on: the theory of NP-completeness; approximation algorithms and basic approaches for the analysis of the approximation guarantee of algorithms for hard problems; and parameterized approaches to hard problems. The student will apply the main algorithmic techniques: recursion, divide and conquer, dynamic programming, some data structures, invariants and monovariants. The student will develop sensitivity about which problems can be solved efficiently and with which techniques, acquiring also dialectical tools to place the complexity of an algorithmic problem and identify promising approaches for the same, looking at the problem to grasp its structure. She will learn to produce, discuss, evaluate, and validate conjectures, and also independently tackle the complete path from the analysis of the problem, to the design of a resolver algorithm, to the coding and experimentation of the same, even in research contexts either in the private sector or at research institutions. Based on the basic notions acquired of computational complexity, the students will be able to employ reductions, standard techniques in complexity theory, to analyze the structural properties of computational problems and identify possible alternative approaches (approximation, parameterization) in the absence of (provably) efficient solutions After attending the course the students will be able to: classify intractable computational problems; understand and verify a formal proof; read and understand a scientific article where a new algorithm is presented together with the analysis of its computational complexity.

Prerequisites and basic notions

know how to program in some programming language.

Program

The Yin and the Yang of problem solving are the general methods for the solutions of instances of the problem (the Algorithms) on one side, and a detached aesthetic eye on the richness of the problem (Complexity) on the other. Two passionate enthusiasts will guide you in the exploration of these two synergistic arts with the hope that in you they might merge into just one.
ALGORITHMS SIDE:
1. The workflow of problem solving: analysis and comprehension of the problem, conception of an algorithmic solution, design of an efficient algorithm, planning the implementation, conducting the implementation, testing and debugging.
2. Methodology in analyzing a problem:
The study of special cases. Particularization and generalization.
Building a dialog with the problem. Conjectures. Simplicity assumptions.
Solving a problem by reducing it to another. Reductions among problems to organize them into classes. Reducing problems to isolate the most fundamental questions. The role of complexity theory in classifying problems into classes. The role of complexity theory in analyzing problems. Counterexamples and NP-hardness proofs. Good conjectures and good characterizations. The belief can make conjectures true. Decomposing problems and inductive thinking.
3. Algorithm design general techniques.
Recursion. Divide et impera. Recursion with memoization. Dynamic programming (DP). Greedy.
DP on sequences. DP on DAGs. More in depth: good characterization of DAGs and scheduling, composing partial orders into new ones.
DP on trees. More in depth: adoption of the children one by one; advantages of an edge-centric vision over the node-centric one.
The asymptotic eye on worst case performance guides the design of algorithms:
the binary search example; negligible improvements; amortized analysis.
Some data structures: binary heaps; prefix-sums; Fenwick trees; range trees.
4. Algorithms on graphs and digraphs.
Bipartite graphs: recognition algorithms and good characterizations.
Eulerian graphs: recognition algorithms and good characterizations.
Shortest paths. Minimum spanning trees.
Maximum flows and minimum cuts.
Bipartite matchings and node covers.
The kernel of a DAG. Progressively finite games. Sums of games.
5. General hints on implementing, coding, testing and debugging.
Plan your implementation. Anticipate the important decisions, and realize where the obscure points are. Try to go round the most painful issues you foresee. Code step by step. Verify step by step. Use the assert. Testing and debugging techniques. Self-certifying algorithms.
COMPLEXITY SIDE:
Relationships among computational problems. Polynomial reductions of one problem into another. The classes P, NP, co-NP. Notion of completeness. Proofs od NP-completeness: Cook's theorem; proofs of completeness using appropriate reductions. Search and Decision Problems. Self-Reducibility of NP-complete problems and existence of non-selfreducible problems.
Space Complexity. Models and fundamental difference between the use of time resource and the space resource. Completeness for space complexity classes. The classes PSPACE and NPSPACE. Examples of reductions to prove PSPACE-completeness.
Introduction to the approximation algorithms for optimisation problems. Examples of approximation algorithms. Classification of problems with respect to their approximabuility. The classes APX, PTAS, FPTAS. Notion of inapproximability; the gap technique to prove inapproximability results; examples of approximation preserving reductions.
Examples of simple randomised algorithms in solving hard problems. . Examples of parameterized approaches to solve hard problems.

Bibliography

Didactic methods

in presence. The lessons will still be recorded and where convenient and upon request we could also serve those who need to follow remotely.

Learning assessment procedures

A written test which mainly focuses on Complexity topics and a laboratory test which mainly focuses on Algorithmic topics contribute to the vote in equal measure.
The writing is based on the path taken in class. For some examples of exercises, please refer to the reference repository for the written test:
https://github.com/romeorizzi/prove_scrive_AlgoComp
In the computer laboratory, students have to take a 5-hour test where they are assigned problems.
Students must analyze and understand the problems and their structure, identify algorithmic solutions for them, and implement these solutions in c/c++ or Pascal code. The more efficient this turns out to be, the more points you collect.
During the exam, students can gradually submit what they have produced to a site completely similar to the one used during the exercises in the laboratory and/or at home. In this way they can obtain an immediate and contextual evaluation that can guide them in conducting the test.
The solutions are evaluated based on the subtasks of the exercise that they manage to solve correctly without exceeding the time and memory resources predetermined by the exercise.
Find problems and reference materials for the laboratory test at the following repositories and platforms where you can try your hand at the exercises:
https://github.com/romeorizzi/esami-algo-public
https://rizzi.olinfo.it/algo-simula-prove
https://cms.di.unipi.it/algo/
The problems proposed there constitute the primary resource for preparing for the exam. The submission system you will use for the exam is TALight.
Even after obtaining a positive grade, the student can participate in multiple exams to see if he can improve it: the policy is to keep the best grade on the various exams, but there are also mechanisms by which the grades are added together.
You will find your grades portfolio on the course website:
http://profs.sci.univr.it/~rrizzi/classes/Algoritmi/index.html

Evaluation criteria

The various parts of the exam and grade management are characterized by maximum transparency.

Criteria for the composition of the final grade

When the student has, in his/her grade portfolio, both a positive grade (at least 18) for the Complexity module and a positive grade (at least 18) for the Algorithms module, he/she can ask the teacher in charge of the course to proceed with the recording of the grade for the entire course, obtained as the average of the grades for the two modules.
The average is rounded up and a 30 with honors is worth 33. To generate a 30 with honors as the final grade you need at least one honors and neither of the two evaluations below 30.
When you think the time has come to register your vote, send an email to romeo.rizzi@univr.it specifying:
1. your personal details (registration number VRxxxxxx);
2. vote you expect to be recorded;
3. vote for the algorithms part, specifying how it is composed (specifying the reference calls);
4. last complexity exam you submitted, with the grade obtained.
The ways to request registration and the entire workflow are shown on the page:
http://profs.sci.univr.it/~rrizzi/classes/Algoritmi/index.html
On the same page you will also find the portfolio of your votes, as well as information on how the vote for the Algorithms module is produced and managed.

Exam language

Italian. But, under request, we will prepare also an English text.