Parametric Timed Regular Expressions

• Parametric Timed Regular Expressions (PTREs) are symbolic templates for timed regular expressions that use parametric, rather than fixed, interval annotations.
• They facilitate synthesis from timed examples by decoupling structural design from SMT-based instantiation of concrete timing bounds.
• PTREs bridge classical timed expressions and automata-based frameworks, with decidability and expressiveness hinging on the careful handling of clock-parameter comparisons.

Parametric Timed Regular Expressions (PTREs), also written as pTREs in the recent synthesis literature, are timed regular expressions whose interval annotations are symbolic rather than fixed. In the formulation currently available on arXiv, a PTRE is a timed-regular-expression syntax tree equipped with parametric intervals, so that one first fixes the expression structure and then instantiates timing constraints by assigning concrete interval bounds and endpoint-closure choices; the result is an ordinary timed regular expression (TRE) instance (Wang et al., 8 Sep 2025). PTREs therefore occupy an intermediate position between classical TREs, which denote concrete timed languages directly, and automata-based parametric formalisms such as parametric timed automata (PTAs), which dominate the current literature on parametric timed matching and monitoring (Waga et al., 2019).

1. Formal basis in timed regular expressions

The current PTRE formulation is built on a standard TRE layer over a finite alphabet $\Sigma$. A timed word is a finite sequence

$$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$

where $t_i$ is the delay before action $\sigma_i$. Two derived functions are used systematically: $\lambda(w)$, which extracts the delay sequence, and $\mu(w)$, which extracts the untimed word. For example, for $w=(a,0.2)(b,0)(a,6)$, one has $\lambda(w)=0.2,0,6$ and $\mu(w)=aba$ (Wang et al., 8 Sep 2025).

A TRE has syntax

$$\phi ::= \varepsilon \mid \sigma \mid (\phi)_I \mid \phi \cdot \phi \mid \phi \vee \phi \mid \phi^*$$

where $$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$0 is an integer-bounded interval of one of the forms

$$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$1

with $$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$2 and $$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$3. Its semantics is inductive: $$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$4

$$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$5

$$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$6

The crucial feature is that $$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$7 constrains the total elapsed time of the word matched by $$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$8, not merely the timing of a single symbol. This distinction is visible in the contrast between $$w = (\sigma_1,t_1)(\sigma_2,t_2)\cdots(\sigma_n,t_n)\in (\Sigma\times \mathbb{R}_{\ge 0})^*$$9, where the interval constrains the whole repetition, and $t_i$0, where each repeated symbol is individually constrained (Wang et al., 8 Sep 2025).

This design makes PTREs structurally richer than formalisms that only attach bounds to letters. In the syntax-tree presentation, every node carries an inherent time restriction, so timing can constrain composite subexpressions such as concatenations, unions, and stars, not only atoms (Wang et al., 8 Sep 2025).

2. Parametric intervals, instantiation, and template semantics

A PTRE replaces concrete intervals by symbolic ones. A parametric interval $t_i$1 is defined as a 4-tuple

$t_i$2

where $t_i$3 are integer variables denoting lower and upper endpoints, and $t_i$4 are Boolean variables indicating whether the left and right endpoints are included. The PTRE grammar is

$t_i$5

where $t_i$6 is a placeholder used during enumeration. A PTRE is closed if it contains no placeholder, and an edge PTRE if it contains exactly one placeholder (Wang et al., 8 Sep 2025).

The role of parameters is deliberately narrow. They occur only in timing intervals; the operator tree is fixed by the PTRE template. Once all parametric intervals in a closed PTRE $t_i$7 are instantiated, the resulting concrete TRE $t_i$8 is called an instance of $t_i$9, written

$\sigma_i$0

This makes a PTRE a symbolic family of TREs rather than a single timed language in the usual sense (Wang et al., 8 Sep 2025).

The synthesis paper also introduces a maximal over-approximation $\sigma_i$1, obtained by setting all parametric intervals in a closed PTRE to $\sigma_i$2. It states that a timed word $\sigma_i$3 is accepted by a closed PTRE $\sigma_i$4 iff $\sigma_i$5 is accepted by $\sigma_i$6. In context, this is a template-level structural acceptance criterion used before interval solving: it checks whether the expression shape can parse the example at all, while postponing the concrete timing constraints to a later SMT phase (Wang et al., 8 Sep 2025).

An additional structural device is the untimed projection $\sigma_i$7, which erases timing annotations from a TRE or PTRE. Examples include $\sigma_i$8 and $\sigma_i$9. This untimed projection is central because parsing is performed against $\lambda(w)$0, while the timing obligations induced by that parse are solved separately over the interval parameters (Wang et al., 8 Sep 2025).

3. Synthesis from positive and negative timed examples

The principal PTRE use currently developed in detail is synthesis. The input is a pair

$\lambda(w)$1

of finite sets of timed words, where $\lambda(w)$2 contains positive examples and $\lambda(w)$3 negative examples. The basic synthesis problem asks for a TRE $\lambda(w)$4 such that

$\lambda(w)$5

or else a proof that no such TRE exists. A second problem asks for such a TRE of minimal length, where length is the number of nodes in the syntax tree (Wang et al., 8 Sep 2025).

The decidability argument does not operate directly on arbitrary PTREs. Instead, it passes through simple timed regular expressions (sTREs), which contain only concatenation and time restriction, with all intervals of the form $\lambda(w)$6 or $\lambda(w)$7, where $\lambda(w)$8. For a timed word $\lambda(w)$9, the paper associates a simple elementary language $\mu(w)$0, determined by the tightest integer-bounded constraints on sums of consecutive delays. If two words have the same $\mu(w)$1, then no TRE can distinguish them. The paper defines a notion of obscuration: a positive example is obscured by a negative sample set if every simple TRE characterizing that positive also accepts some negative. The main decidability theorem states that the synthesis problem has a solution iff every positive example is not obscured by the negative set; in that case a solution is given by a finite disjunction of witness sTREs (Wang et al., 8 Sep 2025).

PTREs enter at the algorithmic, rather than purely logical, stage. They are introduced because concrete TREs of fixed structural size are infinite in number, due to the infinitely many possible interval instantiations. By contrast, the number of PTREs of a fixed length $\mu(w)$2 is finite. This converts synthesis into a finite search over symbolic expression structures, followed by constraint solving for interval values (Wang et al., 8 Sep 2025).

A common misconception is therefore to treat PTREs as already possessing a fully standardized standalone theory parallel to ordinary regular expressions. The present literature is narrower: PTREs are explicitly introduced as symbolic templates for TRE synthesis, and the main completeness and decidability arguments remain phrased at the TRE and sTRE levels rather than at a separate PTRE semantic level (Wang et al., 8 Sep 2025).

4. Enumeration, pruning, and SMT-based interval solving

The synthesis pipeline is split into structure search and timing instantiation. Enumeration begins from the placeholder $\mu(w)$3 and applies substitutions that introduce a symbol, star, concatenation, or union, each with a parametric interval. Because $\mu(w)$4 never appears in a minimal TRE with respect to a nonempty sample set, the search need not include it in minimal solutions. Candidates are explored in increasing syntax-tree size, so the first successful instantiation yields a minimal TRE (Wang et al., 8 Sep 2025).

Two pruning mechanisms are emphasized. Edge pruning applies to an edge PTRE, i.e. a candidate with exactly one remaining placeholder. The placeholder is replaced by $\mu(w)$5, an over-approximation of all possible completions. If even this over-approximation fails to accept all positive examples, no refinement can succeed, so the candidate is pruned. Containment pruning stores previously doomed candidates and prunes any newly generated PTRE contained in one of them. This is sound, but the paper notes that containment is PSPACE-complete, making the pruning criterion itself expensive (Wang et al., 8 Sep 2025).

Once a closed PTRE structurally accepts all positive examples, interval parameters are solved by SMT. The procedure first computes the untimed projection $\mu(w)$6, labels symbol occurrences by syntax-tree position, constructs a Glushkov NFA for the resulting linear expression, and enumerates all accepting paths for each example. A path is a finite sequence of pairs $\mu(w)$7, where $\mu(w)$8 is the subscript of a symbol occurrence and $\mu(w)$9 the depth of the corresponding syntax-tree node. Each accepting path determines bottom-up timing constraints: leaves constrain concrete delays by leaf intervals, concatenation sums adjacent durations, union passes timing upward unchanged, and star sums the durations of a repetition block. For a negative example, every accepting path must be invalidated; for a positive example, at least one accepting path must remain valid (Wang et al., 8 Sep 2025).

The resulting SMT formula $w=(a,0.2)(b,0)(a,6)$0 is satisfiable iff there exists an instance $w=(a,0.2)(b,0)(a,6)$1 consistent with the sample set. The variables are the integer endpoints and Boolean openness flags of every parametric interval, and the implementation uses Z3. In effect, PTRE synthesis is an alternation between regular-structure search and arithmetic consistency checking over interval parameters (Wang et al., 8 Sep 2025).

5. Matching semantics and automata-based counterparts

The broader timed-pattern-matching literature is not PTRE-centric. A foundational non-parametric formulation takes as input a timed word $w=(a,0.2)(b,0)(a,6)$2 and a timed pattern specified either by a timed regular expression or a timed automaton, and returns the set

$w=(a,0.2)(b,0)(a,6)$3

or its automata variant $w=(a,0.2)(b,0)(a,6)$4. Here $w=(a,0.2)(b,0)(a,6)$5 is the restriction of the timed word to the interval $w=(a,0.2)(b,0)(a,6)$6, shifted to start at time $w=(a,0.2)(b,0)(a,6)$7 and terminated by a fresh symbol $w=(a,0.2)(b,0)(a,6)$8. The output is generally infinite, so it is represented symbolically, in the non-parametric case as a finite union of zones in the $w=(a,0.2)(b,0)(a,6)$9-plane (Waga et al., 2016).

Parametric timed pattern matching generalizes the output by adding parameter valuations. With a PTA $\lambda(w)=0.2,0,6$0 as specification, the match set is

$\lambda(w)=0.2,0,6$1

The paper stresses that $\lambda(w)=0.2,0,6$2 is generally uncountable but has a finite symbolic representation as a finite union of special polyhedra in $\lambda(w)=0.2,0,6$3 dimensions. It then develops two frameworks: one based on parametric timed model checking via IMITATOR and reachability synthesis, and a dedicated online algorithm that symbolically tracks locations, reset histories, and constraints over parameters and start times. It also adapts FJS-style skipping through KMP-style and Quick Search-style skip values (Waga et al., 2019).

For PTREs, these automata-based results are indirect but substantial. A plausible implication is that any PTRE formalism equipped with a semantics-preserving compilation into timed automata or PTAs can inherit these matching notions, symbolic outputs, and acceleration techniques. Conversely, the absence of a direct PTRE matching theory in these papers underscores that, in current arXiv practice, parametric timed matching is treated primarily through automata rather than through expression calculi (Waga et al., 2019).

A more tentative related direction comes from proof theory: an untimed sequent-style membership procedure for ordinary regular expressions was proposed with the explicit claim that it “extends easily” to timed regular expressions, but the paper does not define timed syntax, timed semantics, timed rules, or any parametric extension. Its relevance to PTREs is therefore methodological rather than formal (Kwon et al., 2010).

6. Decidability frontier, expressiveness, and limitations

The most important boundary result for PTRE research comes from PTA theory under continuous time. For parametric timed automata with time domain $\lambda(w)=0.2,0,6$4 and integer parameters in $\lambda(w)=0.2,0,6$5, language emptiness and reachability are undecidable already with one integer parameter and three parametric clocks. By contrast, for PTAs with arbitrarily many clocks and arbitrarily many integer parameters, but only one parametric clock, reachability and safety are decidable in continuous time, and reachability lies in NEXPTIME (Beneš et al., 2015).

PTREs are not discussed explicitly in that paper, so any transfer must be stated cautiously. What is directly justified is the following: if a PTRE semantics compiles expressions to PTAs, then the number of clocks compared with parameters becomes the critical resource. This suggests a sharp design principle for continuous-time PTRE fragments with integer parameters: fragments compiling to PTAs where only one clock is ever compared with parameters are plausible candidates for decidable emptiness or satisfiability-style problems, whereas fragments inducing several independently parameter-constrained clocks may inherit undecidability very quickly (Beneš et al., 2015).

Expressiveness remains only partially settled on the expression side. The synthesis work considers standard or extended TREs with concatenation, union, star, and time restriction on subexpressions, but excludes renaming and intersection. It gives an explicit example of a timed language definable with intersection but not without it, and notes that generalized extended TREs are expressively equivalent to timed automata, whereas the precise class of timed automata matched by the restricted TRE fragment remains unclear (Wang et al., 8 Sep 2025).

Three limitations follow. First, PTREs as currently formalized are interval-parametric templates, not full parametric process models with arbitrary symbolic guards or resets. Second, the main direct PTRE development is synthesis from examples, not standalone model checking or language-theoretic analysis. Third, much of the effective machinery for matching, monitoring, and parameter synthesis presently resides in PTA-based frameworks rather than in PTRE-native algorithms (Waga et al., 2019).

Taken together, the literature presents PTREs as a compact symbolic representation for timed-expression synthesis, while placing their likely algorithmic future within an automata-theoretic ecosystem. The direct formalism is expression-based; the strongest decidability and matching results are automata-based; and the key open structural issue is how far PTRE fragments can be pushed before PTA-level undecidability phenomena become unavoidable (Wang et al., 8 Sep 2025).