3.2.1 AI: Circuits for Data Analysis

Circuits are concise representations of data sets that recently found a unifying interest in various areas of artificial intelligence. A circuit may for instance represent the answer set of a database query as a dag whose operators are disjoint unions (for disjunction) and Cartesian products (for conjunction). Similarly, it may also represent the set of all matches of a pattern in a graph. The structure of the circuit may give rise to efficient algorithms to process large data sets based on representation that are often much smaller. Among others, such applications range from knowledge representation/compilation, counting the number of solutions of queries, efficient query answering, factorized databases.

In a first line of research, we want to study novel problems on circuits, in which database queries are relevant to data analysis tasks from artificial intelligence, in machine learning or data mining in particular. In particular we propose to study optimization problems on answer sets of database queries based on circuits, i.e. how to find optimal solutions in the answer set for a given set of conditions. Decompressing small circuits into large answer sets would make the optimization problem unfeasible in many cases. We believe that circuits can structure certain optimization problems in such a way that it can be phrased concisely and then solved efficiently.

Second, we propose to develop a tighter integration between circuits and databases. Indeed query-related circuits are generally produced from a database. This requires that the data is copied within the circuits. This memory cost is accompanied with the loss of the environment of the DBMS which allows many optimizations and uses many low level optimizations that are hard to implement. We propose then to encode circuits directly within the database using materialized views and index structures. We shall also develop the required computational tools for maintaining and exploiting these embedded circuits.

3.2.2 Path Query Optimization

Graph databases are easily queried using path descriptions. Most often these paths are described by means of regular expressions. This makes path queries difficult as the use of Kleene star makes them recursive. In relational DBMS, recursion is almost never used and it is not advised to use it. The natural theoretical tool that pertains to recursion in the context of relational data Datalog. There has been a wealth of optimization algorithms that have been proposed for queries written in Datalog. We propose to use Datalog as a low level language to which we will compile path queries of various kinds. The idea is that the compiler will try to obtain Datalog programs that will have low execution complexity taking advantages of optimization techniques such as magic supplementary set rewriting, pre-computed indexes and also statistics computed from the graph. Our goal is to develop a compiler that will be able to efficiently evaluate path queries on large graphs which in particular will explore only a part of it.

3.3.1 Functional Programming Languges for Data Graphs

The first question is which kind of programming language to use to enable monitoring processes for data graphs based on query answering. While languages of path queries found quite some interest on data graphs, less attention has been given to the programming language tasks, that needed to be solved to produce structured output and to compose various queries with structured output into a pipeline. We believe that transferring the generalization of ideas developed for data trees in the context of XML to data graphs will allow to solve such problems in a systematic manner.

Our approach will consist in developing a functional programming language based on first principles (the lambda calculus, graph navigation, logical connective) that generalizes full XPath 3.0 to the context of graphs. Here we can rely on own previous work for data trees, such as the language X-Fun and $\lambda$-XP. After the language for data graphs is designed we shall study its behavior empirically by means of an implementation. This implementation will help us to design optimization methods so as to evaluate the queries in that language. This will allow us to use a wealth of techniques so as to optimize the computation. Indeed, we can try to compile data structures to imperative ones when possible and also exploit possibilities of parallel executions in certain cases. Functional programming comes with nice verification techniques that we are going to use in several contexts: (i) in optimizing queries (e.g. stop the evaluation when it is possible to know that no more data can contribute to the output) and (ii) to verify that the query behaves correctly. The verification methods we shall focus on will be mainly related to automata and transducers.

Finally we shall also develop a programming language that allows to describe services that use datagraphs as a backend for storing data. Here again, functional programming seems a good candidate, we would need however to orchestrate the concurrent executions of queries so as to ensure the correct behavior of services. This means that we should have concurrent constructs that are built in the language. The high level of concurrence enabled by the notion of futures seems an interesting candidate to adapt to the context of service orchestration.

3.3.2 Hyperstreaming Program Evaluation

Complex-event processing requires to monitor data graphs that are produced on input streams and to write data graphs to some output stream, which can then be used as inputs again. A major problem here is to reduce the high risk of blocking, which arises when the writing of some of the output stream suspends on a data value that will become available only in the future on some input stream. In such cases, all monitoring processes reading the output stream may have to suspend as well. In order to reduce the risk of blocking, we propose to develop the hyperstreaming approach further, of which we layed the foundations in the evaluation period based on automata techniques. The idea is to generalize streams to hyperstreams, i.e. to add holes to streams that can be filled by some other stream in the future. In order to avoid suspension as possible, a monitoring process on hyperstream must then be able to jump over the holes, and to perform some speculative computation. The objective for the next period are to develop tools for hyperstreaming query answering and to lift these to hyperstreaming program evaluation. Furthermore, on the conceptual side, the notion of certain query answers on hyperstreams needs to be lifted to certain program outputs on hyperstreams.

3.4.1 Data Quality with Schemas and Repairing with Inference

The data quality of RDF may suffer due to a number of reasons. Impurities may arise due to data value errors (misspellings, errors during data entry etc.). Such data quality problems have been thoroughly investigated in literature for relational databases and solutions include dictionary methods etc. However, it remains to be seen if the challenges of adapting the existing solutions for relational databases can be easily addressed.

One particular challenge comes from the fact that RDF allows a higher degree of structural freedom in how information is represented as opposed to relation databases, where the choice is strongly limited to flat tables. We plan to investigate suitability of existing data cleaning methods to tackle the problems of data value impurities in RDF. The structural freedom of RDF is a source of data quality issues on its own. With the recent emergence of schema formalisms for RDF, it becomes evident that significant parts of existing RDF repositories do not necessarily satisfy schemas prepared by domain experts.

In the first place, we intend to investigate defining suitable measures of quality for RDF documents. Our approaches will be based on a schema language, such as ShEx and SHACL, and we shall explore suitable variants of graph alignment and graph edit distance to capture similarity between the existing RDF document and its possible repaired versions that satisfy the schema.

The central issue here is repairing an RDF document w.r.t. schema by identifying essential fragments of the RDF that fail to satisfy the schema. Once such fragments are identified, repairing actions can be applied however there might be a significant number of alternatives. We intend to explore enumeration approaches where the space of repairing alternatives is intelligently browsed by the user and the most suitable one is chosen. Furthermore, we intend to propose a rule language for choosing the most suitable repairing action and will investigate inference methods to derive from interactions with user the optimal order in which various repairing actions are presented to the user and derive the rules for the choice of the preferred repairing action for repeating types of fragments that do not satisfy the schema.

3.4.2 Integration and Graph Mappings with Schemas and Inference

The second problem pertaining to integration of RDF data sources is their heterogeneity. We intend to continue to identify and study suitable classes of mappings between RDF documents conforming to potentially different and complementary schemas. We intend to assist the user in constructing such mappings by developing rich and expressive graphical languages for mappings. Also, we wish to investigate inference of RDF mappings with the active help of an expert user. We will need to define interactive protocols that allows the input to be sufficiently informative to guide the inference process while avoiding the pitfalls of user input being too ambiguous and causing combinatorial explosion. We intend to identify

RDF Data Quality. Approach based on a schema language (ShEx or SHACL) used to identify errors and giving a notion of a measure of quality of an RDF database. Impurities in RDF may come from data value errors (misspellings etc.) but also from the fact that RDF imposes fewer constraints on how data is structured which is a consequence of a significantly different use philosophy (just publish your data anyway you want). Repairing of RDF errors would be modeled with a localized rules (transformations that operate within a small radius of an affected node) and if several rules apply, preferences are used to identify the most desirable one. Both the repairing rules and preferences can be inferred with the help of inference algorithms in an interactive setting. Smart tools for LOD integration. Assuming that the LOD sources are of good quality, we want to build tools that assist the user in constructing mappings that integrate data in the user database. For this, we want to define inference algorithms which are guided by schemas, and which are based on comprehensible interactions with the user. For this, we need to define interactions that are rich enough to inform the algorithm, while simple enough to be understandable by a non-expert user. In particular, that means that we need to present data (nodes in a graph for instance) in a readable way. Also, we want to investigate how the - possibly inferred - schema can be used to guide the inference.

7.1.1 ShEx validator

• Name:
  Validation of Shape Expression schemas
• Keywords:
  Data management, RDF
• Functional Description:
  Shape Expression schemas is a formalism for defining constraints on RDF graphs. This software allows to check whether a graph satisfies a Shape Expressions schema.
• Release Contributions:

  ShExJava now uses the Commons RDF API and so support RDF4J, Jena, JSON-LD-Java, OWL API and Apache Clerezza. It can parse ShEx schema in the ShEcC, ShEJ, ShExR formats and can serialize a schema in ShExJ.

  To validate data against a ShExSchema using ShExJava, you have two different algorithms: - the refine algorithm: compute once and for all the typing for the whole graph - the recursive algorithm: compute only the typing required to answer a validate(node,ShapeLabel) call and forget the results.

• URL:
  http://­shexjava.­lille.­inria.­fr/
• Contact:
  Iovka Boneva

7.1.2 gMark

• Name:
  gMark: schema-driven graph and query generation
• Keywords:
  Semantic Web, Data base
• Functional Description:
  gMark allow the generation of graph databases and an associated set of query from a schema of the graph.gMark is based on the following principles: - great flexibility in the schema definition - ability to generate big size graphs - ability to generate recursive queries - ability to generate queries with a desired selectivity
• URL:
  https://­github.­com/­graphMark/­gmark
• Contact:
  Aurélien Lemay

7.1.3 SmartHal

• Keyword:
  Bibliography
• Functional Description:
  SmartHal is a better tool for querying the HAL bibliography database, while is based on Haltool queries. The idea is that a Haltool query returns an XML document that can be queried further. In order to do so, SmartHal provides a new query language. Its queries are conjunctions of Haltool queries (for a list of laboratories or authors) with expressive Boolean queries by which answers of Haltool queries can be refined. These Boolean refinement queries are automatically translated to XQuery and executed by Saxon. A java application for extraction from the command line is available. On top of this, we have build a tool for producing the citation lists for the evaluation report of the LIFL, which can be easily adapter to other Labs.
• URL:
  http://­smarthal.­lille.­inria.­fr/
• Contact:
  Joachim Niehren

7.1.4 QuiXPath

• Keywords:
  XML, NoSQL, Data stream
• Scientific Description:
  The QuiXPath tools supports a very large fragment of XPath 3.0. The QuiXPath library provides a compiler from QuiXPath to FXP, which is a library for querying XML streams with a fragment of temporal logic.
• Functional Description:
  QuiXPath is a streaming implementation of XPath 3.0. It can query large XML files without loading the entire file in main memory, while selecting nodes as early as possible.
• URL:
  https://­project.­inria.­fr/­quix-tool-suite/
• Contact:
  Joachim Niehren

7.1.5 X-FUN

• Keywords:
  Programming language, Compilers, Functional programming, Transformation, XML
• Functional Description:
  X-FUN is a core language for implementing various XML, standards in a uniform manner. X-Fun is a higher-order functional programming language for transforming data trees based on node selection queries.
• Contact:
  Joachim Niehren
• Participants:
  Joachim Niehren, Pavel Labath

7.1.6 ShapeDesigner

• Name:
  ShapeDesigner
• Keywords:
  Validation, Data Exploration, Verification
• Functional Description:
  ShapeDesigner allows construct a ShEx or SHACL schema for an existing dataset. It combines algorithms to analyse the data and automatically extract shape constraints, and to edit and validate shape schemas.
• URL:
  https://­gitlab.­inria.­fr/­jdusart/­shexjapp
• Contact:
  Jeremie Dusart

7.1.7 Coussinet

• Name:
  Coussinet
• Keywords:
  Enumeration, Complexity
• Functional Description:
  Coussinet is a demo illustrating a technique called geometric amortization for enumeration algorithms introduced in the paper Geometric Amortization for Enumeration Algorithms, Florent Capelli, Yann Strozecki. The result presented in this paper is about making the delay of enumeration algorithms more regular.
• URL:
  http://­florent.­capelli.­me/­coussinet/­coussinet.­html
• Contact:
  Florent Capelli
• Participants:
  Florent Capelli, Yann Strozecki

7.1.8 Colis

• Keywords:
  Debug, Automated deduction
• Functional Description:
  Paul Gallot developped a novel algorithm based on tree transducers, for spotting bugs in linux installation scripts. On a corpus of Debian package scripts, his implementation could find around 40 genuine bugs that were reported to the Debian community. This software is is part of Paul's PhD thesis, directed by Sylvain Salvati and Aurélien Lemay, and was funded by the ANR projec CoLiS coordinated by Ralf Treinen on the Correctness of Linux Scripts. The ColiS approach is to consider file systems as data trees, so that tree transducers can be used to represent operations on file system performed by Shell scripts to install and remove packages on Debian GNU/Linux distributions.
• Contact:
  Paul Gallot

8.1.1 Circuits for Data Analysis in Artificial Intelligence

Knowledge compilation is a general technique in artificial intelligence to obtain tractable algorithms for subclasses of algorithmic problems that are computationally hard. For instance, a variant of Yannakakis' algorithm can be used to compile acyclic conjunctive database queries to Boolean circuits. These will then be decomposable and deterministic, and thus tractable in polynomial time, while for the general class of conjunctive queries, testing the existence of a query answer on a relational database is coNP-complete. Another class of instances, where knowledge complilation is used in AI, concern satisfiablity problems. Beside of satisfiability, knowledge compilation is equally relevant to aggregation and enumeration problems.

Capelli et al. present at AAAI 25 a method to certify the output knowledge compilers and #SAT-solvers. This is a cooperation with Université de Lens. The idea is to output a certificate that can be checked in polynomial time and can be used to certify that a given CNF formula has K models. Their experiments were encouraging showing that a large majority of CNF formulas for which the #SAT-solver D4 terminates have certificates that can be checked more quickly than the compilation time.

In their article recently accepted at ICDT'2022 24, Capelli, Crosetti, Niehren and Ramon study the problem of optimizing a linear program whose variables are answers to a conjunctive query. For this they propose a new language for specifying linear programs whose constraints and objective functions depend on the answer sets of conjunctive queries. They developed an efficient algorithm for solving programs in a fragment of this language. Using tools from knowledge compilation, and exploiting the structure of queries having small treewidth (a graph parameter, intuitively measuring how far a graph is from being a tree), they are able to constructs a linear program having the same optimal value but fewer variables, thus nontrivially improving the asymptotic complexity of solving this task. They moreover illustrate the application of their language on three examples: optimizing deliveries of resources, minimizing noise for differential privacy, and computing the s-measure of patterns in graphs as needed for data mining.

8.1.2 Uncertainty and Explanations

Monet et al. 22 study in a paper at AAAI Shapely values for providing explanations to classification results over machine learning models. This work is done in cooperation with the Pontifical Catholic University of Chile. While in general computing Shapley values is a computationally intractable problem, it has recently been claimed that the SHAP-score can be computed in polynomial time over the class of decision trees. They show that the SHAP-score can be computed in polynomial time over deterministic and decomposable Boolean circuits.

In a new article in Transactions on Computational Logic 13, Monet et al. study the complexity of various counting problems that arise in the context of incomplete databases, i.e., relational databases that can contain unknown values in the form of labeled nulls. Intuitively, these problems can be used to answer queries on such incomplete data, for instance by computing how many ways there are to associate constants to the missing values of the database such that a given query is satisfied. They prove complexity dichotomy results between #P-hardness (i.e., highly intractable) and polynomial-time computability for these problems for self-join–free conjunctive queries (intuitively corresponding to the SELECT-PROJECT-JOIN fragment of SQL) and study the impact on the complexity of the various natural restrictions. They also study the approximability of these problems, and consider more expressive query languages to situate these problems with respect to known complexity classes.

In a recently accepted paper at SIGMOD'2022 26, Monet et al. use the framework of Shapley values to assign and compute contributions of input facts of a database to the results of a query. The goal is, intuitively, to explain the results of a query by computing a score for every input fact. The Shapley value is a game-theoretic notion for wealth distribution that is nowadays extensively used to explain complex data-intensive computation, for instance, in network analysis or machine learning. Monet et al. present in this paper two practically effective solutions for computing Shapley values in query answering. First, they establish a tight theoretical connection to the extensively studied problem of query evaluation over probabilistic databases, which allows then to obtain a polynomial-time algorithm for the class of queries for which probability computation is tractable. They then propose a first practical solution for computing Shapley values that adopts tools from probabilistic query evaluation and knowledge compilation. Experiments are caried that demonstrate the practical effectiveness of their solutions.

8.1.3 Query Optimization

In a PVLDB article 15, Staworko et al. study threshold queries, that is, queries that only require computing or counting answers up to a specified threshold value. This type of query is very common in practice, yet has been little studied. In this paper, they present a theoretical analysis of threshold query evaluation and show that thresholds can be used to significantly improve the asymptotic bounds of state-of-the-art query evaluation algorithms. In surprising contrast to conventional wisdom, they found important scenarios in real-world data sets in which users are interested in computing the results of queries up to a certain threshold, independent of a ranking function that orders the query results by importance.

8.2.1 Functional Programming Languages for Data Trees

Paul Gallot defended his thesis, “Safety of transformations of data trees: Tree transducer theory applied to a verification problem on shell scripts” 28, on December 16th 2021. Part of this thesis presents work done in the scope of the CoLiS project (ANR), which stands for Correctness of Linux Scripts. CoLiS’s stated goal is to apply techniques from deductive program verification and analysis of tree transfor- mations to the problem of analyzing Shell scripts used in software installation. Paul's thesis aims at studying formal modelisations of tree transformations, with a focus on tree transducers. In particular he uses tree transformations to represent operations on file systems which are represented as tree structures, by modelising operations performed by Shell scripts used to install and remove packages on Debian GNU/Linux distributions. Unix file systems are modeled as feature trees and the actions of Unix commands on a file system can be represented using a model he calls tree pattern transducers. He proposes to translate Unix commands into this model, and then then provides an algorithm for computing the composition of tree pattern transducers. A tool for finding the configurations of the file system which can make a given Shell script fail is implemented. The implementation is then tested on a corpus of Debian package scripts, and around 40 genuine bugs were found and reported to the Debian community. The thesis also contains more theoretical results, for instance the use of techniques from the field of functional programming to shed new light on known models of transducers.

8.2.2 Query Answering on Streams

In an article published at Algorithms 18 extending on a paper published at CSR'2020, they could show that regular path queries on XML documents in the usual XPathMark benchmark can be compiled to reasonably small deterministic automata on nested words. For this they propose new compilers to the novel class of deterministic stepwise hedge automata and proposed a minimization algorithm for them. We note that streaming evaluators for such automata are heavily stack based.

Paperman et al. received a best paper award for their ICALP'2021 article “Dynamic Membership for Regular Languages” 20, in which they study the dynamic membership problem for regular languages. This fundamental problem can be defined as follow: fix a language $L$, read a word $w$, build in time $O\left(\right|w\left|\right)$ a data structure indicating if $w$ is in $L$, and maintain this structure efficiently under letter substitutions on $w$. Intuitively, one can see the flux of letter substitutions as a stream of information, and we want to be able to efficiently determine if the word is still in the language or not. They obtain a trichotomy on the complexity of the problem – the description of which would be too technical for this document –, and solve related open questions on the dynamic word problem.

Boneva, Niehren et al. 14 study the complexity of regular matching and inclusion for compressed tree patterns with context variables subject to regular constraints. Context variables with regular constraints permit to properly generalize on unranked tree patterns with hedge variables. Regular inclusion on unranked tree patterns is relevant to certain query answering on Xml streams with references. They prove that regular matching and inclusion with regular constraints can be reduced in polynomial time to the corresponding problem without regular constraints.

8.3.1 Data Quality with Schemas and Repairing with Inference

Slawomir Staworko is part of a community effort between industry and academia to shape the future of property graph constraints, the results of which are reported in a recent SIGMOD paper 21. The standardization for a property graph query language is currently underway through the ISO Graph Query Language (GQL) project. Their position is that this project should pay close attention to schemas and constraints, and especially on key constraints. Motivated by use cases from the industry partners, they argue that key constraints should be able to have different modes, which are combinations of basic restriction that require the key to be exclusive, mandatory, and singleton. This lead them to propose PG-Keys, a flexible and powerful framework for defining key constraints that aims to guide the evolution of the standardization efforts towards making systems more useful, powerful, and expressive.

8.3.2 Integration and Graph Mappings with Schemas and Inference

In an ICDT'2022 paper 27, Lemay and Staworko, together with Benoît Groz and Piotr Wieczorek, investigate the problem of constructing a shape graph that describes the structure of a given graph database. They employ the framework of grammatical inference, where the objective is to find an inference algorithm that is both sound, i.e., always producing a schema that validates the input graph, and complete, i.e., able to produce any schema, within a given class of schemas, provided that a sufficiently informative input graph is presented. They identify a number of fundamental limitations that preclude feasible inference, and present inference algorithms based on natural approaches that allow to infer schemas that they argue to be of practical importance.

10.1.1 Participation in other International Programs

10.2.1 Visits of international scientists

• Nofar Cameli
  Technion, Israel. Links' online seminar. Nov, 2021.
• Sebastian Maneth
  Bremen University, Germany. Dec 16, 2021.

ANR JCJC KCODA

Participants: Florent Capelli [correspondent], Charles Paperman, Sylvain Salvati.

• Duration: 2021–2025
• Objectives: The aim of KCODA is to study how succinct representations can be used to efficiently solve modern optimization and AI problems that use a lot of data. We suggest using data structures from the field of compilation of knowledge that can represent large datasets succinctly by factoring certain parts while allowing efficient analysis of the represented data. The first goal of KCODA is to understand how one can efficiently solve optimization and training problems for data represented by these structures. The second goal of KCODA is to offer better integration of these techniques into the systems of database management by proposing new algorithms allowing to build factorized representations of the data responses to DB requests and by proposing encodings of these representations inside the DB.

ANR Colis — Correctness of Linux Scripts

Participants: Joachim Niehren [correspondent], Aurélien Lemay, Paul Gallot, Sylvain Salvati.

• Duration: 2015–2021
• Coordinator: R. Treinen, Université Paris Diderot
• Partner: C. Marché, Tocata project-team, Inria Saclay.
• Objective: This project aims at verifying the correctness of transformations on data trees defined by shell scripts for Linux software installation. The data trees here are the instance of the file system which are changed by installation scripts.

ANR DataCert

Participants: Iovka Boneva [correspondent], Sophie Tison, Jose Martin Lozano.

• Duration: 2015–2021
• Coordinator: E. Contejean, Université Paris-Sud
• Partners: Université de Lyon
• Objective: The main goals of the DataCert project are to provide deep specification in Coq of algorithms for data integration and exchange and of algorithms for enforcing security policies, as well as to design data integration methods for data models beyond the relational data model.

ANR Headwork

Participants: Joachim Niehren [correspondent], Momar Ndiouga Sakho, Nicolas Crosetti, Florent Capelli.

• Duration: 2016–2022
• Coordinator: D. Gross-Amblard, Druid Team, Université de Rennes 1
• Scientific partners: Dahu project-team (Inria Saclay) and Sumo project-team (Inria Bretagne)
• Industrial partners: Spipoll and Foulefactory.
• Objective: The main object is to develop data-centric workflows for programming crowd-sourcing systems in flexible declarative manner. The problem of crowd-sourcing systems is to fill a database with knowledge gathered by thousands or more human participants. A particular focus is to be put on the aspects of data uncertainty and for the representation of user expertise.

ANR Delta

Participants: Joachim Niehren [correspondent], Sylvain Salvati, Aurélien Lemay.

• Duration: 2016–2021
• Partners: LIF (Université Aix-Marseille) and IRIF (Université Paris-Diderot)
• Coordinator: M. Zeitoun, LaBRI (Université de Bordeaux)
• Objective: Delta is focused on the study of logic, transducers and automata. In particular, it aims at extending classical framework to handle input/output, quantities and data.

ANR Bravas

Participants: Sylvain Salvati [correspondent].

• Duration: 2017–2022
• Coordinator: Jérôme Leroux, LaBRI, Université de Bordeaux
• Scientific Partner: LSV, ENS Cachan
• Objective: The goal of the BraVAS project is to develop a new and powerful approach to decide the reachability problems for Vector Addition Systems (VAS) extensions and to analyze their complexity. The ambition here is to crack with a single hammer (ideals over well-orders) several long-lasting open problems that have all been identified as a barrier in different areas, but that are in fact closely related when seen as reachability.

11.1.1 Scientific events: organisation

11.1.2 Scientific events: selection

11.1.3 Journal

11.1.4 Scientific expertise

• Capelli
  Member of Inria Lille CER (Commission des Emplois de Recherche)
• Salvati
  Member of Inria's Evaluation Committee.
• Tison
  Elected member of CNU 27.
• Tison
  Expertise for the Austrian Science Fund (FWF).

11.1.5 Research administration

• Salvati
  Member of the joint and restricted commissions of the computer science department of Université de Lille (FIL) and of CRIStAL for recruitments.
• Staworko
  Member of the Parity/Equality commission of the CRIStAL laboratory.
• Tison
  Member of the coordinating team of ISite Université de Lille - Nord Europe.
• Tison
  Elected member of the executive board of Université de Lille.
• Tison
  Member of the school board of IMT Nord Europe.

11.2.1 Teaching Responsibilities

• Capelli
  Responsible for the L1, LEA department, Université de Lille.
• Capelli
  Elected member of the board of LEA department, Université de Lille.
• Capelli
  Reponsible for Parcoursup for LEA department, Université de Lille.
• Salvati
  Co-director of studies for the Master MIAGE FA, Université de Lille.
• Salvati
  Director of studies for the mathematics and computer science bachelor's degree of Université de Lille.
• Salvati
  Co-responsible for the research track of the computer science bachelor's degree of Université de Lille.
• Salvati
  Board member of the computer science departement of Université de Lille (FIL).
• Staworko
  Coordinator of International Relationships at the Department of Computer Science, Université de Lille (FIL).
• Tison
  Member of the selection board for «Capes» in computer science.

11.2.2 Teaching Activities

• Boneva
  Teaches computer science in DUT Informatique of Université de Lille
• Capelli
  Teaches computer science in the LEA department of Université de Lille for around 200h per year (Licence and Master).
• Lemay
  Teaches computer science in the LEA department of Université de Lille for around 200h per year (Licence and Master). He is also responsible for computer science and numeric correspondent for its department.
• Monet
  Teaches computer science as a temporary lecturer for a total of 85h per year – 69h for the computer science department of Université de Lille (FIL), and 16h for the computer science department of Centrale Lille. That includes Compilers (M1, 24h), Introduction to Security (18h), Advanced Databases (M1, 27h), Databases 1 (M1, 8h), SQL and Databases (G3 Centrale Lille, 8h).
• Niehren
  Gives lessons for the 2nd year students of the Master Machine Learning (Université de Lille): on Logical foundations of databases (21h).
• Paperman
  Teaches computer science for around 200h per year. He gives lectures for the computer science and math departments. Topics includes an Advance Databases lecture (M2, 24hx3), Algorithmic and Programming in L2 MIASHS (24h), Web Programming in L3 MIASHS and Introduction to Web Technology in L1 SESI (32h).
• Salvati
  Teaches computer science for a total of around 230h per year in computer science departement of Université de Lille. That includes Introduction to Computer Science (L1, 50h), Logic (L3, 50h), Algorithmic and operational research (L3, 36h), Functional Programming (L3, 35h), Research Option (L3, 10h), Semantic Web (M2, 30h), Advanced Databases (M1, 20h).
• Staworko
  Teaches computer science for a total of around 200h in the MIME department (Université de Lille).
• Tison
  Teaches computer science for a total of around 120h at the Université de Lille. That includes Advanced Algorithms and Complexity (42h, Master), Databases (60h, L2), and Logic (18h, L2).

11.2.3 Supervision

• Al Serhali
  PhD project started 2020. On hyperstream programming. Supervised by Niehren.
• Barloy
  PhD project started 2021. On circuits and lower complexity bounds. Supervised by Paperman and Salvati.
• Besnier Thomas
  Intern as part of the “immersion into research” course of Centralle Lille (2nd year student), for about 90h of work for the student during the April-June period. Supervised par Monet.
• Crosetti
  PhD project in progress since 2018. Linear programs with database queries. Supervised by Tison, Capelli, Niehren. With Ramon from Inria Magnet.
• Gallot
  PhD project defense in december 2021. On safety of data transformations. Supervised by Salvati and Lemay.
• Soyez-Martin
  PhD project started 2020. On Streaming with vectors and circuits. Supervised by Salvati and Paperman.

11.2.4 Juries

• Lemay
  Member of the PhD committee of Paul Gallot (Inria Lille), December 16th.
• Salvati
  Member of the PhD committee of Paul Gallot (Inria Lille), December 16th.
• Tison
  Member of the PhD committee of Alain Riveiro (Centrale Lille), January 26th.
• Tison
  Member of the PhD committee of Quentin Mayolle (Centrale Lille), July 13th.
• Tison
  Member of the PhD committee of Paul Gallot (Inria Lille), December 16th.
• Tison
  Member of the selection jury for the “Programme Jeunes Talents” of “For Women in Science Programme” (Loreal Foundation).
• Tison
  Reviewer for a position as Professor for “Knowledge Based Systems” at TU Dortmund University.
• Tison
  Member of the selection committees for: MCF Université d'ARTOIS, MCF Université of Gustave Eiffel, MCF Université de Paris, and Pr Université de la Réunion (2021).

11.3.1 Education

• Tison
  Membre of the guidance and scientific counselling board of Xperium and of the organising committee for the Xperium challenge 2021.

International journals

• 11 articleE.Emilie Allart, J.Joachim Niehren and C.Cristian Versari. Computing Difference Abstractions of Linear Equation Systems.Theoretical Computer ScienceJuly 2021
  HALDOIback to text
• 12 articleE.Emilie Allart, J.Joachim Niehren and C.Cristian Versari. Exact Boolean Abstraction of Linear Equation Systems.Computation911October 2021, 32
  HALback to text
• 13 articleM.Marcelo Arenas, P.Pablo Barceló and M.Mikaël Monet. The Complexity of Counting Problems Over Incomplete Databases.ACM Transactions on Computational Logic224October 2021, 1-52
  HALDOIback to textback to text
• 14 articleI.Iovka Boneva, J.Joachim Niehren and M.Momar Sakho. Regular Matching and Inclusion on Compressed Tree Patterns with Constrained Context Variables.Information and Computation2021
  HALDOIback to text
• 15 articleA.Angela Bonifati, S.Stefania Dumbrava, G.George Fletcher, J.Jan Hidders, M.Matthias Hofer, W.Wim Martens, F.Filip Murlak, J.Joshua Shinavier, S.Slawomir Staworko and D.Dominik Tomaszuk. Threshold Queries in Theory and in the Wild.Proceedings of the VLDB Endowment (PVLDB)2022
  HALback to text
• 16 articleM.Michaël Cadilhac, F.Filip Mazowiecki, C.Charles Paperman, M.Michał Pilipczuk and G.Géraud Sénizergues. On Polynomial Recursive Sequences.Theory of Computing SystemsJune 2021
  HALDOIback to text
• 17 articleJ. S.Jean Sébastien Guez, F.Francoise Coucheney, J.Joany Castéra-Guy, M.Max Béchet, P.Pierre Fontanille, N.-E.Nour-Eddine Chihib, J.Joachim Niehren, F.François Coutte and P.Philippe Jacques. Bioinformatics modelling and metabolic engineering of thebranched chain amino acid pathway for specific production of mycosubtilin isoforms in Bacillus subtilis.Metabolites122January 2022
  HALDOIback to text
• 18 articleJ.Joachim Niehren and M.Momar Sakho. Determinization and Minimization of Automata for Nested Words Revisited.AlgorithmsFebruary 2021
  HALDOIback to text
• 19 articleA.Ariane Théatre, C.Carolina Cano-Prieto, M.Marco Bartolini, Y.Yoann Laurin, M.Magali Deleu, J.Joachim Niehren, T.Tarik Fida, S.Saïcha Gerbinet, M.Mohammad Alanjary, M. H.Marnix H Medema, A.Angélique Léonard, L.Laurence Lins, A.Ana Arabolaza, H.Hugo Gramajo, H.Harald Gross and P.Philippe Jacques. The surfactin-like lipopeptides from <i>Bacillus</i> spp.: natural biodiversity and synthetic biology for a broader application range.Frontiers in Bioengineering and BiotechnologyMarch 2021
  HALDOIback to text

International peer-reviewed conferences

• 20 inproceedingsA.Antoine Amarilli, L.Louis Jachiet and C.Charles Paperman. Dynamic Membership for Regular Languages.ICALP48International Colloquium on Automata, Languages, and Programming (ICALP 2021)Glasgow, Scotland, FranceJuly 2021, 116:1--116:17
  HALDOIback to text
• 21 inproceedingsR.Renzo Angles, A.Angela Bonifati, S.Stefania Dumbrava, G.George Fletcher, K. W.Keith W Hare, J.Jan Hidders, V. E.Victor E Lee, B.Bei Li, L.Leonid Libkin, W.Wim Martens, F.Filip Murlak, J.Josh Perryman, O.Ognjen Savković, M.Michael Schmidt, J.Juan Sequeda, S.Slawomir Staworko and D.Dominik Tomaszuk. PG-Keys: Keys for Property Graphs.ACM Special Interest Group on Management of Data (SIGMOD)Xi'an, ChinaJune 2021
  HALDOIback to text
• 22 inproceedingsM.Marcelo Arenas, P.Pablo Barceló, L.Leopoldo Bertossi and M.Mikaël Monet. The Tractability of SHAP-Score-Based Explanations over Deterministic and Decomposable Boolean Circuits.AAAI 2021 - 35th Conference on Artificial IntelligenceVirtual, FranceFebruary 2021
  HALback to text
• 23 inproceedingsC.Corentin Barloy, F.Filip Murlak and C.Charles Paperman. Stackless Processing of Streamed Trees.PODS 2021 - Symposium on Principles of Database SystemsProceedings of the Symposium on Principles of Database Systems, PODS 2021Xi'an, Shaanx, ChinaJune 2021
  HALDOIback to text
• 24 inproceedingsF.Florent Capelli, N.Nicolas Crosetti, J.Joachim Niehren and J.Jan Ramon. Linear Programs with Conjunctive Queries.25th Internationcal Conference on Database Theory (ICDT 2022)Edinburgh, United KingdomMarch 2022
  HALback to text
• 25 inproceedingsF.Florent Capelli, J.-M.Jean-Marie Lagniez and P.Pierre Marquis. Certifying Top-­Down Decision-­DNNF Compilers.AAAI 2021 - 35th Conference on Artificial IntelligenceVirtual, FranceFebruary 2021
  HALback to text
• 26 inproceedingsD.Daniel Deutch, N.Nave Frost, B.Benny Kimelfeld and M.Mikaël Monet. Computing the Shapley Value of Facts in Query Answering.SIGMOD Conference 2022Philadelphia, United StatesJune 2022
  HALback to textback to text
• 27 inproceedingsB.Benoît Groz, A.Aurélien Lemay, S.Slawomir Staworko and P.Piotr Wieczorek. Inference of Shape Graphs for Graph Databases.International Conference on Database TheoryEdinbourgh, United Kingdom2022
  HALDOIback to text

Doctoral dissertations and habilitation theses

• 28 thesisP. D.Paul Daniel Geoffroy Gallot. Safety of transformations of data trees: Tree transducer theory applied to a verification problem on shell scripts.Université de LilleDecember 2021
  HALback to textback to text

Reports & preprints

• 29 miscE.Emilie Allart, J.Joachim Niehren and C.Cristian Versari. Reaction Networks to Boolean Networks.September 2021
  HAL
• 30 miscI.Iovka Boneva, L.Lawek Staworko and J.Jose Lozano. Consistency and Certain Answers in Relational to RDF Data Exchange with Shape Constraints.December 2021
  HAL
• 31 miscM.Michaël Cadilhac and C.Charles Paperman. The Regular Languages of Wire Linear AC 0.December 2021
  HAL
• 32 miscJ.Joachim Niehren, M.Momar Sakho and A.Antonio Al Serhali. Schema-Based Automata Determinization.January 2022
  HAL