Alexandre Blondin Massé

Reconstructing words from a fixed palindromic length sequence

To every word ω is associated a sequence Gω built by computing at each position i the length of its longest palindromic suffix. This sequence is then used to compute the palindromic defect of a finite word Ω defined by D(Ω) = |Ω|+1−|Pal(Ω)| where Pal(Ω) is the set of its palindromic factors. In this paper we exhibit some properties of this sequence and introduce the problem of reconstructing a word from GΩ. In particular we show that up to a relabelling the solution is unique for 2‐letter alphabets.

Exhaustive Exploration of Ajax Web Applications with Selective Jumping

Exploring modern web applications is a difficult task with the presence of client-side JavaScript code, as a crawler cannot jump or backtrack arbitrarily inside applications that maintain a state. In this paper, we present Web Mole, an automated crawler that implements a formal framework for web exploration that generalizes existing approaches. Web Mole uses an algorithm that explores an application without the need for arbitrary backtracking, it intercepts HTTP requests called from client-side code, and uses that information to perform selectively jump to pages while preserving the client-server state relationship. Comparisons with existing crawlers on various classes of graphs show that this strategy incurs a lower exploration cost.

Complexity of the Fibonacci snowflake

The object under study is a particular closed and simple curve on the square lattice ℤ2 related with the Fibonacci sequence Fn. It belongs to a class of curves whose length is 4F3n+1, and whose interiors tile the plane by translation. The limit object, when conveniently normalized, is a fractal line for which we compute first the fractal dimension, and then give a complexity measure.

Solving Equations on Words with Morphisms and Antimorphisms

Word equations are combinatorial equalities between strings of symbols, variables and functions, which can be used to model problems in a wide range of domains. While some complexity results for the solving of specific classes of equations are known, currently there does not exist any equation solver publicly available. Recently, we have proposed the implementation of such a solver based on Boolean satisfiability that leverages existing SAT solvers for this purpose. In this paper, we propose a new representation of equations on words having fixed length, by using an enriched graph data structure. We discuss the implementation as well as experimental results obtained on a sample of equations.

Leaf realization problem, caterpillar graphs and prefix normal words

Abstract Given a simple graph G with n vertices and a natural number i ≤ n , let L G ( i ) be the maximum number of leaves that can be realized by an induced subtree T of G with i vertices. We introduce a problem that we call the leaf realization problem, which consists in deciding whether, for a given sequence of n + 1 natural numbers ( l 0 , l 1 , … , l n ) , there exists a simple graph G with n vertices such that l i = L G ( i ) for i = 0 , 1 , … , n . We present basic observations on the structure of these sequences for general graphs and trees. In the particular case where G is a caterpillar graph, we exhibit a bijection between the set of the discrete derivatives of the form ( Δ L G ( i ) ) 1 ≤ i ≤ n − 3 and the set of prefix normal words.

Fully Leafed Tree-Like Polyominoes and Polycubes

We present and prove recursive formulas giving the maximal number of leaves in tree-like polyominoes and polycubes of size n. We call these tree-like polyforms fully leafed. The proof relies on a combinatorial algorithm that enumerates rooted directed trees that we call abundant. We also show how to produce a family of fully leafed tree-like polyominoes and a family of fully leafed tree-like polycubes for each possible size, thus gaining insight into their geometric characteristics.

Fully Leafed Induced Subtrees

We consider the problem \(\mathrm {LIS}\) of deciding whether there exists an induced subtree with exactly \(i \le n\) vertices and \(\ell \) leaves in a given graph G with n vertices. We study the associated optimization problem, that consists in computing the maximal number of leaves, denoted by \(L_G(i)\), realized by an induced subtree with i vertices, for \(0 \le i \le n\). We begin by proving that the \(\mathrm {LIS}\) problem is NP-complete in general. Then, we describe a nontrivial branch and bound algorithm that computes the function \(L_G\) for any simple graph G. In the special case where G is a tree of maximum degree \(\varDelta \), we provide a \(\mathcal {O}(n^3\varDelta )\) time and \(\mathcal {O}(n^2)\) space algorithm to compute the function \(L_G\).

Efficient operations on discrete paths

We present linear time and space operations on discrete paths. First, we compute the outer hull of any discrete path. As a consequence, a linear time and space algorithm is obtained for computing the convex hull. Next, we provide a linear algorithm computing the overlay graph of two simple closed paths. From this overlay graph, one can easily compute the intersection, union and difference of two Jordan polyominoes, i.e. polyominoes whose boundary is a Jordan curve. The linear complexity is obtained by using an enriched version of a data structure introduced by Brlek, Koskas and Provencal: a quadtree for representing points in the discrete plane Z × Z augmented with neighborhood links, which was introduced in particular to decide in linear time if a discrete path is self-intersecting.

Runtime Monitoring of Temporal Logic Properties in a Platform Game

We report on the use of runtime monitoring to automatically discover gameplay bugs in the execution of video games. In this context, the expected behaviour of game objects is expressed as a set of temporal logic formulae on sequences of game events. Initial empirical results indicate that, in time, the use of a runtime monitor may greatly speed up the testing phase of a video game under development, by automating the detection of bugs when the game is being played.

Solving equations on words through boolean satisfiability

Word equations are combinatorial equalities between strings of symbols, variables and functions, which can be used to model problems in a wide range of domains. While some complexity results for the solving of specific classes of equations are known, currently there does not exist a systematic equation solver. We present in this paper a reduction of the problem of solving word equations to Boolean satisfiability, and describe the implementation of a general-purpose tool that leverages existing SAT solvers for this purpose. Our solver will prove useful in the resolution of word equations, and in the computer-based exploration of various combinatorial conjectures.