We consider the system 477. Alphabet: 2 : [] --> int altmap : [int -> int * list] --> list cons : [int * list] --> list mlt : [int * int] --> int nil : [] --> list pls : [int * int] --> int plus : [int * int] --> int star : [int * int] --> int Rules: altmap(/\x.pls(x, X), cons(Y, Z)) => cons(pls(Y, X), altmap(/\y.mlt(y, X), Z)) altmap(/\x.mlt(x, X), cons(Y, Z)) => cons(mlt(Y, X), altmap(/\y.pls(y, X), Z)) altmap(/\x.X(x), nil) => nil pls(X, Y) => plus(X, Y) mlt(X, Y) => star(X, Y) pls(2, 2) => mlt(2, 2) We observe that the rules contain a first-order subset: pls(X, Y) => plus(X, Y) mlt(X, Y) => star(X, Y) pls(2, 2) => mlt(2, 2) Moreover, the system is finitely branching. Thus, by [Kop12, Thm. 7.55], we may omit all first-order dependency pairs from the dependency pair problem (DP(R), R) if this first-order part is Ce-terminating when seen as a many-sorted first-order TRS. According to the external first-order termination prover, this system is indeed Ce-terminating: || proof of resources/system.trs || # AProVE Commit ID: d84c10301d352dfd14de2104819581f4682260f5 fuhs 20130616 || || || Termination w.r.t. Q of the given QTRS could be proven: || || (0) QTRS || (1) QTRSRRRProof [EQUIVALENT] || (2) QTRS || (3) QTRSRRRProof [EQUIVALENT] || (4) QTRS || (5) RisEmptyProof [EQUIVALENT] || (6) YES || || || ---------------------------------------- || || (0) || Obligation: || Q restricted rewrite system: || The TRS R consists of the following rules: || || pls(%X, %Y) -> plus(%X, %Y) || mlt(%X, %Y) -> star(%X, %Y) || pls(2, 2) -> mlt(2, 2) || ~PAIR(%X, %Y) -> %X || ~PAIR(%X, %Y) -> %Y || || Q is empty. || || ---------------------------------------- || || (1) QTRSRRRProof (EQUIVALENT) || Used ordering: || Polynomial interpretation [POLO]: || || POL(2) = 2 || POL(mlt(x_1, x_2)) = 1 + x_1 + 2*x_2 || POL(pls(x_1, x_2)) = 2*x_1 + 2*x_2 || POL(plus(x_1, x_2)) = 2*x_1 + x_2 || POL(star(x_1, x_2)) = x_1 + x_2 || POL(~PAIR(x_1, x_2)) = 2 + x_1 + x_2 || With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: || || mlt(%X, %Y) -> star(%X, %Y) || pls(2, 2) -> mlt(2, 2) || ~PAIR(%X, %Y) -> %X || ~PAIR(%X, %Y) -> %Y || || || || || ---------------------------------------- || || (2) || Obligation: || Q restricted rewrite system: || The TRS R consists of the following rules: || || pls(%X, %Y) -> plus(%X, %Y) || || Q is empty. || || ---------------------------------------- || || (3) QTRSRRRProof (EQUIVALENT) || Used ordering: || Polynomial interpretation [POLO]: || || POL(pls(x_1, x_2)) = 2 + 2*x_1 + 2*x_2 || POL(plus(x_1, x_2)) = 1 + x_1 + x_2 || With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: || || pls(%X, %Y) -> plus(%X, %Y) || || || || || ---------------------------------------- || || (4) || Obligation: || Q restricted rewrite system: || R is empty. || Q is empty. || || ---------------------------------------- || || (5) RisEmptyProof (EQUIVALENT) || The TRS R is empty. Hence, termination is trivially proven. || ---------------------------------------- || || (6) || YES || We use the dependency pair framework as described in [Kop12, Ch. 6/7], with static dependency pairs (see [KusIsoSakBla09] and the adaptation for AFSMs and accessible arguments in [FuhKop19]). We thus obtain the following dependency pair problem (P_0, R_0, computable, all): Dependency Pairs P_0: 0] altmap#(/\x.pls(x, X), cons(Y, Z)) =#> pls#(Y, X) 1] altmap#(/\x.pls(x, X), cons(Y, Z)) =#> altmap#(/\y.mlt(y, X), Z) 2] altmap#(/\x.pls(x, X), cons(Y, Z)) =#> mlt#(U, X) 3] altmap#(/\x.mlt(x, X), cons(Y, Z)) =#> mlt#(Y, X) 4] altmap#(/\x.mlt(x, X), cons(Y, Z)) =#> altmap#(/\y.pls(y, X), Z) 5] altmap#(/\x.mlt(x, X), cons(Y, Z)) =#> pls#(U, X) Rules R_0: altmap(/\x.pls(x, X), cons(Y, Z)) => cons(pls(Y, X), altmap(/\y.mlt(y, X), Z)) altmap(/\x.mlt(x, X), cons(Y, Z)) => cons(mlt(Y, X), altmap(/\y.pls(y, X), Z)) altmap(/\x.X(x), nil) => nil pls(X, Y) => plus(X, Y) mlt(X, Y) => star(X, Y) pls(2, 2) => mlt(2, 2) Thus, the original system is terminating if (P_0, R_0, computable, all) is finite. We consider the dependency pair problem (P_0, R_0, computable, all). We place the elements of P in a dependency graph approximation G (see e.g. [Kop12, Thm. 7.27, 7.29], as follows: * 0 : * 1 : 3, 4, 5 * 2 : * 3 : * 4 : 0, 1, 2, 3, 4, 5 * 5 : This graph has the following strongly connected components: P_1: altmap#(/\x.pls(x, X), cons(Y, Z)) =#> altmap#(/\y.mlt(y, X), Z) altmap#(/\x.mlt(x, X), cons(Y, Z)) =#> altmap#(/\y.pls(y, X), Z) By [Kop12, Thm. 7.31], we may replace any dependency pair problem (P_0, R_0, m, f) by (P_1, R_0, m, f). Thus, the original system is terminating if (P_1, R_0, computable, all) is finite. We consider the dependency pair problem (P_1, R_0, computable, all). We apply the subterm criterion with the following projection function: nu(altmap#) = 2 Thus, we can orient the dependency pairs as follows: nu(altmap#(/\x.pls(x, X), cons(Y, Z))) = cons(Y, Z) |> Z = nu(altmap#(/\y.mlt(y, X), Z)) nu(altmap#(/\x.mlt(x, X), cons(Y, Z))) = cons(Y, Z) |> Z = nu(altmap#(/\y.pls(y, X), Z)) By [FuhKop19, Thm. 61], we may replace a dependency pair problem (P_1, R_0, computable, f) by ({}, R_0, computable, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. As all dependency pair problems were succesfully simplified with sound (and complete) processors until nothing remained, we conclude termination. +++ Citations +++ [FuhKop19] C. Fuhs, and C. Kop. A static higher-order dependency pair framework. In Proceedings of ESOP 2019, 2019. [Kop12] C. Kop. Higher Order Termination. PhD Thesis, 2012. [KusIsoSakBla09] K. Kusakari, Y. Isogai, M. Sakai, and F. Blanqui. Static Dependency Pair Method Based On Strong Computability for Higher-Order Rewrite Systems. In volume 92(10) of IEICE Transactions on Information and Systems. 2007--2015, 2009.