left

DP Transformations

right
AProVE Help SystemTechniquesTechniques working on SCCsDP Transformations

Description

In order to simplify the constraints generated from an SCC in [GTSKF '03, GTSKF '03b] the transformation techniques of rewriting, narrowing, and (forward) instantiation are presented. Every of these technique replaces one DP s → t by some transformed pairs {s1 → t1, …, sn → tn} (where n may be zero). The advantage of the transformed pairs is that the constraints or filtered constraints are sometimes easier to satisfy for an solver that is used afterwards i.e., an order may be successful on the new constraints which was not successful on the original ones. Moreover, whenever the original constraints where satisfied by some order then the same order satisfies the new constraints. But there are also two disadvantages: first, one DP may be transformed to many new pairs leading to more but very similar pairs and constraints. This may slow down a constraint solver or other techniques processing the resulting SCC further. Second, it can happen that the transformations may be applied infinitely often. Hence, it is unclear how often to apply the transformations.

Application and Configuration

For the automatic mode AProVE offers two heuristics that ensure only finitely many applications of the transformations.

Of course, the user can also use the different transformations separately and specify other limits as those used in the above heuristics. Moreover, in the interactive mode the user can directly choose which of the three transformation should be applied on which DP. Here, AProVE does not limit the use of the transformations and the user has to ensure that the transformations are applied in a suitable way.

Transformations are especially useful for TRS working with destructors. So, if one wants to show termination of the following TRS

p(s(x)) -> x
isZero(s(x)) -> false
isZero(0) -> true
f(x) -> g(isZero(x), x)
g(false, x) -> f(p(x))
g(true, x) -> x

without transformations one usually gets stuck at the SCC

F(x) -> G(isZero(x), x)
G(false, x) -> F(p(x))

because one essentially has to show x > p(x) which can not be fulfilled by any simplification order. However, after applying some transformations one gets the SCC

F(s(x)) -> G(false, s(x))
G(false, s(x)) -> F(x)

whose constraints can easily be satisfied.