1 s t a t i c void 2 e x p l a i n _ e q _ a u x ( T n o d e u , T n o d e v , T s t a c k _ n o d e * e x p l a i n _ p e n d i n g ) 3 { 4 Tlit lit ; 5 T n o d e t r a v e l e r = v ; 6 BFS ( u ) ; 7 w h i l e ( s t a c k _ g e t ( p r e d _ e x p l a i n , t r a v e l e r ) != -1) 8 { 9 lit = g e t _ e q _ l i t ( traveler , s t a c k _ g e t ( p r e d _ e x p l a i n , t r a v e l e r ) ) ; 10 if ( lit ) s t a c k _ p u s h ( v e r i T _ c o n f l i c t , lit ) ;
11 else if ( t y p e _ n o d e ( t r a v e l e r ) == APP &&
12 t y p e _ n o d e ( s t a c k _ g e t ( p r e d _ e x p l a i n , t r a v e l e r ) ) == APP ) 13 e x p l a i n _ c o n g ( traveler , s t a c k _ g e t ( p r e d _ e x p l a i n , t r a v e l e r ) , e x p l a i n _ p e n d i n g ) ; 14 t r a v e l e r = s t a c k _ g e t ( p r e d _ e x p l a i n , t r a v e l e r ) ; 15 } 16 c l e a n _ v i s i t e d _ n o d e () ; 17 }
Figure 4.8 – Construction de la clause de conflit
4.5 conclusion
Dans ce chapitre, nous avons présenté une partie de l’implémentation du ground solveur pour la théorie de l’égalité en place dans le solveur SMT veriT. Cet algorithme permet en outre de traiter des formules sans quantificateur de la logique d’ordre supérieur sans λ-expression. Cette implémentation a une complexité quadratique dans le pire des scénarios et comme nous l’avons observé dans le chapitre précédent (section 3.8) dans la pratique cet algorithme est cinq fois moins rapide que l’implémentation optimale de la fermeture de congruence initialement utilisée dans veriT pour traiter des formules de la logique du premier ordre. La description de l’ensemble des algorithmes donnée dans cette section permet de s’assurer intuitivement de leur correction par construction. En effet dans la présentation de l’algorithme donnée ci-dessus nous avons décrit chacune des entrées possible et le traitement appliqué sur ces entrées. Ainsi pour chaque nou-veau littéral introduit dans la fermeture de congruence l’algorithme est capable de déterminer si l’ensemble des littéraux en cours de traitement est satisfaisable ou non. En effet la construc-tion de classe d’équivalence en utilisant des graphes permet de se convaincre de la correcconstruc-tion de l’algorithme de manière assez intuitive. Cette implémentation permet donc d’exprimer des ex-pressions de la logique d’ordre supérieur de manière assez naturel, mais peut aussi être une base solide pour des logiques plus riches. En particulier, il est possible d’implémenter assez facilement la théorie des data-types, mais aussi de traiter les symboles de fonction injective de manière efficace. Enfin cet algorithme permet une meilleure collaboration avec le module d’instanciation et peut notamment être utilisé pour effectuer l’algorithme de E-unification utilisé par le calcul CCFV. Une implémentation du solveur SMT veriT s’appuyant sur cet algorithme pour effectuer
Chapitre 4. Implémentation du solveur ground pour la logique d’ordre supérieur 1 s t a t i c void 2 e x p l a i n _ c o n g ( T n o d e u , T n o d e v , T s t a c k _ n o d e * e x p l a i n _ p e n d i n g ) 3 { 4 if (! a l r e a d y _ s e e n ( g e t _ l e f t ( u ) , g e t _ l e f t ( v ) ) ) 5 { 6 s t a c k _ p u s h (* e x p l a i n _ p e n d i n g , g e t _ l e f t ( u ) ) ; 7 s t a c k _ p u s h (* e x p l a i n _ p e n d i n g , g e t _ l e f t ( v ) ) ; 8 } 9 if (! a l r e a d y _ s e e n ( g e t _ r i g h t ( u ) , g e t _ r i g h t ( v ) ) ) 10 { 11 s t a c k _ p u s h (* e x p l a i n _ p e n d i n g , g e t _ r i g h t ( u ) ) ; 12 s t a c k _ p u s h (* e x p l a i n _ p e n d i n g , g e t _ r i g h t ( v ) ) ) ; 13 } 14 }
Figure 4.9 – Expliquer les congruences
l’instanciation des quantificateurs (via une version de CCFV modifiée) est aussi disponible sur le dépôt5.
5
Améliorer l’instanciation via des
méthodes d’apprentissage
Sommaire
5.1 Introduction . . . . 71 5.2 Contexte . . . . 73 5.2.1 Petits rappels sur SMT . . . . 73 5.2.2 Instanciation dans SMT . . . . 74 5.2.3 À la recherche des bonnes instances . . . . 75 5.3 Une approche par apprentissage pour l’instanciation . . . . 77 5.3.1 Encoder SMT comme un problème de classification . . . . 78 5.3.2 Concevoir les features . . . . 78 5.3.3 Description du problème de l’instanciation . . . . 82 5.3.4 Apprentissage automatique . . . . 84 5.3.5 Les arbres de décision . . . . 86 5.3.6 Intégration du classifieur . . . . 88 5.4 Evaluation . . . . 90 5.5 Travaux similaires . . . . 96 5.6 Conclusion . . . . 97
5.1 Introduction
Comme vu au chapitre 2, les solveurs SMT sont des outils particulièrement efficaces pour rai-sonner, avec des théories, sur des formules de la logique du premier ordre. Lorsque les problèmes contiennent des quantificateurs, les solveurs SMT s’appuient sur le processus d’instanciation. L’instanciation dérive un ensemble d’instances à partir des formules quantifiées. Plus précisé-ment, les variables liées aux quantificateurs, dans les formules, sont remplacées par des termes
Chapitre 5. Améliorer l’instanciation via des méthodes d’apprentissage
qui apparaissent généralement dans la fermeture de congruence. Pour instancier ces formules plusieurs stratégies peuvent être employées : l’approche par énumération [95], l’approche par trigger [41, 45], l’approche par conflit [97], ou encore l’approche par construction de modèle [55]. Parmi ces stratégies, seule l’approche par conflit permet de calculer efficacement un ensemble d’instances permettant d’éliminer le modèle E, produit en collaboration avec le SAT solveur et les procédures de décision. Cette approche est néanmoins incomplète, et nécessite d’être utilisée en combinaison avec d’autres méthodes comme les approches par trigger, ou par énumération. Malheureusement ces dernières sont très heuristiques, et génèrent un grand nombre d’instances. En conséquence, l’espace de recherche du solveur peut vite exploser. Ainsi, pour résoudre rapi-dement des problèmes avec quantificateurs, il faut être capable de trouver rapirapi-dement les bonnes instances, c’est-à-dire réduire le nombre d’instances inutiles données au solveur ground. Il est donc impératif d’améliorer l’efficacité du module d’instanciation, et pour cela nous proposons dans ce chapitre de sélectionner les instances produites par les approches par trigger et énumé-ration, à l’aide d’un algorithme de classification entraîné en amont sur plusieurs exemples de bonnes et mauvaises instances produites par le module d’instanciation.
L’apprentissage automatique est un domaine en plein essor. Popularisé par les algorithmes d’apprentissages profonds, et notamment très utilisé pour les systèmes de vision, l’apprentis-sage automatique peut aussi être appliqué à de nombreux autres domaines. Polyvalents, ces algorithmes ont la particularité d’apprendre une tache sans aucune connaissance préalable du domaine d’application, pour peu que ce dernier soit mathématiquement représentable. En effet à l’aide d’encodages spécifiques, ces algorithmes sont capables de comprendre et d’apprendre le fonctionnement d’un système. On distingue d’ailleurs deux types d’apprentissages : supervisé qui consiste à entraîner un modèle à partir d’un certain nombre d’observations étiquetées, et non supervisé où l’algorithme doit découvrir la structure du problème sans indication préalable. Récemment plusieurs solveurs automatiques, incorporant dans leur processus de recherche des algorithmes d’apprentissage, ont démontré leur efficacité face à des solveurs de dernière généra-tion. En particulier des systèmes comme Enigma et ATPBoost [67, 94] permettent de modérer le processus de preuve, et de suggérer des choix au solveur. Ces approches ont été majoritaire-ment appliquées à des architectures basées sur des systèmes de preuves de type superposition ou tableaux. Dans ce travail nous nous inspirons de ces travaux pour concevoir une approche par instanciation coopérant avec des algorithmes d’apprentissage supervisé, et dont le but est d’améliorer l’instanciation des quantificateurs au sein du SMT solveur veriT.
Le travail présenté dans ce chapitre est initialement motivé par la visite à Nancy de Cezary Kaliszyk. Ce travail est donc le fruit d’une collaboration étroite avec mes encadrants Jasmin Blan-chette et Pascal Fontaine pour la partie raisonnement automatique et SMT, et Cezary Kaliszyk qui a apporté son expertise dans le domaine de l’apprentissage automatique, en particulier pour la preuve automatique. L’idée générale de notre approche consiste à invoquer un classifieur après chaque cycle d’instanciation pour évaluer l’utilité potentielle de chaque instance. En fonction des prévisions, les instances sont soit introduites au problème original, retardées ou rejetées. Étant donné que l’instanciation des quantificateurs implique plusieurs milliers d’instances, le prédicteur doit être rapide. Par conséquent, il est important de choisir une approche simple à mettre en