|Links' Seminars and Public Events|
Fri 19th Feb
Seminar: Bernardo Subercaseau
Title: Foundations of Languages for Interpretability.
The area of interpretability in Machine Learning aims for the design of algorithms that we humans can understand and trust. One of the fundamental questions of interpretability is: given a classifier M, and an input vector x, why did M classify x as M(x)? In order to approximate an answer to this "why" question, many concrete queries, metrics and scores have emerged as proxies, and their complexity has been studied over different classes of models. Many of these analyses are ad-hoc, but they tend to agree on the fact that these queries and scores are hard to compute over Neural Networks, but easy to compute over Decision Trees. It is thus natural to think of a more general approach, like a query language in which users could write an arbitrary number of different queries, and that would allow for a generalized study of the complexity of interpreting different ML models. Our work proposes foundations for such a language, tying to First Order Logic, as a way to have a clear understanding of its expressiveness and complexity. We manage to define a minimalistic structure over FO that allows expressing many natural interpretability queries over models, and we show that evaluating such queries can be done efficiently for Decision Trees, in data-complexity.
Fri 12th Feb
Seminar: Florent Capelli
Title: Regularizing the delay of enumeration algorithms
Zoom link: univ-lille-fr.zoom.us/j/95419000064
Abstract: Enumeration algorithms are algorithms whose goal is to output the set
of all solutions to a given problem. There exists different measures for the
quality of such algorithm, whose relevance depends on what the user wants to do
with the solutions set.
If the goal of the user is to explore some solutions or to transform the
solutions as they are outputted with a stream-like algorithm, a relevant measure
of the complexity of an enumeration algorithm is the delay between the output of
two distinct solutions. Following this line of thoughts, significant efforts
have been made by the community to design polynomial delay algorithms, that is,
algorithms whose delay between the output of two new solutions is polynomial in
the size of the input.
While this measure is interesting, it is not always completely necessary to have
a bound on the delay and it is enough to ask for a guarantee that running the
algorithm for O(t poly(n)) will result in the output of at least t solutions. Of
course, by storing each solution seen and outputting them regularly, one can
simulate a polynomial delay but if the number of solutions is large, it may
result in a blow up in the space used by the enumerator.
In this talk, we will present a new technique that allow to transform such
algorithm into polynomial delay algorithm using polynomial space.
This is joint work with Yann Strozecki.
Fri 29th Jan
Seminar: Antonio AL SERHALI
Title: Earliest Query Answering on Nested Streams in Combined Linear Time
Abstract: We show that the earliest query answering on nested streams can be done in time O(|A|) per event, for monadic queries defined by a deterministic stepwise hedge automaton A. The best previous algorithm required quadratic time O(|A| 2 ) while being applicable to deterministic nested word automata.
Fri 15th Jan
Séminaire de Kim Nguyễn
Titile: The BOLDR project
n this presentation, I will give an account of the BOLDR project and
perspectives in the field of language integrated queries.
Several classes of solutions allow programming languages to express
queries: specific APIs such as JDBC, Object-Relational Mappings (ORMs)
such as Hibernate, and language-integrated query frameworks such as
Microsoft's LINQ. However, most of these solutions do not allow for
efficient cross-databases queries, and none allow the use of complex
application logic from the programming language in queries.
We study the design of a new language-integrated query
framework called BOLDR that allows the evaluation in databases of
queries written in general-purpose programming languages containing
application logic, and targeting several databases following different
data models. In this framework, application queries are translated to
an intermediate representation. Then, they are typed with a type
system extensible by databases in order to detect which database
language each subexpression should be translated to. This type system
also allows us to detect a class of errors before execution. Next,
they are rewritten in order to avoid query avalanches and make the
most out of database optimizations. Finally, queries are sent for
evaluation to the corresponding databases and the results are
converted back to the application. Our experiments show that the
techniques we implemented are applicable to real-world database
applications, successfully handling a variety of language-integrated
queries with good performances.
This talk will give an overview of what has been achieved so far (mainly
in the context of Julien Lopez' PhD Thesis) and will glimpse at preliminary
work that is being done in the context of a collaboration with Oracle Labs.
Fri 8th Jan
Séminaire @ Lê Thành Dũng (Tito) Nguyễn
Title: The planar geometry of first-order string transductions (joint work with Pierre Pradic)
We propose a new machine model recognizing star-free languages, with a geometric flavor. Our starting point is the characterization of regular languages using two-way automata (2DFA). The idea is to take seriously the visual representations found throughout the literature of the behavior of a 2DFA on a word ; by putting a total order on the set of states, one can formally define what it means for such a behavior to be planar, in a sense analogous to the planarity of combinatorial maps. Star-free languages are then exactly the languages recognized by "planar 2DFA". We also show that the corresponding planar transducer model characterizes the class of first-order transductions (a.k.a. aperiodic regular functions). If time allows, the talk will briefly discuss the connections of this work with the non-commutative lambda-calculus (cf. our recent paper Aperiodicity in a non-commutative logic, ICALP'20).
Thu 17th Dec
Speaker: Nofar Carmeli (nofar.carme.li/)
Zoom link: univ-lille-fr.zoom.us/j/95419000064
Title: The Complexity of Answering Unions of Conjunctive Queries.
We discuss the fine-grained complexity of enumerating the answers to a query over a relational database. With the ideal guarantees, linear time is required before the first answer to read the input and determine its existence, and then we need to print the answers one by one. Consequently, we wish to identify the queries that can be solved with linear preprocessing time and constant or logarithmic delay between answers. A known dichotomy classifies CQs into those that admit such enumeration and those that do not. The computationally expensive component of query answering is joining tables, which can be done efficiently if and only if the join query is acyclic. However, the join query usually does not appear in a vacuum; for example, it may be part of a larger query, or it may be applied to a database with dependencies. We inspect how the complexity changes in these settings and chart the borders of tractability within. In addition, we consider the task of enumerating query answers with a uniformly random order, and we propose to do so using an efficient random-access structure for representing the set of answers. We also prove conditional lower bounds showing that our algorithms capture all tractable queries in some cases. Among our results, we show that a union of tractable conjunctive queries may be intractable w.r.t. random access; on the other hand, a union of intractable conjunctive queries may be tractable w.r.t. enumeration.
Fri 11th Dec
Title: Elimination Distance to Bounded Degree on Planar Graphs
Link to the zoominar: univ-lille-fr.zoom.us/j/95419000064
What does it mean for a graph to almost be planar? Or to almost have bounded
On such simple graphs classes, some difficult algorithmic problems become
Ideally, one would like to use (or adapt) existing algorithms for graphs that
are "almost" in such a simple class.
In this talk, I will discuss the notion of elimination distance to a class C, a
notion introduced by Bulian and Dawar (2016).
The goals of the talk are:
1) Define this notion, and discuss why it is relevant by presenting some
2) Show that we can compute the elimination distance of a given planar graph to
the class of graph of degree at most d.
I.e. answer the question: "Is this graph close to a graph of bounded degree?"
The second part is the result of a collaboration with Alexandre Lindermayer and
Fri 4th Dec
Seminar: Pierre Pradic
Title: Extracting nested relational queries from implicit definitions
In this talk, I will present results obtained jointly with Michael
Benedikt establishing a connection between the Nested Relational
Calculus (NRC) and sets implicitly definable using Δ₀ formulas.
Call a formula φ(I,O) an implicit definition of the relation O(x,...) in
terms of I(y,...) if O is functionally determined by I: for every I, O,
O', if both φ(I,O) and φ(I,O') hold, then we have O ≡ O'. When φ is
first-order and I and O are relations over base sorts, then Beth's
definability theorem states that there is a first-order formula
ψ(I,x,...) corresponding to O whenever φ(I,O) holds. Further, this
explicit definition ψ can be effectively be computed from a sequent
calculus proof witnessing that φ is functional. This allows for
practical use of implicit definitions in the context of database
programming, as there is a well-established link between fragments of
explicitly FO definable relations and relational calculi.
NRC is a conservative extension of relational calculi from database
theory with limited powerset types in addition to tupling and anonymous
base types. NRC expressions thus not only encompass flat relations over
primitive datatypes like SQL but also nested collections, while
remaining useful in practice.
We extend the above correspondence between first-order logic and flat
relational queries to NRC and implicit definitions using set-theoretical
Δ₀ formulas over (typed) nested collection. Our proof of the equivalence
goes through a notion of Δ₀-interpretation and a generalization of Beth
definability for multi-sorted structures. This proof is non-constructive
and thus does not yield any useful algorithm for converting implicit
definitions into NRC terms. Using an approach more closely related to
proof-theoretic interpolation, we give a constructive proof of the
result restricted to intuitionistic provability, i.e, when the input
functionality proof π of φ(I,O) is carried out in intuitionistic logic.
Further, if π is cut-free, this can be done efficiently. Whether or not
there exists a polynomial-time procedure working with classical proofs
of functionality is still an open problem.
I will focus on the effective result for the talk, and if time allows,
discuss the difficulties with extending it to classical logic. I will
not assume any background in either database or model theory.
Fri 27th Nov
Seminar: Charles Paperman
Title: Stackless processing of streamed trees
Abstract: In this talk, I will first present the state of the art of efficiency implementation of streaming-text algorithms on modern architecture. Then some recent results on the extraction of information on streamed of structured documents without stack overhead.
For more info: paperman.name/data/pub.....d.pdf
Fri 13th Nov
Seminar: Mikaël Monet
Title: The Complexity of Counting Problems over Incomplete Databases
Abstract: In this presentation, I will talk about various counting problems that naturally
arise in the context of query evaluation over incomplete databases. Incomplete
databases are relational databases that can contain unknown values in the form
of labeled nulls. We will assume that the domains of these unknown values are
finite and, for a Boolean query $q$, we will consider the following two
problems: given as input an incomplete database $D$, (a) return the number of
completions of $D$ that satisfy $q$; or (b) return or the number of valuations
of the nulls of $D$ yielding a completion that satisfies $q$.
We will study the computational complexity of these problems when $q$ is a
self-join--free conjunctive query, and study the impact on the complexity of
the following two restrictions: (1) every null occurs at most once in $D$ (what
is called *Codd tables*); and (2) the domain of each null is the same. Roughly
speaking, we will see that counting completions is much harder than counting
valuations, and that both (1) and (2) can reduce the complexity of our
I will also talk about the approximability of these problems and prove that,
while counting valuations can efficiently be approximated, in most cases
counting completions cannot.
On our way, we will encounter the counting complexity classes #P, Span-P and
The presentation will be based on joint work with Marcelo Arenas and Pablo
Barcelo; see arxiv.org/abs/1912.11064
Fri 16th Oct
Seminar: Aurélien Lemay
Title: ShEx Learning from Typed Graphs
Abstract: In knowledge graphs, schemas are becoming a new asset to describe the organization of data. The new world-leading format Shex is becoming a de-facto standard in the industry that allows defining flexible and powerful schemas.
In this context, the inference of schemas can become a solution to provide shex expressions that describe already existing data. Typically, the inference starts from untyped graphs. However, these tasks appears to be more complex than expected in general, and is possible only for subclasses of Shex.
The inference of schemas from typed graph gives a baseline for those algorithms. Its comprehension allows to understand better the underlying difficulties of the task. It presents already unexpected difficulties.
We present an algorithm that infers Shex-defined schemas from fully typed graphs. We also present some encountered difficulties, as well as the limitations of the approach.
Fri 24th Jul
Momar Sakho, PhD defense
Wed 8th Jan
Introduction to argumentation theory
Salle Agora 1, Bâtiment ESPRIT
Thu 19th Dec
Thèse L. Gallois
amphi Bâtiment B Inria
Fri 13th Dec
1. On Parsing Gpath (Jérémy and Antonio) 2. On Nested Regular Expression (Joachim)
Fri 13th Dec
Repet Lily pour l'équipe
"Lille-Salle B31 "
Tue 24th Sep
Title: General Dynamic Yannakakis: Conjunctive Queries with Theta Joins Under Updates
The ability to efficiently analyze changing data is a key requirement
of many real-time analytics applications like Stream Processing,
Complex Event Recognition, Business Intelligence, and Machine
Traditional approaches to this problem are based either on the
materialization of subresults (to avoid their recomputation) or on the
recomputation of subresults (to avoid the space overhead of
materialization). Both techniques have recently been shown suboptimal:
instead of fully materializing results and subresults, one can
maintain a data structure that supports efficient maintenance under
updates and can quickly enumerate the full query output, as well as
the changes produced under single updates.
In our work we are concerned with designing a practical family of
algorithms for dynamic query evaluation based on this idea, and for
queries featuring both equi-joins and inequality joins, as well as
certain forms of aggregation. Our main insight is that, for acyclic
conjunctive queries, such algorithms can naturally be obtained by
modifying Yannakakis' seminal algorithm for processing acyclic joins
in the static setting.
In this talk I present the main ideas behind this modfication,
offset it against the traditional ways of doing incremental view
maintenance, and discuss recent extensions such as dealing with
Amphitheater of INRIA Building B.
Tue 25th Jun
Tue 25th Jun
Seminar Véronique Benzaken and Évelyne Contejean
Elles présenteront un outil qui prend en entrée une requête SQL et sa compilation par Postrgres sous forme de plan d'exécution, et démontre (avec Coq) que la requête initiale est équivalente au plan d'exécution.
Fri 21st Jun
Fri 24th May
Fri 10th May
Fri 12th Apr
Alexandre Vigny in Links Seminar
Fri 5th Apr
Talk of Semyon Grigorev
Title: Parsing techniques for context-free path querying
Abstract: Context-free path querying (CFPQ) is a case of language constrained path querying: the way to specify constraints on paths in a graph in terms of formal languages. In CFPQ language is restricted to be a context-free. Classical parsing techniques and algorithms, such as generalized LR and LL parsing, or parser combinators, can be used for CFPQ. Results of adaptation of different parsing techniques for CFPQ will be presented.
Fri 5th Apr
Semyon Grigorev in Links' seminar
Fri 22nd Mar
Seminar LINKS by Aurelien Lemay "Tutorial: Grammatical Inference"
Fri 8th Mar
Title: Regular Matching and Inclusion on Compressed Tree Patterns with Context Variables
Abstract: We study the complexity of regular matching and inclusion for compressed tree patterns extended by context variables. The addition of context variables to tree patterns permits us to properly capture compressed string patterns but also compressed patterns for unranked trees with tree and hedge variables. Regular inclusion for the latter is relevant to certain query answering on Xml streams with references.
Fri 15th Feb
Wed 13th Feb
30mn de science : Florent Capelli on Knowledge Compilation
Inria salle Plénière (Bâtiment A)
Fri 1st Feb
Bruno Guillon in Links' seminar
Title: Finding paths in large graphs
When dealing with large graphs, classical algorithms for finding paths such as Dijkstra's Algorithm are unsuitable, because they require to perform too many disk accesses. To avoid this while keeping a data structure of size quasi-linear in the size of the graph, we propose to guide the path search with a distance oracle, obtained from a topological embedding of the graph.
I will present fresh experimental research on this topic, in which we obtain graph embeddings using learning algorithms from natural language processing. On some graphs, such as the graph of publications from DBLP, our topologically-guided path search allows us to visit a small portion of the graph only, in average.
This is joint work with Charles Paperman.
Fri 23rd Nov
Filip Mazowiecki in Links' seminar
Title: Containment for Probabilistic automata.
Abstract: This is an ICALP 2018 paper. We analyze when the model of probabilistic
automata has decidable properties, when restricting the ambiguity. The
notion of ambiguity is usually used in weighted automata or transducers,
but we follow a recent paper by Fijalkow, Riveros and Worrell, which
introduced this approach. We do not solve everything but our decidability
results rely unexpectedly on Schanuel's conjecture and we provide some
geometric intuition behind the hardness of the problem.
Fri 16th Nov
Aurelien Lemay's Habilitation defense
Thu 15th Nov
Andreas Maletti in Aurélien Lemay's prehabilitation seminar
Thu 15th Nov
Henning Fernau in Aurélien Lemay's prehabilitation seminar:
Fri 9th Nov
Talk of Bruno Guillon
Abstract: The time complexity of 1-limited automata is investigated from a
descriptional complexity view point. Though the model recognizes
regular languages only, it may use quadratic time in the input length.
We show that, with a polynomial increase in size and preserving
determinism, each 1-limited automaton can be transformed into a
linear-time equivalent one. We also obtain polynomial transformations
into related models, including weight-reducing Hennie machines (i.e.,
one-tape Turing machines syntactically forced to operate in
linear-time), and we show exponential gaps for converse
transformations in the deterministic case.
Fri 26th Oct
Momar Sakho in Links seminar
"Lieu : Lille, Salle : A12"
Thu 18th Oct
Talk of Mikael Monet
Title: Combined Complexity of Probabilistic Query Evaluation
Query evaluation over probabilistic databases (probabilistic query evaluation, or PQE) is known to be intractable in many cases, even in data complexity, i.e., when the query is fixed. Although some restrictions of the queries and instances have been proposed to lower the complexity, these known tractable cases usually do not apply to combined complexity, i.e., when the query is not fixed. This talk gives an overview of my PhD research, which investigates which queries and instances ensure the tractability of PQE in combined complexity.
I will first present our work on PQE of conjunctive queries on binary signatures, which can be rephrased as a probabilistic graph homomorphism problem. We restrict the query and instance graphs to be trees and show the impact on the combined complexity of diverse features such as edge labels, branching, or connectedness. This is joint work with Antoine Amarilli and Pierre Senellart and was presented at PODS'2017.
Second, we will explore the combined complexity of evaluating queries on treelike databases, i.e., databases whose treewidth is bounded by a constant. We introduce a class of queries (named 'CFG-Datalog') which generalizes many known query languages that are tractable in this context. Specifically, we show that the (non-probabilistic) evaluation of CFG-Datalog on treelike databases can be solved with complexity linear in the product of the instance size and of the query size. In the process, we introduce a new representation of the provenance of a query on a database, based on cyclic Boolean circuits. This is joint work with Antoine Amarilli, Pierre Bourhis, and Pierre Senellart, and was presented at ICDT'2017.
Last, we will move to the field of knowledge compilation and present our work that connects various notions of width for Boolean circuits. We show that circuits of bounded treewidth can be efficiently compiled into structured deterministic decomposable normal forms (d-SDNNFs), which in particular allows efficient probability computation. We show the implications of this result for PQE of CFG-Datalog on treelike databases. We also prove general lower bounds on knowledge compilation formalisms, which imply lower bounds for provenance computation. This is joint work with Antoine Amarilli and Pierre Senellart and was presented at ICDT'2018.
"Lieu : Lille, Salle : B21"
Fri 28th Sep
José Lozano Links seminar
Fri 21st Sep
Fabian Reiter in Links' Seminar: Descriptive distributed complexity
This talk connects two classical areas of theoretical computer science: descriptive complexity and distributed computing. The former is a branch of computational complexity theory that characterizes complexity classes in terms of equivalent logical formalisms. The latter studies algorithms that run in networks of interconnected processors.
Although an active field of research since the late 1970s, distributed computing is still lacking the analogue of a complexity theory. One reason for this may be the large number of distinct models of distributed computation, which make it rather difficult to develop a unified formal framework. In my talk, I will outline how the descriptive approach, i.e., connections to logic, could be helpful in this regard.
Fri 7th Sep
Rustam Azimov in Links Seminar: "Context-Free Path Querying by Matrix Multiplication"
Fri 25th May
Nicolas Crosetti in Links' Seminar: Dependency weighted aggregation
Fri 27th Apr
Yann Strozecki in Links' Seminar: Methods in enumeration
In enumeration we are interested in generating a set of solutions, while bounding the time needed to generate one solution. We will first present the complexity measures used in this context, simple theoritical results and a few open questions.
We then introduce classical problems in this area such as the enumeration of: trees, models of a DNF, model of a FO or MSO formula, the maximal cliques of a graph, circuits of a matroid ...
We use them to illustrate the algorithmic toolbox of enumeration (Gray Code, backtrack search, reverse search, saturation...).
Wed 25th Apr
Fri 20th Apr
Fri 13th Apr
Fri 13th Apr
Iovka Boneva and Jérémie Dusart in Links' Seminar: Shape Expressions Schemas 2.0 : Semantics and Implementation
We will present the semantics of the ShEx language, its implementation
in java, and future directions of research.
Fri 6th Apr
Fri 30th Mar
Fri 23rd Mar
Paul Gallot: High-Order Tree Transducers
Paul présentera le papier de Sylvain, Aurélien et Paul, soumis à LICS 2018, sur le sujet des transducteurs d'arbres d'ordre supérieur.
Wed 21st Mar
Fri 16th Mar
Luc Dartois in Links' Seminar: A Logic for Word Transductions with Synthesis
In this talk I present a logic, called LT, to express properties of transductions, i.e. binary relations from input to output (finite) words. I argue that LT is a suitable candidate as a specification language for verification of non reactive systems, extending the successful approach of verifying synchronous systems via Mealy Machines and MSO.
In LT, the input/output dependencies are modelled via an origin function which associates to any position of the output word, the input position from which it originates. LT is well-suited to express relations (which are not necessarily functional), and can express all regular functional transductions, i.e. transductions definable for instance by deterministic two-way transducers.
Despite its high expressive power, LT has decidable satisfiability problems. The main contribution is a synthesis result: it is always possible to synthesis a regular function which satisfies the specification.
Finally, I explicit a correspondence between transductions and data words. As a side-result, we obtain a new decidable logic for data words.
Fri 9th Mar
Benjamin Bergougnoux : Counting minimal transversals of hypergraphs
A transversal of a hypergraph H is a subset of vertices that
intersects all the hyper-edges H. The enumeration and the counting of
the minimal transversals have a lot of applications in many domains
(graph theory, AI, datamining, etc). Counting problems are generally
harder than theirs associated decision problems. For example, finding
a minimal transversal is doable in polynomial time but counting them
is #P-complet (the equivalent of NP-complet for counting problems).
We have proved that we can count the minimal transversals of any
beta-acyclique hypergraph in polynomial time. Our result is based on
a recursive decomposition of the beta-acyclique hypergraph founded by
Florent Capelli and by the introduction of a new notion that
generalize the minimal transversals.
A lot of exciting open questions live in the neighborhood of our
result. In particular, our algorithm is able to count the minimum
dominating set of a strong-chordal graph. But counting the minimum
dominating set is #P-complete on split graphs. Is it the beginning of
a complete characterization of the complexity of counting minimal
dominating sets in dense graphs ?
Fri 16th Feb
Victor Marsault : Formal semantics of the query-language Cypher
Cypher is a query-language for property-graphs. It was originally designed and implemented as part of the Neo4j graph database, and it is currently used by several commercial database products and researchers. The semantics of Cypher queries is currently described using natural language and, as a result, it is often not well defined. This work is part of a project to define a full denotational semantics of Cypher queries. The talk will first present the main features of Cypher through examples, including the core mecanism: graph pattern-matching, and then will describe the formal semantics in its current state.
Salle B21 - INRIA Institut National Recherche Informatique Automatique; 40 Avenue Halley, 59650 Villeneuve d'Ascq, France