Static DP Framework for LCSTRSs

• The framework is a method that transforms termination analysis of LCSTRSs into verifying the absence of infinite chains in a logic-enriched dependency graph.
• It integrates built-in theories with simply-typed rewriting by extracting marked dependency pairs to capture potential recursive calls under logical constraints.
• The approach employs reduction pairs, graph decomposition, and DP processors to modularly prove termination and ensure computational soundness.

The static dependency pair (DP) framework for Logically Constrained Simply-Typed Rewriting Systems (LCSTRSs) is a foundational methodology for analyzing termination in higher-order term rewriting systems equipped with logical constraints. LCSTRSs generalize simply-typed rewriting by integrating built-in theories (such as integers, booleans, and user-specified background theories) and allowing constraints at the level of rewrite rules. The static DP framework adapts and extends classical dependency pair techniques, enabling termination and computability proofs for these expressive systems by systematically transforming the termination problem into the absence of infinite chains in a transition graph enriched by logical constraints and higher-order considerations.

1. LCSTRSs: Syntax, Semantics, and Constraints

An LCSTRS is specified by a finite set of rewrite rules over curried (partially applied) function signatures. Types are constructed over a set of base sorts $\mathcal{S}$ via the grammar $\tau ::= \alpha \mid \tau_1 \to \tau_2$, where $\alpha\in\mathcal{S}$. The signature is partitioned:

• Theory signature ($\Sigma$): symbols interpreted in an external theory (e.g., integers, booleans) serving as values and whose ground subterms never rewrite.
• Defined signature ($\mathcal{F}$): symbols whose behavior is given by rewrite rules.

Rewriting occurs via constrained rules of the form $\ell \to r [\varphi]$, where $\ell$ and $r$ are terms of the same type and $\varphi$ is a logical constraint—a conjunction of background-theory atoms, with variables from $\ell$. A rewrite step applies when, under a ground substitution $\gamma$, the instantiated constraint $\varphi\gamma$ holds in the theory and the pattern matches at the root of a subterm.

2. Static Dependency Pair Extraction

For each defined symbol $f$ of type $\sigma_1\to\cdots\to\sigma_n\to\tau$, a marked symbol $f^\sharp$ of identical type is introduced. From each rule $\ell = f(\ell_1,\dots,\ell_n) \to r [\varphi]$:

• Traverse $r$ to identify subterms $g(u_1,\dots,u_m)$ whose head $g$ is defined.
• Emit a static dependency pair:

$$f^\sharp(\ell_1,\dots,\ell_n) \to g^\sharp(u_1,\dots,u_m)\; [\varphi]$$

The set of all such pairs forms the collection $\mathrm{SDP}(\mathcal{R})$.

In static DPs, every potential recursive call in rule right-hand sides is recorded, each with its side constraint. Notably, static DPs do not analyze the calling context—contrast with dynamic DPs, which would only include those pairs feasible under actual execution and the constraints. In the unconstrained (classical) case, all $[\varphi]$ are trivial (true), and the theory layer is absent (Kop, 2024, Kop, 2016, Kusakari et al., 2011).

3. Computability and Reduction Pairs: Orderings for Termination

The framework requires a reduction pair $(\succeq, \succ)$ on terms:

• $\succeq$ is a reflexive, monotonic quasi-order.
• $\succ$ is a well-founded strict order, also substitution-closed.
• They satisfy: $\succeq\circ\succ\subseteq\succ$.
• Weak monotonicity: If $s\succ_\varphi^L t$, then for any context $C$ not duplicating or deleting filtered positions, $C[s]\succeq_\varphi^L C[t]$.

A key instance is the weakly monotonic HORPO-variant, parameterized by a precedence $\ge_\mathcal{F}$ on defined symbols, a filter $\pi$ selecting monotonic positions, and defined recursively in RPO style:

• Theory terms: $s,t$ of base sort, with $\mathrm{Var}(s)\cup\mathrm{Var}(t)\subseteq L$ and $\varphi\models_{\mathrm{Th}} s\le t$ yield $s\succeq_\varphi^L t$.
• Arguments: Structural comparison of filtered positions under the order.
• Higher-order descent: Allows drop in type structure.

The reduction pair is shown to be well-founded using Tait–Girard computability, with all ground terms strongly normalizing in the computability model whenever no infinite $\succ$-chain exists (Kop, 2024).

4. Dependency Graphs and Infinite Chains

The set $\mathrm{SDP}(\mathcal{R})$ is represented as a directed dependency graph:

• Nodes: The marked pairs from static DP extraction.
• Edges: There is an edge from

$$p = f^\sharp(\ell)\to g^\sharp(u)\;[\varphi]\quad\text{to}\quad q = g^\sharp(v)\to h^\sharp(w)\;[\psi]$$

if $g^\sharp(u)$ and $g^\sharp(v)$ unify under some substitution $\theta$ with $\theta\models (\varphi \wedge \psi)$.

The core reduction is that termination is equivalent to the absence of infinite chains in this graph: If there does not exist an infinite sequence of pairs such that the corresponding relation is $\succ$ infinitely often, then the LCSTRS is terminating (Kop, 2024, Kop, 2016, Guo et al., 2024).

Strongly Connected Components (SCCs) are then used to decompose the problem, with chain-freeness of each SCC equivalent to global chain-freeness.

5. Processors, Simplification, and Practical Framework

To show the absence of infinite chains, the dependency graph undergoes transformation by DP processors:

1. Graph decomposition: Decompose into SCCs.
2. Subterm criterion: Project (via mappings) argument positions to yield a decrease under a well-founded order, removing DPs that decrease a chosen component.
3. Theory or value criterion: Use reduction on theory or value arguments to orient pairs.
4. Reduction pair processor: Attempt to orient pairs under the chosen order ($\succeq, \succ$), possibly via polynomial interpretations or higher-order path orderings.

Each processor is shown to be sound: removing pairs that cannot appear infinitely often in any computable chain preserves the equivalence between chain-freeness and termination. This modular approach allows flexible, scalable proofs (Kop, 2016, Guo et al., 2024).

6. Open-World Termination and Universal Computability

While classical DP frameworks reason about closed systems, the static DP framework for LCSTRSs can be extended to open-world settings:

• Public computability: Termination is preserved under any extension not redefining certain hidden symbols.
• Universal computability: Termination is preserved under arbitrary extensions introducing only new symbols.

The same DP chain-freeness criterion applies when restricting attention to public chains, i.e., chains whose first SDP is public. This enables modular, library-style reasoning where LCSTRS termination is shown independently of possible future extensions (Guo et al., 2024).

7. Illustrative Examples and Application

For instance, analyzing a curried, constraint-rich definition such as bounded sum or a fold-based GCD list computation involves the following steps:

1. Extract all static dependency pairs with logical constraints from every rule.
2. Construct the dependency graph, encode constraint propagation, and perform satisfiability checks.
3. Decompose the graph into SCCs.
4. Apply appropriate DP processors to orient (strictly or weakly) each pair under the reduction pair.
5. Demonstrate that every SCC is chain-free by removing strictly oriented arcs or applying value, theory, or subterm criteria.

Such systematic application reconstructs a full termination proof for highly expressive, constrained higher-order rewrite systems (Kop, 2024, Kop, 2016, Guo et al., 2024).