[Paper Review] The Complexity of Translation Membership for Macro Tree Transducers

Kazuhiro Inaba, Sebastian Maneth|ArXiv.org|Oct 13, 2009

Algorithms and Data Compression19 references3 citations

TL;DR

This paper investigates the complexity of the translation membership problem for macro tree transducers (MTTs), showing that for call-by-value MTTs (IO mode), the problem is solvable in polynomial time using on-the-fly inverse type inference. In contrast, for call-by-name MTTs (OI mode), the problem is NP-complete, and the result extends to multi-return and lookahead-enhanced MTTs, maintaining PTIME complexity for IO variants.

ABSTRACT

Macro tree transducers (mtts) are a useful formal model for XML query and transformation languages. In this paper one of the fundamental decision problems on translations, namely the "translation membership problem" is studied for mtts. For a fixed translation, the translation membership problem asks whether a given input/output pair is element of the translation. For call-by-name mtts this problem is shown to be NP-complete. The main result is that translation membership for call-by-value mtts is in polynomial time. For several extensions, such as addition of regular look-ahead or the generalization to multi-return mtts, it is shown that translation membership still remains in PTIME.

Motivation & Objective

• To analyze the computational complexity of the translation membership problem for macro tree transducers (MTTs), a key formal model for XML transformations.
• To determine whether a given input-output tree pair belongs to the translation defined by a fixed MTT, especially under different evaluation strategies.
• To extend the complexity analysis to variants such as multi-return MTTs and MTTs with regular look-ahead or equality/disequality constraints.
• To develop an efficient algorithm for IO-mode MTTs based on on-the-fly inverse type inference, avoiding exponential pre-computation.

Proposed method

• Proposes an on-the-fly construction of inverse-type automata to determine input types corresponding to given output types, avoiding exponential pre-computation.
• Uses inverse type inference to characterize the set of input trees that produce a given output tree under an IO-mode MTT.
• Applies dynamic programming over the structure of input and output trees to efficiently compute membership without enumerating all possible derivations.
• Extends the technique to multi-return MTTs by defining states that track multiple output tree tuples and their parameter dependencies.
• Handles regular look-ahead and sibling constraints by enriching the state space of the inverse automaton with constraint satisfaction checks.
• Employs a recursive, tree-automaton-based algorithm that traverses input and output trees in tandem, checking consistency with MTT rules.

Experimental results

Research questions

• RQ1 Is the translation membership problem for call-by-value macro tree transducers solvable in polynomial time?
• RQ2 What is the complexity of translation membership for call-by-name macro tree transducers?
• RQ3 Can the inverse type inference technique be adapted to maintain polynomial-time complexity in extended MTT models, such as multi-return or lookahead MTTs?
• RQ4 Does the addition of equality and disequality constraints between sibling nodes in look-ahead affect the complexity of translation membership?
• RQ5 Can the inverse-type automaton approach be applied to 1-parameter MTTs in OI mode, or does it fail due to state space explosion?

Key findings

• Translation membership for call-by-value macro tree transducers is in PTIME, with a time complexity of O(|s|·|t|^{2m+2d}·|M|), where m is the maximum rank and d the maximum dimension of states.
• For call-by-name macro tree transducers, the translation membership problem is NP-complete, even for compositions of multiple IO-mode MTTs.
• The inverse type inference technique, when applied on-the-fly, avoids exponential blowup and enables polynomial-time membership checking for IO-mode MTTs.
• The complexity remains in PTIME for multi-return MTTs, as the method generalizes to tracking multiple output tree tuples via extended state representations.
• The approach extends to MTTs with regular look-ahead and those using tree automata with equality and disequality constraints between siblings, preserving polynomial-time complexity.
• For deterministic MTTs, translation membership can be solved in linear time O(|s| + 2^n·|t|) for n-fold compositions, by computing the output and comparing it directly.