WikiPrépaLivrets

Mines Informatique 1 MPI 2026Sujet et rapport du jury

2,3(3 votes)
  • Langages réguliers et automates finis : déterminisation, complémentaire, automate produit
  • Lemme de l'étoile et langages non réguliers
  • Programmation OCaml : tableaux, listes, complexité
  • Représentation binaire des entiers et exponentiation rapide
  • Logique du premier ordre et déduction naturelle
  • Preuves par induction structurelle
  • Réductions polynomiales et problème SAT

Téléchargements

  • Corrigé : pas encore disponible

Présentation du sujet

Difficulté moyenne
Décidabilité de l'arithmétique de Presburger à l'aide d'automates synchrones sur des vecteurs binaires
Afficher ou masquer la section

La première épreuve d'informatique MPI des Mines 2026 (3 heures, OCaml) est un problème unique de 30 questions en cinq sections. Elle part de l'écriture binaire des entiers pour construire des automates lisant plusieurs mots binaires en parallèle, reconnaître l'addition, écrire des formules de l'arithmétique de Presburger, puis montrer que leur validité est décidable par une construction inductive d'automates.

  1. 1Section 1 : implémentation de quelques fonctions utiles (Q1 à Q3)Exponentiation rapide, bijection entre les entiers de 0 à 2^n - 1 et les vecteurs binaires de taille n, puis son implémentation en OCaml.
  2. 2Section 2 : automates finis sur Σn (Q4 à Q13)Langages d'automates donnés, test de déterminisme complet, déterminisation par l'automate des parties, complémentaire et automate produit pour l'intersection.
  3. 3Section 3 : opérations arithmétiques (Q14 à Q16)Automate à deux états reconnaissant l'addition, preuve de sa correction et non-régularité du langage associé à la multiplication.
  4. 4Section 4 : arithmétique de Presburger (Q17 à Q22)Écriture de formules, mise sous forme simple par induction et preuves en déduction naturelle avec quantificateurs et règles de l'égalité.
  5. 5Section 5 : retour sur les automates (Q23 à Q30)Réduction polynomiale de Sat-Cnf à Tautologie-Presburger, projection existentielle d'un langage, construction d'un automate associé à une formule, preuve de correction et décision de la validité.

Difficulté moyenne. Le jury juge le niveau global bon et une note honorable accessible par la seule maîtrise du cours, mais très peu de candidats ont abordé sérieusement les questions 26 à 30.

Ce qu'a observé le jury

6 erreurs relevées
Exponentiation rapide mal programmée · Construction de cours non formalisée · Complexité dégradée par List.length
Afficher ou masquer la section

Le problème balaie une large part du programme de MPI : OCaml, automates, logique et complexité. Une grande majorité des candidats a compris les notions introduites et le jury signale quelques excellentes copies, mais la restitution et l'application directe des théorèmes et algorithmes de cours sont souvent insuffisantes. Un peu plus d'un tiers des copies a subi un malus de présentation.

Les erreurs les plus sanctionnées

  1. 1
    Exponentiation rapide mal programméeQ1

    Passer par les flottants et l'opérateur ** était incorrect pour des entiers. Deux appels récursifs dans le même appel font perdre la complexité logarithmique demandée.

    « trop de candidats ont utilisé deux appels récursifs lors du même appel »
  2. 2
    Construction de cours non formaliséeQ9, Q13

    Pour la déterminisation, il fallait définir formellement états, transitions, état initial et états finaux de l'automate des parties. L'automate de Glushkov ou l'ajout d'un état puits ne déterminisent pas.

    « Un exemple de construction d'un tel automate ne constituait pas une réponse correcte à elle seule. »
  3. 3
    Complexité dégradée par List.lengthQ8

    Appeler List.length à chaque tour de boucle dépasse la complexité attendue ; un filtrage suffisait. Le déterminisme devait être vérifié pour tous les états, pas seulement les états accessibles.

  4. 4
    Automate de l'addition incomplet ou non prouvéQ14, Q15

    Beaucoup de propositions oublient l'état où la retenue vaut 1 et les transitions qui y restent. Pour la preuve, il fallait une justification rigoureuse, par exemple une condition nécessaire et suffisante.

    « Les réponses ne faisant que paraphraser l'automate proposé à la question précédente n'ont obtenu aucun point. »
  5. 5
    Non-régularité mal justifiéeQ16

    Le langage de la multiplication n'étant pas régulier, on pouvait utiliser la contraposée du lemme de l'étoile ; un argument intuitif ne suffit pas.

    « Il ne suffisait pas d'arguer que reconnaître ce langage nécessite d'utiliser une “mémoire non bornée” pour conclure. »
  6. 6
    Termes interdits en arithmétique de PresburgerQ17, Q18

    Les constantes 0 et 1, l'écriture 2y ou x = n ne sont pas des termes autorisés. Il fallait construire f0(x) et f1(x), puis fn(x) pour n ≥ 2.

    « puisqu'ils ne font pas partie des termes autorisés dans l'arithmétique de Presburger. »

Ce qui a été bien réussi

  • Les questions 5 et 6 sont parfaitement réussies par une majorité des candidats qui les ont traitées.
  • Les questions 13 et 17 sont réussies ; les questions 3, 7, 10 et 12 sont globalement ou plutôt bien traitées.
  • Les arbres de preuve en déduction naturelle (Q20 à Q22) sont plutôt réussis quand ils sont traités.
  • La plupart des programmes OCaml sont clairs, structurés et correctement indentés.

Conseils du jury

  • Donner une définition formelle complète lorsqu'une question demande de rappeler une définition, une construction ou un algorithme de cours.
  • Expliquer la stratégie des fonctions OCaml non évidentes et le rôle des fonctions auxiliaires, avec des noms pertinents, sans paraphraser le code.
  • Respecter les types de l'énoncé (tableaux contre listes, bool array contre int array) et connaître la complexité de Array.make, Array.length et List.length.
  • Pour une preuve par induction, préciser l'ensemble, la variable, la propriété et les hypothèses utilisées dans chaque cas inductif.
  • En logique, préciser la valuation avant de dire qu'une formule est vraie et distinguer le connecteur ↔ de l'équivalence sémantique ≡.
  • Indiquer clairement les étapes non démontrées d'un raisonnement : le jury l'a valorisé.

Synthèse rédigée par WikiPrépa à partir du rapport officiel du jury (à télécharger en PDF). Les citations sont extraites du rapport.

Ces sujets peuvent vous intéresser

Pas encore de corrigé pour ce sujet : voici des sujets proches corrigés.

Lecture du sujet en ligne

L'énoncé complet, avec les formules et les figures, sans ouvrir le PDF.
Afficher ou masquer la section

ÉCOLE NATIONALE DES PONTS et CHAUSSÉES, ISAE-SUPAERO, ENSTA, TÉLÉCOM PARIS, MINES PARIS - PSL, MINES SAINT-ÉTIENNE, MINES NANCY, IMT ATLANTIQUE, ENSAE PARIS, CHIMIE PARISTECH - PSL.

Concours Mines-Télécom, Concours Centrale-Supélec (Cycle International).

CONCOURS 2026
PREMIÈRE ÉPREUVE D'INFORMATIQUE
Durée de l'épreuve : 3 heures
L'usage de la calculatrice ou de tout dispositif électronique est interdit.
Les candidats sont priés de mentionner de façon apparente sur la première page de la copie :
INFORMATIQUE I - MPI
Cette épreuve concerne uniquement les candidats de la filière MPI.
L'énoncé de cette épreuve comporte 9 pages de texte.
Si, au cours de l'épreuve, un candidat repère ce qui lui semble être une erreur d'énoncé, il le signale sur sa copie et poursuit sa composition en expliquant les raisons des initiatives qu'il est amené à prendre.

Préliminaires

L'épreuve est composée d'un problème unique, comportant 30 questions. Le problème est divisé en cinq sections. Dans la première section (page 2), nous implémentons plusieurs fonctions mathématiques. Dans la deuxième section (page 3), nous étudions des automates sur un alphabet particulier et nous nous intéressons à une implémentation. Dans la troisième section (page 5), nous nous intéressons à la reconnaissabilité de certains langages sous cet alphabet. Dans la quatrième section (page 5), nous nous intéressons à l'arithmétique de Presburger et ses formules logiques. Enfin, dans la cinquième et dernière section (page 7), nous cherchons à décider de la satisfiabilité de ces formules à l'aide des automates précédemment étudiés.
Dans tout l'énoncé, un même identificateur écrit dans deux polices de caractères différentes désigne la même entité, mais du point de vue mathématique pour la police en italique (par exemple n ) et du point de vue informatique pour celle en romain avec espacement fixe (par exemple n).
Des rappels portant sur les règles de la déduction naturelle sont fournis en annexe.

Travail attendu

Pour répondre à une question, il est permis de réutiliser le résultat d'une question antérieure, même sans avoir réussi à établir ce résultat.
Il faudra coder des fonctions à l'aide du langage de programmation OCaml exclusivement. Les fonctions des modules List et Array peuvent être utilisées sans explication. Il est cependant recommandé de s'en tenir aux fonctions les plus courantes afin de rester compréhensible.
Le barème tient compte de la clarté et de la concision des programmes. Nous recommandons de choisir des noms de variables intelligibles ou encore de structurer de longs codes par des blocs ou par des fonctions auxiliaires dont on décrit le rôle.

Introduction

On note ℕ l'ensemble des entiers naturels. Pour tout couple d'entiers a, b tel que a ⩽ b, on note [ [a, b] ] l'ensemble des entiers de a à b compris. Pour tout ensemble E, on note P(E) l'ensemble des parties de E, c'est-à-dire l'ensemble des sous-ensembles de E. Pour tout ensemble fini E, on note |E| son cardinal.
Pour tout mot m, on note |m| la taille de m, qui correspond à son nombre de lettres.
Dans tout le sujet, pour tout entier n positif, on notera Σ_n l'alphabet composé des vecteurs colonnes de taille n à valeurs dans {0,1}. Par exemple,
Σ_2 = {(0/0), (1/0), (0/1), (1/1)}.
Pour tout entier i dans [ [1, n] ], et pour tout mot m sur Σ_n, on note π_i(m) la projection de m sur la composante i, c'est-à-dire, le mot sur {0, 1} composé du terme à la i-ème ligne sur chaque lettre de m.
Par abus de notation, on s'autorise à confondre la lettre 0 et 1 de l'alphabet {0,1} avec les entiers 0 et 1 . Pour tout mot u de taille |u| = k sur {0, 1} tel que u = u_0…u_(k − 1), on va noter v(u) la valeur suivante :
v(u) = ∑_(j = 0)^(k − 1)2^j u_j
Autrement dit, v(u) est l'entier dont u en est une de ses représentations en binaire telles que le bit de poids faible soit à gauche, donc à l'inverse du sens habituel.
Pour un mot m sur Σ_n et un entier i entre 1 et n, on note v_i(m) = v(π_i(m)).
Considérons par exemple le mot m suivant :
m = (0; 1; 1)(1; 0; 1)(1; 0; 0)(0; 0; 0)(1; 1; 1)(0; 1; 1)(1; 0; 1)(1; 0; 0)
On a π_2(m) = 10001100, v_1(m) = 2 + 4 + 16 + 64 + 128 = 214, v_2(m) = 49 et v_3(m) = 115.
Dans ce sujet, un automate fini non déterministe à un seul état initial, qu'on s'autorise à appeler simplement automate, est défini comme un tuple A = (Σ, Q, q_0, F, δ) où :
  • - Σ est un alphabet fini;
  • - Q est un ensemble fini d'états;
  • - q_0 est un état de Q appelé état initial;
  • - F est un sous-ensemble de Q appelé ensemble des états finaux ;
  • - δ est une fonction de Q × Σ dans P(Q) appelée fonction de transition.
On dit qu'un automate A = (Σ, Q, q_0, δ, F) est déterministe complet lorsque pour chaque sommet q ∈ Q, et chaque lettre a ∈ Σ, on a |δ(q, a)| = 1.
Pour deux états p et q de Q, et pour toute lettre a de Σ, on note p → ^a q si q ∈ δ(p, a). On dit qu'il existe une transition de p à q étiquetée par a. On prend comme convention graphique d'indiquer l'état initial par une flèche entrante et les états finaux en les entourant.
Pour un automate A on note L(A) le langage reconnu par A.
Dans tout le sujet, on fera l'hypothèse simplificatrice qu'en OCaml, on dispose d'une mémoire infinie et que les variables peuvent stocker des valeurs aussi grandes que l'on souhaite.

1. Implémentation de quelques fonctions utiles

Commençons par implémenter plusieurs fonctions mathématiques qui nous seront utiles dans la suite.
  • □1 - Écrire une fonction pow2 : int -> int qui prend en entrée un entier n et renvoie 2^n. On attend une fonction récursive de complexité temporelle en O(log(n)).
On représente en OCaml les lettres de Σ_n à l'aide du type int array en utilisant des tableaux de dimension n dont les éléments sont à valeurs dans {0,1}.
  • □2 - Exhiber une bijection entre [ [0, 2^n − 1] ] et Σ_n.
    À présent, on souhaite implémenter notre bijection.
  • □3 - Écrire une fonction decompose : int -> int -> int array qui prend en entrée x et n tels que x ∈ [ [0, 2^n − 1] ] et qui renvoie l'élément de Σ_n associée par la bijection précédemment définie. On vérifiera que l'entrée est valide à l'aide d'une assertion.

2. Automates finis sur ∑_n

Considérons les automates A_1 et A_2 suivants :
Figure 1 - Représentation de l'automate A_1
Figure 2 - Représentation de l'automate A_2
Soit E l'ensemble des mots m sur Σ_2 tels que v_2(m) est la plus grande puissance de 2 qui divise v_1(m).
□ 4 - Démontrer rigoureusement que L(A_1) = E.
□ 5 - Montrer que pour tout m ∈ L(A_1), v_1(m) ≡ v_2(m)[2 × v_2(m)].
□ 6 - Décrire sans justifier le langage L(A_2) en donnant une condition nécessaire et suffisante pour qu'un mot m sur Σ_2 soit dans le langage qui fait intervenir v_1(m) et v_2(m).
□ 7 - Proposer sans justifier un automate à 3 états qui reconnaît le langage L défini par :
L = {m ∈ Σ_3^∗|v_1(m) = v_3(m) ou v_2(m) = v_3(m)}
Pour implémenter les automates, on utilise le type automate suivant en OCaml. Un automate sur Σ_n à k états est représenté en utilisant un entier différent dans [ [0, k − 1] ] pour chaque état. L'état initial est toujours l'état 0.
type automate = {
    k : int ;
    n : int ;
    finaux : bool array ;
    delta : int -> int array -> int list ;
}
Ici, k correspond donc au nombre d'états de l'automate, n correspond à n, finaux est un tableau de booléens de taille k qui indique si un état est final, et delta est la fonction de transition prenant en paramètre un état q et une lettre a, représentée par un tableau d'entiers de taille n, et renvoie la liste des états de δ(q, a)
□ 8 - Écrire une fonction est_deterministe_complet : automate -> bool qui vérifie si un automate A = (Σ_n, Q, q_0, δ, F) est déterministe complet. On attend une complexité temporelle en O(n × |Q| × |Σ_n|). Justifier la complexité obtenue.
On se propose maintenant d'implémenter l'algorithme de déterminisation des automates.
□ 9 - Soit A = (Σ, Q, q_0, δ, F) un automate fini non déterministe. Donner la construction formelle d'un automate déterministe reconnaissant L(A).
□ 10 - Écrire une fonction union : int array -> automate -> int array -> int array qui prend en entrée les paramètres etats, a et lettre, tels que :
  • a soit un automate à k états;
  • etats soit un tableau d'entiers de taille k à valeur dans {0,1};
  • lettre soit une lettre représentée par un tableau d'entiers.
Cette fonction doit renvoyer un tableau t de taille k, tel que t.(i)=1 s'il existe un q tels que etats. (q) = 1 et q→−^(lettre)i est une transition de a, et t. (i)=0 sinon.
□ 11 - En déduire une fonction determinise : automate -> automate qui prend en entrée un automate et renvoie un automate déterministe complet reconnaissant le même langage.
Indication : On pourra utiliser la fonction decompose plusieurs fois.
On appelle complémentaire d'un langage L sur un alphabet Σ le langage L¯ des mots sur Σ n'appartenant pas à L.
□ 12 - Écrire une fonction complementaire : automate -> automate qui prend en entrée un automate et renvoie un automate reconnaissant son langage complémentaire.
□ 13 - Considérons deux automates A_1 = (Σ_n, Q_1, q_1, δ_1, F_1) et A_2 = (Σ_n, Q_2, q_2, δ_2, F_2). Donner la construction formelle d'un automate ayant pour ensemble d'états Q_1 × Q_2 et reconnaissant L(A_1) ∩ L(A_2). Ici Q_1 × Q_2 est le produit cartésien de Q_1 et Q_2.
On suppose dans la suite disposer d'une fonction OCaml intersection : automate -> automate -> automate qui prend en entrée deux automates et renvoie un automate reconnaissant l'intersection de leurs langages.

3. Opérations arithmétiques

On s'intéresse à présent aux opérations arithmétiques en binaire et à la possibilité de les représenter à l'aide d'automates sur Σ_3.
  • □14 - Donner, dans un premier temps sans justifier, un automate à deux états reconnaissant le langage L_+ = {m ∈ Σ_3^∗|v_1(m) + v_2(m) = v_3(m)}.
  • □15 - Démontrer que l'automate proposé dans la question précédente reconnaît bien L_+.
    ◻16 - Le langage L_× = {m ∈ Σ_3^∗|v_1(m) × v_2(m) = v_3(m)} est-il reconnaissable? Justifier.

4. Arithmétique de Presburger

L'arithmétique de Presburger est l'arithmétique usuelle des entiers et de l'addition, mais sans la multiplication.
Soit V un ensemble infini de variables.
L'ensemble des termes est défini inductivement de la façon suivante :
  • -pour tout x ∈ V, x est un terme;
  • -pour deux termes t_1 et t_2, t_1 + t_2 est un terme.
L'ensemble des formules de Presburger, qu'on s'autorise à appeler formules, est ensuite défini inductivement de la façon suivante :
  • -pour t_1 et t_2 deux termes, t_1 = t_2 est une formule;
  • -pour φ une formule, ¬φ est une formule;
  • -pour φ_1 et φ_2 deux formules φ_1 → φ_2, φ_1 ∧ φ_2 et φ_1 ∨ φ_2 sont des formules;
  • -pour φ une formule et x une variable qui n'apparaît pas juste après un quantificateur dans φ, alors ∃x.φ et ∀x.φ sont des formules.
L'évaluation des formules suit le sens habituel de l'opérateur d'égalité =, et des opérateurs logiques. Les quantificateurs ont leur sens usuel avec des variables prises à valeurs dans l'ensemble ℕ. On utilise des parenthèses pour repérer les sous-formules lorsqu'il y a ambiguïté et pour indiquer les priorités d'ordre des opérations usuelles.
Pour toute formule φ, et toute sous-formule ∀x.ψ ou ∃x.ψ de φ, on dit que toutes les occurrences de x dans ψ sont liées. Les occurrences non liées de x dans φ sont dites libres. Si φ possède des occurrences libres de x, on dit que x est une variable libre de φ.
Dans la formule ∃x.∀y.(z = t + y ∧ z = x) ∨ (∃w.z = t + w), les variables x, y et w sont liées, et les variables libres sont z et t.
Pour x¯ un vecteur de variables, on notera souvent φ(x¯) pour signifier que x¯ est l'ensemble des variables libres de φ. Une assignation est une fonction des variables libres de φ vers ℕ.
Pour φ une formule de Presburger et a une assignation de ses variables libres, on note [ [φ] ]_a la valeur de vérité de φ dans l'assignation a.
Par exemple, considérons la formule φ_⩽(x, y):=∃z.y = x + z, où := est un opérateur de définition. Ici, z est une variable liée, et y et x sont des variables libres. Pour un x et un y donnés, cette formule est vraie si et seulement s'il existe un entier z dans ℕ tel que y = x + z, donc si et seulement si x ⩽ y.
Pour deux formules φ et φ^′ ayant le même ensemble de variables libres, on dit qu'elles sont équivalentes, si pour toute assignation de ces variables libres, elles ont la même valeur de vérité.
□ 17 - Donner une formule de Presburgerdiv_2(x) qui est vraie si et seulement si x est divisible par 2.
□ 18 - Pour tout entier n ∈ ℕ, donner une formule de Presburger f_n(x) qui est vraie si et seulement si x = n.
Attention, n n'est pas un terme et ne peut donc pas apparaître dans votre formule sous cette forme.
On dit qu'une formule est sous forme simple si elle vérifie les propriétés suivantes :
  • (i)Elle ne contient pas les opérateurs ∨ et →.
  • (ii)Elle ne contient pas le quantificateur ∀.
  • (iii)Pour toute sous-formule de la forme t_1 = t_2, t_1 est une variable dans V et
    - soit t_2 est une variable dans V;
    - soit t_2 = x + y avec x et y deux variables de V.
□ 19 - Montrer que toute formule de Presburger φ est équivalente à une formule sous forme simple.
On veut à présent montrer que certaines formules sont des tautologies à l'aide de la déduction naturelle.
□ 20 - Prouver à l'aide de la déduction naturelle le séquent suivant où φ(x) désigne une formule faisant apparaître la variable libre x et ψ(y) désigne une formule faisant apparaître la variable libre y.
⊢(φ(x) ∨ ψ(y)) → (¬φ(x) → ψ(y))
Pour φ une formule, x une variable, et t un terme, on note φ[t/x] la formule φ où toutes les occurrences libres de x ont été remplacées par le terme t. Pour pouvoir effectuer des preuves sur des formules plus complexes, on introduit les règles suivantes sur l'égalité pour x une variable, φ une formule et t un terme :
(Γ ⋅ x = t⊢φ[t/x])/(Γ⊢t = t)ax_= (Γ, x =)/(Γ, x = t⊢φ)sub_=
De plus, on sait que l'addition est associative et pour simplifier les preuves, on s'autorise à utiliser cette propriété dans nos arbres. Par exemple, pour t_1, t_2 et t_3 des termes, on peut considérer que t_1 + (t_2 + t_3) est le même terme que (t_1 + t_2) + t_3 ainsi que t_1 + t_2 + t_3.
□ 21 - Donner une formule sans variable libre de Presburger exprimant le fait que l'égalité est transitive sur les variables et la prouver en utilisant la déduction naturelle.
□ 22 - Prouver à l'aide de la déduction naturelle le séquent suivant.
⊢∀x.∀y.∀z.(∃a.∃b.x = y + a ∧ y = z + b) → (∃c.x = z + c)

5. Retour sur les automates

On s'intéresse au problème suivant.
Tautologie-Presburger
  • -Entrée : Une formule de Presburger φ sans variable libre.
  • -Sortie : La valeur de vérité de cette formule.
On rappelle la définition du problème Sat-Cnf.
Sat-Cnf
  • -Entrée : Une formule logique sans quantificateur φ sous forme normale conjonctive.
  • -Sortie : Un booléen indiquant si φ est satisfiable.
□ 23 - Montrer que Sat-Cnf se réduit polynomialement à Tautologie-Presburger.
On veut à présent montrer que le problème Tautologie-Presburger est décidable. Pour ce faire, on veut transformer une formule de Presburger en un automate et se ramener à la question de savoir si un langage est vide ou non.
Avant de faire le lien entre automate et formules, on doit d'abord s'intéresser au problème des différentes représentations des entiers dues aux zéros non significatifs.
Soit n un entier naturel non nul et i dans [ [1, n] ]. Soit L un langage sur Σ_n. On note L_(∃i) le langage défini par :
L_(∃i) = {m ∈ Σ_n^∗|∃w ∈ L, ∀k ∈ [ [1, n] ], k ≠ i, π_k(m) = π_k(w)}.
Autrement dit, il s'agit de l'ensemble des mots égaux à un mot de L sauf possiblement à la ligne i.
◻24 - Soit L = {ε, (0; 1; 1), (0; 0; 0)(1; 1; 1)}}}{{, donner L_(∃2).
□ 25 - Écrire une fonction automate_existe : automate -> int -> automate qui prend en entrée un automate A et un entier i et qui renvoie un automate reconnaissant L(A)_(∃i).
Soit n un entier supérieur ou égal à 3. Soit, i, j et k des entiers de [ [1, n] ].
On note L_(i, j, k) le langage {m ∈ Σ_n^∗|v_i(m) + v_j(m) = v_k(m)}. On suppose disposer d'une fonction automate_somme : int -> int -> int -> int -> automate telle que automate_somme n i j k renvoie un automate reconnaissant L_(i, j, k).
On note L_(= i, j) le langage {m ∈ Σ_n^∗|v_i(m) = v_j(m)}. On suppose disposer d'une fonction automate_egalite : int -> int -> int -> automate telle que automate_egalite n i j renvoie un automate reconnaissant L_(= i, j).
On suppose également disposer d'une fonction sans_zero : automate -> automate qui prend en entrée un automate et qui renvoie une copie de cet automate dans laquelle les états finaux sont les états permettant d'accéder à un état final de l'automate initial par une suite de transitions étiquetées par la lettre (0; ⋮; 0).
Considérons une formule sous forme simple φ utilisant n variables qu'on note {x_1, …, x_n}. Soit k le nombre de variables libres de φ. Soit une fonction f strictement croissante de [ [1, k] ] dans [ [1, n] ] telle que les {x_(f(1)), …, x_(f(k))} est l'ensemble des variables libres de φ. Pour tout mot m de Σ_n, on note a^m l'assignation des variables libres de φ définie pour i dans [ [1, k] ] par a^m(x_(f(i))) = v_(f(i))(m). On note L_φ le langage
L_φ = {m ∈ Σ_n^∗|[ [φ] ]_(a^m) est vrai }.
Intéressons-nous à l'implémentation des formules de Presburger sous forme simple. On représente les variables par des entiers. On utilise les types OCaml suivants :
type terme = V of int | Plus of int*int
type formule =
    |Existe of int * formule
    |Et of formule * formule
    |Non of formule
    |Egale of terme * terme
  • □26 - Expliquer en langage courant le principe d'un algorithme qui prend en entrée une formule φ sous forme simple, l'indice de la plus grande variable apparaissant dans φ, et qui renvoie un automate reconnaissant L_φ.
  • □27 - Faites tourner à la main votre algorithme en détaillant bien les étapes et automates intermédiaires sur la formule φ(x_2):=¬∃x_1.¬(x_1 = x_2) pour renvoyer l'automate correspondant
  • □28 - Écrire une fonction automate_formule : formule -> int -> automate qui prend en entrée une formule φ sous forme simple et l'indice de la plus grande variable apparaissant dans φ, et qui renvoie un automate reconnaissant L_φ.
  • □29 - Démontrer la correction de votre algorithme.
  • □30 - En déduire une fonction est_vraie : formule -> int -> bool qui détermine pour une formule sous forme simple supposée sans variable libre et le plus grand indice de ses variables si elle est vraie.

A. Annexe : Règles de la déduction naturelle

On présente les règles de la déduction naturelle suivantes.
Les arbres de preuves doivent être effectués à partir de l'ensemble de règles fourni ci-dessous.
(Γ⊢B)/(Γ, A⊢A) ax, (Γ⊢⊥)/(Γ, A⊢B) ⊥; (Γ⊢A ∨ ¬A)/(Γ⊢A) t.e., (Γ, ¬A⊢⊥)/(Γ⊢A)RAA; (Γ, A⊢B)/(Γ⊢A → B) → _i, (Γ⊢A → B Γ⊢A)/(Γ⊢B) → _e; (Γ⊢A Γ⊢B)/(Γ⊢A ∧ B) ∧ _i, (Γ⊢A ∧ B)/(Γ⊢A) ∧ _e^g (Γ⊢A ∧ B)/(Γ⊢B) ∧ _e^d; (Γ⊢A)/(Γ⊢A ∨ B) ∨ _i^g, (Γ⊢A)/(Γ⊢A ∨ B) ∨ _i^d; (Γ, A⊢⊥)/(Γ⊢¬A)¬_i, (Γ⊢A⊢A Γ, B⊢C)/(Γ⊢A) ∨ _e; (Γ, A, B⊢C)/(Γ, A ∧ B⊢C)cut; (Γ⊢A x ∉ FV(Γ))/(Γ⊢∀x.A)∀_(i_ι); (Γ⊢∃x.A Γ, A⊢B x ∉ FV(Γ) ∪ FV(B))/(Γ⊢B)∃_e; (Γ⊢A[t/x])/(Γ⊢∃x.A)∃_i (Γ⊢∀x.A)/(Γ⊢A[t/x])∀_e; Γ, ∃x.A⊢B
Où FV(A) désigne l'ensemble des variables libres dans une formule A et FV(Γ) l'ensemble des variables libres dans un ensemble de formules Γ. De plus, A[t/x] correspond à la formule A où les occurrences d'une variable libre x ont été remplacées par t.
Fin de l'épreuve

  1. Les sujets sont la propriété du GIP CCMP. Ils sont publiés sous les termes de la licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Pas de Modification 3.0 France.

Questions fréquentes

3 questions
Sur quoi porte le sujet d'informatique 1 MPI des Mines 2026 ?
Afficher ou masquer la section

Sur quoi porte le sujet d'informatique 1 MPI des Mines 2026 ?

Sur la décidabilité de l'arithmétique de Presburger : automates synchrones sur des vecteurs binaires, automate de l'addition, formules et déduction naturelle, réduction depuis Sat-Cnf et construction d'un automate pour chaque formule.

Quelles erreurs le jury a-t-il relevées en informatique 1 MPI Mines 2026 ?

Exponentiation rapide non logarithmique, déterminisation décrite sur un exemple au lieu d'être formalisée, preuves d'automates réduites à une paraphrase, termes interdits dans les formules de Presburger et malus fréquents pour la présentation.

Comment obtenir une note correcte à l'épreuve d'info 1 MPI Mines 2026 ?

Selon le jury, la maîtrise des notions de cours assurait une note honorable même en ne traitant qu'une partie du sujet. Les questions 1, 2, 4, 8, 14 et 19 ont été discriminantes.

Pas de description pour le moment