Efficient asymmetric inclusion between regular expression types

Abstract

The inclusion of Regular Expressions (REs) is the kernel of any type-checking algorithm for XML manipulation languages. XML applications would benefit from the extension of REs with interleaving and counting, but this is not feasible in general, since inclusion is EXPSPACE-complete for such extended REs. In [9] we introduced a notion of "conflict-free REs", which are extended REs with excellent complexity behaviour, including a cubic inclusion algorithm [9] and linear membership [10]. Conflict-free REs have interleaving and counting, but the complexity is tamed by the "conflict-free" limitations, which have been found to be satisfied by the vast majority of the content models published on the Web.However, a type-checking algorithm needs to compare ma chine-generated subtypes against human-defined supertypes. The conflict-free restriction, while quite harmless for the human-defined supertype, is far too restrictive for the subtype. We show here that the PTIME inclusion algorithm can be actually extended to deal with totally unrestricted REs with counting and interleaving in the subtype position, provided that the supertype is conflict-free. This is exactly the expressive power that we need in order to use subtyping inside type-checking algorithms, and the cost of this generalized algorithm is only quadratic, which is as good as the best algorithm we have for the symmetric case (see [5]). The result is extremely surprising, since we had previously found that asymmetric inclusion becomes NP-hard as soon as the candidate subtype is enriched with binary intersection, a generalization that looked much more innocent than what we achieve here.

Linear inclusion for XML regular expression types

“…In [6] we proved that inclusion for the above language, which is EXPSPACE-complete in general, can be verified in quadratic time when the right hand-side of the comparison (the supertype) is conflict-free. Conflict-free types are defined as those types that respect the following restrictions (hereafter we will use the meta-variable U for conflict-free types):…”

“…Type inclusion is the basic operation of any type-checking compiler, and is typically invoked for every variable assignment, function definition, and function call, hence it must be extremely fast. We offered a first solution in [9,6]. In these papers we introduced conflict-free EREs, which are a restricted form of EREs that closely correspond to the kind of EREs that schema designers actually use, and that admit a quadratic-time inclusion algorithm.…”

“…The algorithm we presented in [6] extracts a set of "constraints" from the candidate supertype and verifies that each constraint is satisfied by the subtype, which involves a quad ratic amount of work, even in cases when the two types are very similar, or equal. Our new algorithm has a more traditional "structural" approach: it visits both types in parallel from the top, matching the topmost operator and recurring on the children.…”

The inclusion problem for regular expressions

“…Martens, Neven and Schwentick study in [13] the complexity of the inclusion problem for several sub-classes of the regular expressions. Colazzo, Ghelli and Sartiani, describe in [14] and [15] asymmetric polynomial-time algorithms for inclusion of a subclass of regular expressions called collision-free. The collision-free regular expressions have at most one occurrence of each symbol from Σ , and the Kleene star can only be applied to disjunctions of letters.…”

Schemas for safe and efficient XML processing

“…In particular, we will introduce several classes of schemas (e.g., CHAREs [7]), for which decision problems can be solved efficiently, and present an approach based on conflict-free types [11], [12], [13] for solving membership and inclusion in polynomial time.…”