/export/starexec/sandbox2/solver/bin/starexec_run_standard /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files
--------------------------------------------------------------------------------
MAYBE
proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty
Outermost Termination of the given OTRS could not be shown:
(0) OTRS
(1) Trivial-Transformation [SOUND, 0 ms]
(2) QTRS
(3) DependencyPairsProof [EQUIVALENT, 1 ms]
(4) QDP
(5) DependencyGraphProof [EQUIVALENT, 0 ms]
(6) QDP
(7) UsableRulesProof [EQUIVALENT, 0 ms]
(8) QDP
(9) NonTerminationLoopProof [COMPLETE, 0 ms]
(10) NO
(11) Thiemann-SpecialC-Transformation [EQUIVALENT, 0 ms]
(12) QTRS
(13) DependencyPairsProof [EQUIVALENT, 0 ms]
(14) QDP
(15) DependencyGraphProof [EQUIVALENT, 0 ms]
(16) AND
(17) QDP
(18) UsableRulesProof [EQUIVALENT, 0 ms]
(19) QDP
(20) QReductionProof [EQUIVALENT, 0 ms]
(21) QDP
(22) UsableRulesReductionPairsProof [EQUIVALENT, 16 ms]
(23) QDP
(24) DependencyGraphProof [EQUIVALENT, 0 ms]
(25) TRUE
(26) QDP
(27) UsableRulesProof [EQUIVALENT, 0 ms]
(28) QDP
(29) QReductionProof [EQUIVALENT, 0 ms]
(30) QDP
(31) TransformationProof [EQUIVALENT, 0 ms]
(32) QDP
(33) QDPOrderProof [EQUIVALENT, 13 ms]
(34) QDP
(35) UsableRulesProof [EQUIVALENT, 0 ms]
(36) QDP
(37) QReductionProof [EQUIVALENT, 0 ms]
(38) QDP
(39) Raffelsieper-Zantema-Transformation [SOUND, 0 ms]
(40) QTRS
(41) DependencyPairsProof [EQUIVALENT, 0 ms]
(42) QDP
(43) DependencyGraphProof [EQUIVALENT, 0 ms]
(44) QDP
(45) UsableRulesProof [EQUIVALENT, 12 ms]
(46) QDP
(47) TransformationProof [EQUIVALENT, 32 ms]
(48) QDP
(49) DependencyGraphProof [EQUIVALENT, 0 ms]
(50) QDP
(51) UsableRulesProof [EQUIVALENT, 0 ms]
(52) QDP
(53) TransformationProof [EQUIVALENT, 0 ms]
(54) QDP
(55) DependencyGraphProof [EQUIVALENT, 0 ms]
(56) QDP
(57) TransformationProof [EQUIVALENT, 0 ms]
(58) QDP
(59) DependencyGraphProof [EQUIVALENT, 0 ms]
(60) QDP
(61) TransformationProof [EQUIVALENT, 0 ms]
(62) QDP
(63) DependencyGraphProof [EQUIVALENT, 0 ms]
(64) QDP
(65) TransformationProof [EQUIVALENT, 0 ms]
(66) QDP
(67) DependencyGraphProof [EQUIVALENT, 0 ms]
(68) QDP
(69) TransformationProof [EQUIVALENT, 0 ms]
(70) QDP
(71) DependencyGraphProof [EQUIVALENT, 0 ms]
(72) QDP
(73) TransformationProof [EQUIVALENT, 10 ms]
(74) QDP
(75) DependencyGraphProof [EQUIVALENT, 0 ms]
(76) QDP
(77) TransformationProof [EQUIVALENT, 0 ms]
(78) QDP
(79) DependencyGraphProof [EQUIVALENT, 0 ms]
(80) QDP
(81) TransformationProof [EQUIVALENT, 11 ms]
(82) QDP
(83) DependencyGraphProof [EQUIVALENT, 0 ms]
(84) QDP
(85) MRRProof [EQUIVALENT, 159 ms]
(86) QDP
(87) QDPOrderProof [EQUIVALENT, 1190 ms]
(88) QDP
(89) QDPOrderProof [EQUIVALENT, 606 ms]
(90) QDP
(91) QDPOrderProof [EQUIVALENT, 3463 ms]
(92) QDP
(93) QDPOrderProof [EQUIVALENT, 4315 ms]
(94) QDP
(95) SplitQDPProof [EQUIVALENT, 0 ms]
(96) AND
(97) QDP
(98) SemLabProof [SOUND, 0 ms]
(99) QDP
(100) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms]
(101) QDP
(102) MRRProof [EQUIVALENT, 9 ms]
(103) QDP
(104) DependencyGraphProof [EQUIVALENT, 0 ms]
(105) QDP
(106) QDPOrderProof [EQUIVALENT, 18 ms]
(107) QDP
(108) QDPOrderProof [EQUIVALENT, 0 ms]
(109) QDP
(110) PisEmptyProof [SOUND, 0 ms]
(111) TRUE
(112) QDP
(113) SplitQDPProof [EQUIVALENT, 0 ms]
(114) AND
(115) QDP
(116) SemLabProof [SOUND, 0 ms]
(117) QDP
(118) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms]
(119) QDP
(120) DependencyGraphProof [EQUIVALENT, 0 ms]
(121) QDP
(122) MRRProof [EQUIVALENT, 21 ms]
(123) QDP
(124) QDPOrderProof [EQUIVALENT, 0 ms]
(125) QDP
(126) QDPOrderProof [EQUIVALENT, 15 ms]
(127) QDP
(128) QDPOrderProof [EQUIVALENT, 0 ms]
(129) QDP
(130) QDPOrderProof [EQUIVALENT, 0 ms]
(131) QDP
(132) PisEmptyProof [SOUND, 0 ms]
(133) TRUE
(134) QDP
(135) SplitQDPProof [EQUIVALENT, 0 ms]
(136) AND
(137) QDP
(138) SemLabProof [SOUND, 0 ms]
(139) QDP
(140) MRRProof [EQUIVALENT, 0 ms]
(141) QDP
(142) QDPOrderProof [EQUIVALENT, 0 ms]
(143) QDP
(144) QDPOrderProof [EQUIVALENT, 17 ms]
(145) QDP
(146) PisEmptyProof [SOUND, 0 ms]
(147) TRUE
(148) QDP
(149) TransformationProof [EQUIVALENT, 0 ms]
(150) QDP
(151) DependencyGraphProof [EQUIVALENT, 0 ms]
(152) QDP
(153) TransformationProof [EQUIVALENT, 18 ms]
(154) QDP
(155) DependencyGraphProof [EQUIVALENT, 0 ms]
(156) QDP
(157) TransformationProof [EQUIVALENT, 0 ms]
(158) QDP
(159) DependencyGraphProof [EQUIVALENT, 0 ms]
(160) QDP
(161) SplitQDPProof [EQUIVALENT, 0 ms]
(162) AND
(163) QDP
(164) SemLabProof [SOUND, 0 ms]
(165) QDP
(166) MRRProof [EQUIVALENT, 0 ms]
(167) QDP
(168) DependencyGraphProof [EQUIVALENT, 0 ms]
(169) QDP
(170) MRRProof [EQUIVALENT, 0 ms]
(171) QDP
(172) MRRProof [EQUIVALENT, 7 ms]
(173) QDP
(174) DependencyGraphProof [EQUIVALENT, 0 ms]
(175) QDP
(176) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms]
(177) QDP
(178) QDPOrderProof [EQUIVALENT, 14 ms]
(179) QDP
(180) QDPOrderProof [EQUIVALENT, 0 ms]
(181) QDP
(182) PisEmptyProof [SOUND, 0 ms]
(183) TRUE
(184) QDP
(185) SplitQDPProof [EQUIVALENT, 0 ms]
(186) AND
(187) QDP
(188) SemLabProof [SOUND, 0 ms]
(189) QDP
(190) MRRProof [EQUIVALENT, 0 ms]
(191) QDP
(192) DependencyGraphProof [EQUIVALENT, 0 ms]
(193) QDP
(194) MRRProof [EQUIVALENT, 16 ms]
(195) QDP
(196) MRRProof [EQUIVALENT, 0 ms]
(197) QDP
(198) DependencyGraphProof [EQUIVALENT, 0 ms]
(199) QDP
(200) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms]
(201) QDP
(202) QDPOrderProof [EQUIVALENT, 12 ms]
(203) QDP
(204) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms]
(205) QDP
(206) PisEmptyProof [SOUND, 0 ms]
(207) TRUE
(208) QDP
(209) SplitQDPProof [EQUIVALENT, 0 ms]
(210) AND
(211) QDP
(212) SemLabProof [SOUND, 0 ms]
(213) QDP
(214) MRRProof [EQUIVALENT, 8 ms]
(215) QDP
(216) DependencyGraphProof [EQUIVALENT, 0 ms]
(217) QDP
(218) MRRProof [EQUIVALENT, 0 ms]
(219) QDP
(220) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms]
(221) QDP
(222) PisEmptyProof [SOUND, 0 ms]
(223) TRUE
(224) QDP
----------------------------------------
(0)
Obligation:
Term rewrite system R:
The TRS R consists of the following rules:
a -> f(a)
a -> g(a)
f(f(f(x))) -> b
g(g(g(x))) -> b
g(f(f(g(x)))) -> b
f(g(g(f(x)))) -> b
g(f(g(f(x)))) -> b
Outermost Strategy.
----------------------------------------
(1) Trivial-Transformation (SOUND)
We applied the Trivial transformation to transform the outermost TRS to a standard TRS.
----------------------------------------
(2)
Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
a -> f(a)
a -> g(a)
f(f(f(x))) -> b
g(g(g(x))) -> b
g(f(f(g(x)))) -> b
f(g(g(f(x)))) -> b
g(f(g(f(x)))) -> b
Q is empty.
----------------------------------------
(3) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.
----------------------------------------
(4)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
A -> F(a)
A -> A
A -> G(a)
The TRS R consists of the following rules:
a -> f(a)
a -> g(a)
f(f(f(x))) -> b
g(g(g(x))) -> b
g(f(f(g(x)))) -> b
f(g(g(f(x)))) -> b
g(f(g(f(x)))) -> b
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(5) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
----------------------------------------
(6)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
A -> A
The TRS R consists of the following rules:
a -> f(a)
a -> g(a)
f(f(f(x))) -> b
g(g(g(x))) -> b
g(f(f(g(x)))) -> b
f(g(g(f(x)))) -> b
g(f(g(f(x)))) -> b
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(7) UsableRulesProof (EQUIVALENT)
We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------
(8)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
A -> A
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(9) NonTerminationLoopProof (COMPLETE)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.
s = A evaluates to t =A
Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
* Matcher: [ ]
* Semiunifier: [ ]
--------------------------------------------------------------------------------
Rewriting sequence
The DP semiunifies directly so there is only one rewrite step from A to A.
----------------------------------------
(10)
NO
----------------------------------------
(11) Thiemann-SpecialC-Transformation (EQUIVALENT)
We applied the Thiemann-SpecialC transformation to transform the outermost TRS to an innermost TRS.
----------------------------------------
(12)
Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
top(go_up(x)) -> top(reduce(x))
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_f(f(f(x))) -> result_f(b)
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_f(g(g(f(x)))) -> result_f(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_f(result_f(x)) -> go_up(x)
check_g(result_g(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
The set Q consists of the following terms:
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
----------------------------------------
(13) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.
----------------------------------------
(14)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(x)) -> TOP(reduce(x))
TOP(go_up(x)) -> REDUCE(x)
REDUCE(f(x_1)) -> CHECK_F(redex_f(x_1))
REDUCE(f(x_1)) -> REDEX_F(x_1)
REDUCE(g(x_1)) -> CHECK_G(redex_g(x_1))
REDUCE(g(x_1)) -> REDEX_G(x_1)
CHECK_F(redex_f(x_1)) -> IN_F_1(reduce(x_1))
CHECK_F(redex_f(x_1)) -> REDUCE(x_1)
CHECK_G(redex_g(x_1)) -> IN_G_1(reduce(x_1))
CHECK_G(redex_g(x_1)) -> REDUCE(x_1)
The TRS R consists of the following rules:
top(go_up(x)) -> top(reduce(x))
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_f(f(f(x))) -> result_f(b)
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_f(g(g(f(x)))) -> result_f(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_f(result_f(x)) -> go_up(x)
check_g(result_g(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
The set Q consists of the following terms:
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(15) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 5 less nodes.
----------------------------------------
(16)
Complex Obligation (AND)
----------------------------------------
(17)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
CHECK_F(redex_f(x_1)) -> REDUCE(x_1)
REDUCE(f(x_1)) -> CHECK_F(redex_f(x_1))
REDUCE(g(x_1)) -> CHECK_G(redex_g(x_1))
CHECK_G(redex_g(x_1)) -> REDUCE(x_1)
The TRS R consists of the following rules:
top(go_up(x)) -> top(reduce(x))
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_f(f(f(x))) -> result_f(b)
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_f(g(g(f(x)))) -> result_f(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_f(result_f(x)) -> go_up(x)
check_g(result_g(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
The set Q consists of the following terms:
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(18) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------
(19)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
CHECK_F(redex_f(x_1)) -> REDUCE(x_1)
REDUCE(f(x_1)) -> CHECK_F(redex_f(x_1))
REDUCE(g(x_1)) -> CHECK_G(redex_g(x_1))
CHECK_G(redex_g(x_1)) -> REDUCE(x_1)
The TRS R consists of the following rules:
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
The set Q consists of the following terms:
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(20) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
----------------------------------------
(21)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
CHECK_F(redex_f(x_1)) -> REDUCE(x_1)
REDUCE(f(x_1)) -> CHECK_F(redex_f(x_1))
REDUCE(g(x_1)) -> CHECK_G(redex_g(x_1))
CHECK_G(redex_g(x_1)) -> REDUCE(x_1)
The TRS R consists of the following rules:
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
The set Q consists of the following terms:
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(22) UsableRulesReductionPairsProof (EQUIVALENT)
By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.
The following dependency pairs can be deleted:
REDUCE(f(x_1)) -> CHECK_F(redex_f(x_1))
REDUCE(g(x_1)) -> CHECK_G(redex_g(x_1))
The following rules are removed from R:
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
Used ordering: POLO with Polynomial interpretation [POLO]:
POL(CHECK_F(x_1)) = 2*x_1
POL(CHECK_G(x_1)) = x_1
POL(REDUCE(x_1)) = 2*x_1
POL(b) = 0
POL(f(x_1)) = 2*x_1
POL(g(x_1)) = 2*x_1
POL(redex_f(x_1)) = x_1
POL(redex_g(x_1)) = 2*x_1
POL(result_f(x_1)) = 2*x_1
POL(result_g(x_1)) = x_1
----------------------------------------
(23)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
CHECK_F(redex_f(x_1)) -> REDUCE(x_1)
CHECK_G(redex_g(x_1)) -> REDUCE(x_1)
R is empty.
The set Q consists of the following terms:
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(24) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes.
----------------------------------------
(25)
TRUE
----------------------------------------
(26)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(x)) -> TOP(reduce(x))
The TRS R consists of the following rules:
top(go_up(x)) -> top(reduce(x))
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_f(f(f(x))) -> result_f(b)
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_f(g(g(f(x)))) -> result_f(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_f(result_f(x)) -> go_up(x)
check_g(result_g(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
The set Q consists of the following terms:
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(27) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------
(28)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(x)) -> TOP(reduce(x))
The TRS R consists of the following rules:
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_g(result_g(x)) -> go_up(x)
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
check_f(result_f(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
The set Q consists of the following terms:
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(29) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
top(go_up(x0))
----------------------------------------
(30)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(x)) -> TOP(reduce(x))
The TRS R consists of the following rules:
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_g(result_g(x)) -> go_up(x)
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
check_f(result_f(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
The set Q consists of the following terms:
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(31) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(go_up(x)) -> TOP(reduce(x)) at position [0] we obtained the following new rules [LPAR04]:
(TOP(go_up(f(x0))) -> TOP(check_f(redex_f(x0))),TOP(go_up(f(x0))) -> TOP(check_f(redex_f(x0))))
(TOP(go_up(g(x0))) -> TOP(check_g(redex_g(x0))),TOP(go_up(g(x0))) -> TOP(check_g(redex_g(x0))))
(TOP(go_up(a)) -> TOP(go_up(f(a))),TOP(go_up(a)) -> TOP(go_up(f(a))))
(TOP(go_up(a)) -> TOP(go_up(g(a))),TOP(go_up(a)) -> TOP(go_up(g(a))))
----------------------------------------
(32)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(f(x0))) -> TOP(check_f(redex_f(x0)))
TOP(go_up(g(x0))) -> TOP(check_g(redex_g(x0)))
TOP(go_up(a)) -> TOP(go_up(f(a)))
TOP(go_up(a)) -> TOP(go_up(g(a)))
The TRS R consists of the following rules:
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_g(result_g(x)) -> go_up(x)
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
check_f(result_f(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
The set Q consists of the following terms:
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(33) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP(go_up(a)) -> TOP(go_up(f(a)))
TOP(go_up(a)) -> TOP(go_up(g(a)))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP(x_1)) = x_1
POL(a) = 1
POL(b) = 0
POL(check_f(x_1)) = x_1
POL(check_g(x_1)) = x_1
POL(f(x_1)) = 0
POL(g(x_1)) = 0
POL(go_up(x_1)) = x_1
POL(in_f_1(x_1)) = 0
POL(in_g_1(x_1)) = 0
POL(redex_f(x_1)) = 0
POL(redex_g(x_1)) = 0
POL(reduce(x_1)) = 0
POL(result_f(x_1)) = x_1
POL(result_g(x_1)) = x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
check_f(result_f(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_g(result_g(x)) -> go_up(x)
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
----------------------------------------
(34)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(f(x0))) -> TOP(check_f(redex_f(x0)))
TOP(go_up(g(x0))) -> TOP(check_g(redex_g(x0)))
The TRS R consists of the following rules:
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_g(result_g(x)) -> go_up(x)
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
check_f(result_f(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
The set Q consists of the following terms:
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(35) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------
(36)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(x)) -> TOP(reduce(x))
The TRS R consists of the following rules:
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_g(result_g(x)) -> go_up(x)
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
check_f(result_f(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
The set Q consists of the following terms:
top(go_up(x0))
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(37) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
top(go_up(x0))
----------------------------------------
(38)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(go_up(x)) -> TOP(reduce(x))
The TRS R consists of the following rules:
reduce(f(x_1)) -> check_f(redex_f(x_1))
reduce(g(x_1)) -> check_g(redex_g(x_1))
reduce(a) -> go_up(f(a))
reduce(a) -> go_up(g(a))
redex_g(g(g(x))) -> result_g(b)
redex_g(f(f(g(x)))) -> result_g(b)
redex_g(f(g(f(x)))) -> result_g(b)
check_g(result_g(x)) -> go_up(x)
check_g(redex_g(x_1)) -> in_g_1(reduce(x_1))
in_g_1(go_up(x_1)) -> go_up(g(x_1))
redex_f(f(f(x))) -> result_f(b)
redex_f(g(g(f(x)))) -> result_f(b)
check_f(result_f(x)) -> go_up(x)
check_f(redex_f(x_1)) -> in_f_1(reduce(x_1))
in_f_1(go_up(x_1)) -> go_up(f(x_1))
The set Q consists of the following terms:
reduce(f(x0))
reduce(g(x0))
reduce(a)
redex_f(f(f(x0)))
redex_g(g(g(x0)))
redex_g(f(f(g(x0))))
redex_f(g(g(f(x0))))
redex_g(f(g(f(x0))))
check_f(result_f(x0))
check_g(result_g(x0))
check_f(redex_f(x0))
check_g(redex_g(x0))
in_f_1(go_up(x0))
in_g_1(go_up(x0))
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(39) Raffelsieper-Zantema-Transformation (SOUND)
We applied the Raffelsieper-Zantema transformation to transform the outermost TRS to a standard TRS.
----------------------------------------
(40)
Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(f(f(x)))) -> up(b)
down(g(g(g(x)))) -> up(b)
down(g(f(f(g(x))))) -> up(b)
down(f(g(g(f(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
top(up(x)) -> top(down(x))
down(f(a)) -> f_flat(down(a))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(g(a)) -> g_flat(down(a))
down(g(b)) -> g_flat(down(b))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(g(y10)))) -> f_flat(down(f(g(y10))))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(f(y18)))) -> g_flat(down(g(f(y18))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
f_flat(up(x_1)) -> up(f(x_1))
g_flat(up(x_1)) -> up(g(x_1))
Q is empty.
----------------------------------------
(41) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.
----------------------------------------
(42)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(x)) -> TOP(down(x))
TOP(up(x)) -> DOWN(x)
DOWN(f(a)) -> F_FLAT(down(a))
DOWN(f(a)) -> DOWN(a)
DOWN(f(b)) -> F_FLAT(down(b))
DOWN(f(b)) -> DOWN(b)
DOWN(f(fresh_constant)) -> F_FLAT(down(fresh_constant))
DOWN(f(fresh_constant)) -> DOWN(fresh_constant)
DOWN(g(a)) -> G_FLAT(down(a))
DOWN(g(a)) -> DOWN(a)
DOWN(g(b)) -> G_FLAT(down(b))
DOWN(g(b)) -> DOWN(b)
DOWN(g(fresh_constant)) -> G_FLAT(down(fresh_constant))
DOWN(g(fresh_constant)) -> DOWN(fresh_constant)
DOWN(f(f(a))) -> F_FLAT(down(f(a)))
DOWN(f(f(a))) -> DOWN(f(a))
DOWN(f(f(g(y10)))) -> F_FLAT(down(f(g(y10))))
DOWN(f(f(g(y10)))) -> DOWN(f(g(y10)))
DOWN(f(f(b))) -> F_FLAT(down(f(b)))
DOWN(f(f(b))) -> DOWN(f(b))
DOWN(f(f(fresh_constant))) -> F_FLAT(down(f(fresh_constant)))
DOWN(f(f(fresh_constant))) -> DOWN(f(fresh_constant))
DOWN(f(g(a))) -> F_FLAT(down(g(a)))
DOWN(f(g(a))) -> DOWN(g(a))
DOWN(f(g(f(y12)))) -> F_FLAT(down(g(f(y12))))
DOWN(f(g(f(y12)))) -> DOWN(g(f(y12)))
DOWN(f(g(b))) -> F_FLAT(down(g(b)))
DOWN(f(g(b))) -> DOWN(g(b))
DOWN(f(g(fresh_constant))) -> F_FLAT(down(g(fresh_constant)))
DOWN(f(g(fresh_constant))) -> DOWN(g(fresh_constant))
DOWN(g(f(a))) -> G_FLAT(down(f(a)))
DOWN(g(f(a))) -> DOWN(f(a))
DOWN(g(f(b))) -> G_FLAT(down(f(b)))
DOWN(g(f(b))) -> DOWN(f(b))
DOWN(g(f(fresh_constant))) -> G_FLAT(down(f(fresh_constant)))
DOWN(g(f(fresh_constant))) -> DOWN(f(fresh_constant))
DOWN(g(g(a))) -> G_FLAT(down(g(a)))
DOWN(g(g(a))) -> DOWN(g(a))
DOWN(g(g(f(y18)))) -> G_FLAT(down(g(f(y18))))
DOWN(g(g(f(y18)))) -> DOWN(g(f(y18)))
DOWN(g(g(b))) -> G_FLAT(down(g(b)))
DOWN(g(g(b))) -> DOWN(g(b))
DOWN(g(g(fresh_constant))) -> G_FLAT(down(g(fresh_constant)))
DOWN(g(g(fresh_constant))) -> DOWN(g(fresh_constant))
DOWN(f(g(g(a)))) -> F_FLAT(down(g(g(a))))
DOWN(f(g(g(a)))) -> DOWN(g(g(a)))
DOWN(f(g(g(g(y22))))) -> F_FLAT(down(g(g(g(y22)))))
DOWN(f(g(g(g(y22))))) -> DOWN(g(g(g(y22))))
DOWN(f(g(g(b)))) -> F_FLAT(down(g(g(b))))
DOWN(f(g(g(b)))) -> DOWN(g(g(b)))
DOWN(f(g(g(fresh_constant)))) -> F_FLAT(down(g(g(fresh_constant))))
DOWN(f(g(g(fresh_constant)))) -> DOWN(g(g(fresh_constant)))
DOWN(g(f(f(a)))) -> G_FLAT(down(f(f(a))))
DOWN(g(f(f(a)))) -> DOWN(f(f(a)))
DOWN(g(f(f(f(y24))))) -> G_FLAT(down(f(f(f(y24)))))
DOWN(g(f(f(f(y24))))) -> DOWN(f(f(f(y24))))
DOWN(g(f(f(b)))) -> G_FLAT(down(f(f(b))))
DOWN(g(f(f(b)))) -> DOWN(f(f(b)))
DOWN(g(f(f(fresh_constant)))) -> G_FLAT(down(f(f(fresh_constant))))
DOWN(g(f(f(fresh_constant)))) -> DOWN(f(f(fresh_constant)))
DOWN(g(f(g(a)))) -> G_FLAT(down(f(g(a))))
DOWN(g(f(g(a)))) -> DOWN(f(g(a)))
DOWN(g(f(g(g(y28))))) -> G_FLAT(down(f(g(g(y28)))))
DOWN(g(f(g(g(y28))))) -> DOWN(f(g(g(y28))))
DOWN(g(f(g(b)))) -> G_FLAT(down(f(g(b))))
DOWN(g(f(g(b)))) -> DOWN(f(g(b)))
DOWN(g(f(g(fresh_constant)))) -> G_FLAT(down(f(g(fresh_constant))))
DOWN(g(f(g(fresh_constant)))) -> DOWN(f(g(fresh_constant)))
The TRS R consists of the following rules:
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(f(f(x)))) -> up(b)
down(g(g(g(x)))) -> up(b)
down(g(f(f(g(x))))) -> up(b)
down(f(g(g(f(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
top(up(x)) -> top(down(x))
down(f(a)) -> f_flat(down(a))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(g(a)) -> g_flat(down(a))
down(g(b)) -> g_flat(down(b))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(g(y10)))) -> f_flat(down(f(g(y10))))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(f(y18)))) -> g_flat(down(g(f(y18))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
f_flat(up(x_1)) -> up(f(x_1))
g_flat(up(x_1)) -> up(g(x_1))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(43) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 67 less nodes.
----------------------------------------
(44)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(x)) -> TOP(down(x))
The TRS R consists of the following rules:
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(f(f(x)))) -> up(b)
down(g(g(g(x)))) -> up(b)
down(g(f(f(g(x))))) -> up(b)
down(f(g(g(f(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
top(up(x)) -> top(down(x))
down(f(a)) -> f_flat(down(a))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(g(a)) -> g_flat(down(a))
down(g(b)) -> g_flat(down(b))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(g(y10)))) -> f_flat(down(f(g(y10))))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(f(y18)))) -> g_flat(down(g(f(y18))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
f_flat(up(x_1)) -> up(f(x_1))
g_flat(up(x_1)) -> up(g(x_1))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(45) UsableRulesProof (EQUIVALENT)
We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------
(46)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(x)) -> TOP(down(x))
The TRS R consists of the following rules:
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(f(f(x)))) -> up(b)
down(g(g(g(x)))) -> up(b)
down(g(f(f(g(x))))) -> up(b)
down(f(g(g(f(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(f(a)) -> f_flat(down(a))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(g(a)) -> g_flat(down(a))
down(g(b)) -> g_flat(down(b))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(g(y10)))) -> f_flat(down(f(g(y10))))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(f(y18)))) -> g_flat(down(g(f(y18))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(47) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(x)) -> TOP(down(x)) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(a)) -> TOP(up(f(a))),TOP(up(a)) -> TOP(up(f(a))))
(TOP(up(a)) -> TOP(up(g(a))),TOP(up(a)) -> TOP(up(g(a))))
(TOP(up(f(f(f(x0))))) -> TOP(up(b)),TOP(up(f(f(f(x0))))) -> TOP(up(b)))
(TOP(up(g(g(g(x0))))) -> TOP(up(b)),TOP(up(g(g(g(x0))))) -> TOP(up(b)))
(TOP(up(g(f(f(g(x0)))))) -> TOP(up(b)),TOP(up(g(f(f(g(x0)))))) -> TOP(up(b)))
(TOP(up(f(g(g(f(x0)))))) -> TOP(up(b)),TOP(up(f(g(g(f(x0)))))) -> TOP(up(b)))
(TOP(up(g(f(g(f(x0)))))) -> TOP(up(b)),TOP(up(g(f(g(f(x0)))))) -> TOP(up(b)))
(TOP(up(f(a))) -> TOP(f_flat(down(a))),TOP(up(f(a))) -> TOP(f_flat(down(a))))
(TOP(up(f(b))) -> TOP(f_flat(down(b))),TOP(up(f(b))) -> TOP(f_flat(down(b))))
(TOP(up(f(fresh_constant))) -> TOP(f_flat(down(fresh_constant))),TOP(up(f(fresh_constant))) -> TOP(f_flat(down(fresh_constant))))
(TOP(up(g(a))) -> TOP(g_flat(down(a))),TOP(up(g(a))) -> TOP(g_flat(down(a))))
(TOP(up(g(b))) -> TOP(g_flat(down(b))),TOP(up(g(b))) -> TOP(g_flat(down(b))))
(TOP(up(g(fresh_constant))) -> TOP(g_flat(down(fresh_constant))),TOP(up(g(fresh_constant))) -> TOP(g_flat(down(fresh_constant))))
(TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a)))),TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a)))))
(TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0))))),TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0))))))
(TOP(up(f(f(b)))) -> TOP(f_flat(down(f(b)))),TOP(up(f(f(b)))) -> TOP(f_flat(down(f(b)))))
(TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant)))),TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant)))))
(TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a)))),TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a)))))
(TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0))))),TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0))))))
(TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b)))),TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b)))))
(TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant)))),TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant)))))
(TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a)))),TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a)))))
(TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b)))),TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b)))))
(TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant)))),TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant)))))
(TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a)))),TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a)))))
(TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0))))),TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0))))))
(TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b)))),TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b)))))
(TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant)))),TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant)))))
(TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a))))),TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a))))))
(TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0)))))),TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0)))))))
(TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b))))),TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b))))))
(TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant))))),TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant))))))
(TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a))))),TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a))))))
(TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0)))))),TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0)))))))
(TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b))))),TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b))))))
(TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant))))),TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant))))))
(TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a))))),TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a))))))
(TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0)))))),TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0)))))))
(TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b))))),TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b))))))
(TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant))))),TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant))))))
----------------------------------------
(48)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(a)) -> TOP(up(f(a)))
TOP(up(a)) -> TOP(up(g(a)))
TOP(up(f(f(f(x0))))) -> TOP(up(b))
TOP(up(g(g(g(x0))))) -> TOP(up(b))
TOP(up(g(f(f(g(x0)))))) -> TOP(up(b))
TOP(up(f(g(g(f(x0)))))) -> TOP(up(b))
TOP(up(g(f(g(f(x0)))))) -> TOP(up(b))
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(f(b))) -> TOP(f_flat(down(b)))
TOP(up(f(fresh_constant))) -> TOP(f_flat(down(fresh_constant)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(g(b))) -> TOP(g_flat(down(b)))
TOP(up(g(fresh_constant))) -> TOP(g_flat(down(fresh_constant)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(f(b)))) -> TOP(f_flat(down(f(b))))
TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(f(f(x)))) -> up(b)
down(g(g(g(x)))) -> up(b)
down(g(f(f(g(x))))) -> up(b)
down(f(g(g(f(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(f(a)) -> f_flat(down(a))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(g(a)) -> g_flat(down(a))
down(g(b)) -> g_flat(down(b))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(g(y10)))) -> f_flat(down(f(g(y10))))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(f(y18)))) -> g_flat(down(g(f(y18))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(49) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 11 less nodes.
----------------------------------------
(50)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(f(b)))) -> TOP(f_flat(down(f(b))))
TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(f(f(x)))) -> up(b)
down(g(g(g(x)))) -> up(b)
down(g(f(f(g(x))))) -> up(b)
down(f(g(g(f(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(f(a)) -> f_flat(down(a))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(g(a)) -> g_flat(down(a))
down(g(b)) -> g_flat(down(b))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(g(y10)))) -> f_flat(down(f(g(y10))))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(f(y18)))) -> g_flat(down(g(f(y18))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(51) UsableRulesProof (EQUIVALENT)
We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------
(52)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(f(b)))) -> TOP(f_flat(down(f(b))))
TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(53) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(f(f(b)))) -> TOP(f_flat(down(f(b)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(f(f(b)))) -> TOP(f_flat(f_flat(down(b)))),TOP(up(f(f(b)))) -> TOP(f_flat(f_flat(down(b)))))
----------------------------------------
(54)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(f(f(b)))) -> TOP(f_flat(f_flat(down(b))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(55) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(56)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(57) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(down(f(fresh_constant)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(f_flat(down(fresh_constant)))),TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(f_flat(down(fresh_constant)))))
----------------------------------------
(58)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(f(f(fresh_constant)))) -> TOP(f_flat(f_flat(down(fresh_constant))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(59) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(60)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(61) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(f(g(b)))) -> TOP(f_flat(down(g(b)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(f(g(b)))) -> TOP(f_flat(g_flat(down(b)))),TOP(up(f(g(b)))) -> TOP(f_flat(g_flat(down(b)))))
----------------------------------------
(62)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(f(g(b)))) -> TOP(f_flat(g_flat(down(b))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(63) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(64)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(65) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(down(g(fresh_constant)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(g_flat(down(fresh_constant)))),TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(g_flat(down(fresh_constant)))))
----------------------------------------
(66)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(f(g(fresh_constant)))) -> TOP(f_flat(g_flat(down(fresh_constant))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(67) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(68)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(69) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(g(f(b)))) -> TOP(g_flat(down(f(b)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(g(f(b)))) -> TOP(g_flat(f_flat(down(b)))),TOP(up(g(f(b)))) -> TOP(g_flat(f_flat(down(b)))))
----------------------------------------
(70)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(g(f(b)))) -> TOP(g_flat(f_flat(down(b))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(71) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(72)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(73) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(down(f(fresh_constant)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(f_flat(down(fresh_constant)))),TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(f_flat(down(fresh_constant)))))
----------------------------------------
(74)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(g(f(fresh_constant)))) -> TOP(g_flat(f_flat(down(fresh_constant))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(75) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(76)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(77) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(g(g(b)))) -> TOP(g_flat(down(g(b)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(g(g(b)))) -> TOP(g_flat(g_flat(down(b)))),TOP(up(g(g(b)))) -> TOP(g_flat(g_flat(down(b)))))
----------------------------------------
(78)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(g(g(b)))) -> TOP(g_flat(g_flat(down(b))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(79) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(80)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(81) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(down(g(fresh_constant)))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(g_flat(down(fresh_constant)))),TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(g_flat(down(fresh_constant)))))
----------------------------------------
(82)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
TOP(up(g(g(fresh_constant)))) -> TOP(g_flat(g_flat(down(fresh_constant))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(83) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(84)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(85) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:
TOP(up(f(g(g(fresh_constant))))) -> TOP(f_flat(down(g(g(fresh_constant)))))
TOP(up(g(f(f(fresh_constant))))) -> TOP(g_flat(down(f(f(fresh_constant)))))
TOP(up(g(f(g(fresh_constant))))) -> TOP(g_flat(down(f(g(fresh_constant)))))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP(x_1)) = x_1
POL(a) = 0
POL(b) = 0
POL(down(x_1)) = x_1
POL(f(x_1)) = x_1
POL(f_flat(x_1)) = x_1
POL(fresh_constant) = 1
POL(g(x_1)) = 2*x_1
POL(g_flat(x_1)) = 2*x_1
POL(up(x_1)) = 2*x_1
----------------------------------------
(86)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(a))) -> TOP(f_flat(down(a)))
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(87) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP(up(f(a))) -> TOP(f_flat(down(a)))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:
Non-tuple symbols:
<<<
M( a ) = [[0], [1]]
>>>
<<<
M( b ) = [[0], [0]]
>>>
<<<
M( down_1(x_1) ) = [[1], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( f_1(x_1) ) = [[0], [0]] + [[0, 1], [0, 0]] * x_1
>>>
<<<
M( fresh_constant ) = [[0], [0]]
>>>
<<<
M( up_1(x_1) ) = [[0], [0]] + [[1, 0], [0, 1]] * x_1
>>>
<<<
M( f_flat_1(x_1) ) = [[0], [0]] + [[0, 1], [0, 0]] * x_1
>>>
<<<
M( g_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( g_flat_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
Tuple symbols:
<<<
M( TOP_1(x_1) ) = [[0]] + [[1, 0]] * x_1
>>>
Matrix type:
We used a basic matrix type which is not further parametrizeable.
As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down(a) -> up(f(a))
down(a) -> up(g(a))
f_flat(up(x_1)) -> up(f(x_1))
g_flat(up(x_1)) -> up(g(x_1))
down(f(a)) -> f_flat(down(a))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(g(a)) -> g_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(g(x)))) -> up(b)
down(g(g(b))) -> g_flat(down(g(b)))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(b)) -> g_flat(down(b))
----------------------------------------
(88)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(g(a))) -> TOP(g_flat(down(a)))
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(89) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP(up(g(a))) -> TOP(g_flat(down(a)))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:
Non-tuple symbols:
<<<
M( a ) = [[1], [0]]
>>>
<<<
M( b ) = [[0], [0]]
>>>
<<<
M( down_1(x_1) ) = [[1], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( f_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( fresh_constant ) = [[0], [0]]
>>>
<<<
M( up_1(x_1) ) = [[0], [0]] + [[0, 1], [1, 0]] * x_1
>>>
<<<
M( f_flat_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( g_1(x_1) ) = [[0], [0]] + [[0, 0], [1, 0]] * x_1
>>>
<<<
M( g_flat_1(x_1) ) = [[0], [0]] + [[0, 1], [0, 0]] * x_1
>>>
Tuple symbols:
<<<
M( TOP_1(x_1) ) = [[0]] + [[1, 0]] * x_1
>>>
Matrix type:
We used a basic matrix type which is not further parametrizeable.
As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down(a) -> up(f(a))
down(a) -> up(g(a))
g_flat(up(x_1)) -> up(g(x_1))
down(f(a)) -> f_flat(down(a))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(f(g(a))) -> f_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(f(x)))) -> up(b)
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
----------------------------------------
(90)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(91) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP(up(f(f(a)))) -> TOP(f_flat(down(f(a))))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:
Non-tuple symbols:
<<<
M( a ) = [[1], [0]]
>>>
<<<
M( b ) = [[0], [0]]
>>>
<<<
M( down_1(x_1) ) = [[0], [0]] + [[1, 0], [0, 1]] * x_1
>>>
<<<
M( f_1(x_1) ) = [[0], [0]] + [[0, 1], [1, 0]] * x_1
>>>
<<<
M( fresh_constant ) = [[0], [0]]
>>>
<<<
M( up_1(x_1) ) = [[0], [0]] + [[0, 1], [1, 0]] * x_1
>>>
<<<
M( f_flat_1(x_1) ) = [[0], [0]] + [[0, 1], [1, 0]] * x_1
>>>
<<<
M( g_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( g_flat_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
Tuple symbols:
<<<
M( TOP_1(x_1) ) = [[0]] + [[0, 1]] * x_1
>>>
Matrix type:
We used a basic matrix type which is not further parametrizeable.
As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down(f(a)) -> f_flat(down(a))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
down(g(a)) -> g_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
g_flat(up(x_1)) -> up(g(x_1))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(g(g(x)))) -> up(b)
down(g(g(b))) -> g_flat(down(g(b)))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(b)) -> g_flat(down(b))
down(a) -> up(f(a))
down(a) -> up(g(a))
----------------------------------------
(92)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(93) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP(up(g(g(a)))) -> TOP(g_flat(down(g(a))))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:
Non-tuple symbols:
<<<
M( a ) = [[1], [0]]
>>>
<<<
M( b ) = [[0], [0]]
>>>
<<<
M( down_1(x_1) ) = [[0], [0]] + [[0, 1], [1, 0]] * x_1
>>>
<<<
M( f_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( fresh_constant ) = [[0], [0]]
>>>
<<<
M( up_1(x_1) ) = [[0], [0]] + [[1, 0], [0, 1]] * x_1
>>>
<<<
M( f_flat_1(x_1) ) = [[0], [0]] + [[0, 0], [0, 0]] * x_1
>>>
<<<
M( g_1(x_1) ) = [[0], [0]] + [[0, 1], [1, 0]] * x_1
>>>
<<<
M( g_flat_1(x_1) ) = [[0], [0]] + [[0, 1], [1, 0]] * x_1
>>>
Tuple symbols:
<<<
M( TOP_1(x_1) ) = [[0]] + [[1, 0]] * x_1
>>>
Matrix type:
We used a basic matrix type which is not further parametrizeable.
As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(f(g(a))) -> f_flat(down(g(a)))
f_flat(up(x_1)) -> up(f(x_1))
down(g(a)) -> g_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(a)) -> f_flat(down(a))
g_flat(up(x_1)) -> up(g(x_1))
down(f(f(a))) -> f_flat(down(f(a)))
down(f(f(f(x)))) -> up(b)
down(f(f(b))) -> f_flat(down(f(b)))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(b)) -> f_flat(down(b))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
----------------------------------------
(94)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(95) SplitQDPProof (EQUIVALENT)
We show in the first subproof that some pairs and rules can be removed, afterwards, we continue with the remaining DP-Problem
----------------------------------------
(96)
Complex Obligation (AND)
----------------------------------------
(97)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(a)))) -> TOP(f_flat(down(g(a))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(f(a)))) -> TOP(g_flat(down(f(a))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(b))) -> f_flat(down(g(b)))
down(g(b)) -> g_flat(down(b))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(98) SemLabProof (SOUND)
We found the following model for the rules of the TRSs R and P.
Interpretation over the domain with elements from 0 to 1.
a: 1
b: 0
down: 0
f: 0
fresh_constant: 0
up: 0
f_flat: 0
TOP: 0
g_flat: 0
g: 0
By semantic labelling [SEMLAB] we obtain the following labelled QDP problem.
----------------------------------------
(99)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.1(a.)))) -> TOP.0(f_flat.0(down.0(g.1(a.))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(f.1(a.)))) -> TOP.0(g_flat.0(down.0(f.1(a.))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.1(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(g.0(fresh_constant.)) -> g_flat.0(down.0(fresh_constant.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.0(b.)
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(g.1(x)))) -> up.0(b.)
down.0(g.0(g.1(a.))) -> g_flat.0(down.0(g.1(a.)))
down.0(g.1(a.)) -> g_flat.0(down.1(a.))
down.1(a.) -> up.0(f.1(a.))
down.1(a.) -> up.0(g.1(a.))
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(fresh_constant.)) -> f_flat.0(down.0(fresh_constant.))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(f.1(x)))) -> up.0(b.)
down.0(f.0(f.1(a.))) -> f_flat.0(down.0(f.1(a.)))
down.0(f.1(a.)) -> f_flat.0(down.1(a.))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.0(b.)
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(100) UsableRulesReductionPairsProof (EQUIVALENT)
By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.
No dependency pairs are removed.
The following rules are removed from R:
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
Used ordering: POLO with Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 1 + x_1
POL(down.1(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1 + x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(101)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.1(a.)))) -> TOP.0(f_flat.0(down.0(g.1(a.))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(f.1(a.)))) -> TOP.0(g_flat.0(down.0(f.1(a.))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.1(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(g.0(g.1(a.))) -> g_flat.0(down.0(g.1(a.)))
down.0(g.1(a.)) -> g_flat.0(down.1(a.))
down.1(a.) -> up.0(f.1(a.))
down.1(a.) -> up.0(g.1(a.))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(g.0(fresh_constant.)) -> g_flat.0(down.0(fresh_constant.))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.1(x)))) -> up.0(b.)
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.1(x)))) -> up.0(b.)
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.1(a.))) -> f_flat.0(down.0(f.1(a.)))
down.0(f.1(a.)) -> f_flat.0(down.1(a.))
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(fresh_constant.)) -> f_flat.0(down.0(fresh_constant.))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(102) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.0(f.0(g.0(g.0(f.1(x))))) -> up.0(b.)
down.0(g.0(g.0(g.1(x)))) -> up.0(b.)
down.0(f.0(f.0(f.1(x)))) -> up.0(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.0(b.)
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 1 + x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 1 + x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
----------------------------------------
(103)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.1(a.)))) -> TOP.0(f_flat.0(down.0(g.1(a.))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(f.1(a.)))) -> TOP.0(g_flat.0(down.0(f.1(a.))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.1(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(g.0(g.1(a.))) -> g_flat.0(down.0(g.1(a.)))
down.0(g.1(a.)) -> g_flat.0(down.1(a.))
down.1(a.) -> up.0(f.1(a.))
down.1(a.) -> up.0(g.1(a.))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(g.0(fresh_constant.)) -> g_flat.0(down.0(fresh_constant.))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.1(a.))) -> f_flat.0(down.0(f.1(a.)))
down.0(f.1(a.)) -> f_flat.0(down.1(a.))
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(fresh_constant.)) -> f_flat.0(down.0(fresh_constant.))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(104) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
----------------------------------------
(105)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.1(a.)))) -> TOP.0(f_flat.0(down.0(g.1(a.))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(f.1(a.)))) -> TOP.0(g_flat.0(down.0(f.1(a.))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.1(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(g.0(g.1(a.))) -> g_flat.0(down.0(g.1(a.)))
down.0(g.1(a.)) -> g_flat.0(down.1(a.))
down.1(a.) -> up.0(f.1(a.))
down.1(a.) -> up.0(g.1(a.))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(g.0(fresh_constant.)) -> g_flat.0(down.0(fresh_constant.))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.1(a.))) -> f_flat.0(down.0(f.1(a.)))
down.0(f.1(a.)) -> f_flat.0(down.1(a.))
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(fresh_constant.)) -> f_flat.0(down.0(fresh_constant.))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(106) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.1(a.)))) -> TOP.0(f_flat.0(down.0(g.1(a.))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 1
POL(b.) = 0
POL(down.0(x_1)) = 0
POL(down.1(x_1)) = 0
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 0
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = 0
POL(g.1(x_1)) = 1 + x_1
POL(g_flat.0(x_1)) = 0
POL(up.0(x_1)) = x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(g.1(a.)) -> g_flat.0(down.1(a.))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.1(a.))) -> g_flat.0(down.0(g.1(a.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(g.0(fresh_constant.)) -> g_flat.0(down.0(fresh_constant.))
----------------------------------------
(107)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(f.1(a.)))) -> TOP.0(g_flat.0(down.0(f.1(a.))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.1(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(g.0(g.1(a.))) -> g_flat.0(down.0(g.1(a.)))
down.0(g.1(a.)) -> g_flat.0(down.1(a.))
down.1(a.) -> up.0(f.1(a.))
down.1(a.) -> up.0(g.1(a.))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(g.0(fresh_constant.)) -> g_flat.0(down.0(fresh_constant.))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.1(a.))) -> f_flat.0(down.0(f.1(a.)))
down.0(f.1(a.)) -> f_flat.0(down.1(a.))
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(fresh_constant.)) -> f_flat.0(down.0(fresh_constant.))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(108) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(g.0(f.1(a.)))) -> TOP.0(g_flat.0(down.0(f.1(a.))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 1
POL(b.) = 0
POL(down.0(x_1)) = 0
POL(down.1(x_1)) = 0
POL(f.0(x_1)) = 0
POL(f.1(x_1)) = 1 + x_1
POL(f_flat.0(x_1)) = 0
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
down.0(f.1(a.)) -> f_flat.0(down.1(a.))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(f.0(f.1(a.))) -> f_flat.0(down.0(f.1(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(fresh_constant.)) -> f_flat.0(down.0(fresh_constant.))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
----------------------------------------
(109)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.1(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.1(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(a.)))) -> f_flat.0(down.0(g.0(g.1(a.))))
down.0(g.0(g.1(a.))) -> g_flat.0(down.0(g.1(a.)))
down.0(g.1(a.)) -> g_flat.0(down.1(a.))
down.1(a.) -> up.0(f.1(a.))
down.1(a.) -> up.0(g.1(a.))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(g.0(fresh_constant.)) -> g_flat.0(down.0(fresh_constant.))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(f.0(g.1(a.))) -> f_flat.0(down.0(g.1(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.1(a.))) -> f_flat.0(down.0(f.1(a.)))
down.0(f.1(a.)) -> f_flat.0(down.1(a.))
down.0(g.0(f.1(a.))) -> g_flat.0(down.0(f.1(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(f.1(a.)))) -> g_flat.0(down.0(f.0(f.1(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.1(a.)))) -> g_flat.0(down.0(f.0(g.1(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(fresh_constant.)) -> f_flat.0(down.0(fresh_constant.))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(110) PisEmptyProof (SOUND)
The TRS P is empty. Hence, there is no (P,Q,R) chain.
----------------------------------------
(111)
TRUE
----------------------------------------
(112)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(b)) -> g_flat(down(b))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(113) SplitQDPProof (EQUIVALENT)
We show in the first subproof that some pairs and rules can be removed, afterwards, we continue with the remaining DP-Problem
----------------------------------------
(114)
Complex Obligation (AND)
----------------------------------------
(115)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(b)) -> g_flat(down(b))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(g(fresh_constant)) -> g_flat(down(fresh_constant))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(fresh_constant)) -> f_flat(down(fresh_constant))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(116) SemLabProof (SOUND)
We found the following model for the rules of the TRSs R and P.
Interpretation over the domain with elements from 0 to 1.
a: 0
b: 0
down: 0
f: 0
fresh_constant: 1
up: 0
f_flat: 0
TOP: 0
g_flat: 0
g: 0
By semantic labelling [SEMLAB] we obtain the following labelled QDP problem.
----------------------------------------
(117)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(g.1(fresh_constant.)) -> g_flat.0(down.1(fresh_constant.))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(g.1(x)))) -> up.0(b.)
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(f.1(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.1(fresh_constant.)) -> f_flat.0(down.1(fresh_constant.))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(118) UsableRulesReductionPairsProof (EQUIVALENT)
By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.
No dependency pairs are removed.
The following rules are removed from R:
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.0(g.0(f.1(x))))) -> up.0(b.)
down.0(g.0(g.0(g.1(x)))) -> up.0(b.)
down.0(f.0(f.0(f.1(x)))) -> up.0(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.0(b.)
Used ordering: POLO with Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 1 + x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 1 + x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(119)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(g.1(fresh_constant.)) -> g_flat.0(down.1(fresh_constant.))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.1(fresh_constant.)) -> f_flat.0(down.1(fresh_constant.))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(120) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
----------------------------------------
(121)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(g.1(fresh_constant.)) -> g_flat.0(down.1(fresh_constant.))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.1(fresh_constant.)) -> f_flat.0(down.1(fresh_constant.))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(122) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.0(g.1(fresh_constant.)) -> g_flat.0(down.1(fresh_constant.))
down.0(f.1(fresh_constant.)) -> f_flat.0(down.1(fresh_constant.))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 1 + x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 1 + x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
----------------------------------------
(123)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(124) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 0
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = 1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = 1
POL(up.0(x_1)) = 1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
----------------------------------------
(125)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(126) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(f.0(x_1)) = 1
POL(f.1(x_1)) = 0
POL(f_flat.0(x_1)) = 1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
----------------------------------------
(127)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(128) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 0
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 0
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
----------------------------------------
(129)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(130) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 0
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
----------------------------------------
(131)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(b.)) -> g_flat.0(down.0(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.0(g.0(g.1(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.1(fresh_constant.))))
down.0(g.0(g.1(fresh_constant.))) -> g_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(b.)) -> f_flat.0(down.0(b.))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(f.0(g.1(fresh_constant.))) -> f_flat.0(down.0(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(132) PisEmptyProof (SOUND)
The TRS P is empty. Hence, there is no (P,Q,R) chain.
----------------------------------------
(133)
TRUE
----------------------------------------
(134)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(b)) -> g_flat(down(b))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(135) SplitQDPProof (EQUIVALENT)
We show in the first subproof that some pairs and rules can be removed, afterwards, we continue with the remaining DP-Problem
----------------------------------------
(136)
Complex Obligation (AND)
----------------------------------------
(137)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
down(g(b)) -> g_flat(down(b))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(b)) -> f_flat(down(b))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(138) SemLabProof (SOUND)
We found the following model for the rules of the TRSs R and P.
Interpretation over the domain with elements from 0 to 1.
a: 0
b: 1
down: 0
f: 0
fresh_constant: 0
up: 0
f_flat: 0
TOP: 0
g_flat: 0
g: 0
By semantic labelling [SEMLAB] we obtain the following labelled QDP problem.
----------------------------------------
(139)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.1(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.1(b.))) -> f_flat.0(down.0(g.1(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(g.1(b.)) -> g_flat.0(down.1(b.))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.1(b.)))) -> f_flat.0(down.0(g.0(g.1(b.))))
down.0(g.0(g.1(b.))) -> g_flat.0(down.0(g.1(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.1(b.)
down.0(g.0(g.0(g.1(x)))) -> up.1(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.1(b.))) -> f_flat.0(down.0(f.1(b.)))
down.0(f.1(b.)) -> f_flat.0(down.1(b.))
down.0(f.0(f.0(f.0(x)))) -> up.1(b.)
down.0(f.0(f.0(f.1(x)))) -> up.1(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.1(b.)
down.0(g.0(f.1(b.))) -> g_flat.0(down.0(f.1(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.1(b.)))) -> g_flat.0(down.0(f.0(f.1(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(b.)))) -> g_flat.0(down.0(f.0(g.1(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(140) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.0(g.1(b.)) -> g_flat.0(down.1(b.))
down.0(f.1(b.)) -> f_flat.0(down.1(b.))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 1 + x_1
POL(down.1(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1 + x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(141)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.1(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.1(b.))) -> f_flat.0(down.0(g.1(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.1(b.)))) -> f_flat.0(down.0(g.0(g.1(b.))))
down.0(g.0(g.1(b.))) -> g_flat.0(down.0(g.1(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.1(b.)
down.0(g.0(g.0(g.1(x)))) -> up.1(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.1(b.))) -> f_flat.0(down.0(f.1(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.1(b.)
down.0(f.0(f.0(f.1(x)))) -> up.1(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.1(b.)
down.0(g.0(f.1(b.))) -> g_flat.0(down.0(f.1(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.1(b.)))) -> g_flat.0(down.0(f.0(f.1(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(b.)))) -> g_flat.0(down.0(f.0(g.1(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(142) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 0
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = 1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = 1
POL(up.0(x_1)) = 1
POL(up.1(x_1)) = 1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.1(b.)))) -> f_flat.0(down.0(g.0(g.1(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.1(b.))) -> f_flat.0(down.0(g.1(b.)))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.1(b.)))) -> g_flat.0(down.0(f.0(f.1(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(b.)))) -> g_flat.0(down.0(f.0(g.1(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(g.0(f.1(b.))) -> g_flat.0(down.0(f.1(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(g.0(g.0(x)))) -> up.1(b.)
down.0(g.0(g.0(g.1(x)))) -> up.1(b.)
down.0(g.0(g.1(b.))) -> g_flat.0(down.0(g.1(b.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
----------------------------------------
(143)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.1(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.1(b.))) -> f_flat.0(down.0(g.1(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.1(b.)))) -> f_flat.0(down.0(g.0(g.1(b.))))
down.0(g.0(g.1(b.))) -> g_flat.0(down.0(g.1(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.1(b.)
down.0(g.0(g.0(g.1(x)))) -> up.1(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.1(b.))) -> f_flat.0(down.0(f.1(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.1(b.)
down.0(f.0(f.0(f.1(x)))) -> up.1(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.1(b.)
down.0(g.0(f.1(b.))) -> g_flat.0(down.0(f.1(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.1(b.)))) -> g_flat.0(down.0(f.0(f.1(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(b.)))) -> g_flat.0(down.0(f.0(g.1(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(144) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(f.0(x_1)) = 1
POL(f.1(x_1)) = 0
POL(f_flat.0(x_1)) = 1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1
POL(up.1(x_1)) = 1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.1(b.)))) -> f_flat.0(down.0(g.0(g.1(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.1(b.)))) -> g_flat.0(down.0(f.0(f.1(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(b.)))) -> g_flat.0(down.0(f.0(g.1(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(g.0(f.1(b.))) -> g_flat.0(down.0(f.1(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.1(b.)
down.0(f.0(f.0(f.1(x)))) -> up.1(b.)
down.0(f.0(f.1(b.))) -> f_flat.0(down.0(f.1(b.)))
down.0(f.0(g.1(b.))) -> f_flat.0(down.0(g.1(b.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
----------------------------------------
(145)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(f.0(g.0(g.1(b.))))) -> TOP.0(f_flat.0(down.0(g.0(g.1(b.)))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(f.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(f.1(b.)))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(g.1(b.))))) -> TOP.0(g_flat.0(down.0(f.0(g.1(b.)))))
The TRS R consists of the following rules:
down.0(f.0(g.1(b.))) -> f_flat.0(down.0(g.1(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.0(g.0(g.0(fresh_constant.)))) -> f_flat.0(down.0(g.0(g.0(fresh_constant.))))
down.0(g.0(g.0(fresh_constant.))) -> g_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.1(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.1(b.)))) -> f_flat.0(down.0(g.0(g.1(b.))))
down.0(g.0(g.1(b.))) -> g_flat.0(down.0(g.1(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.1(b.)
down.0(g.0(g.0(g.1(x)))) -> up.1(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.1(b.))) -> f_flat.0(down.0(f.1(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.1(b.)
down.0(f.0(f.0(f.1(x)))) -> up.1(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(fresh_constant.))) -> g_flat.0(down.0(f.0(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.1(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.1(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.1(b.)
down.0(g.0(f.1(b.))) -> g_flat.0(down.0(f.1(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.1(b.)))) -> g_flat.0(down.0(f.0(f.1(b.))))
down.0(g.0(f.0(f.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.0(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(b.)))) -> g_flat.0(down.0(f.0(g.1(b.))))
down.0(g.0(f.0(g.0(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.0(fresh_constant.))))
down.0(f.0(g.0(fresh_constant.))) -> f_flat.0(down.0(g.0(fresh_constant.)))
down.0(f.0(f.0(fresh_constant.))) -> f_flat.0(down.0(f.0(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(146) PisEmptyProof (SOUND)
The TRS P is empty. Hence, there is no (P,Q,R) chain.
----------------------------------------
(147)
TRUE
----------------------------------------
(148)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b)))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(149) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(f(g(g(b))))) -> TOP(f_flat(down(g(g(b))))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(f(g(g(b))))) -> TOP(f_flat(g_flat(down(g(b))))),TOP(up(f(g(g(b))))) -> TOP(f_flat(g_flat(down(g(b))))))
----------------------------------------
(150)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(f(g(g(b))))) -> TOP(f_flat(g_flat(down(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(151) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(152)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b)))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(153) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(g(f(f(b))))) -> TOP(g_flat(down(f(f(b))))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(g(f(f(b))))) -> TOP(g_flat(f_flat(down(f(b))))),TOP(up(g(f(f(b))))) -> TOP(g_flat(f_flat(down(f(b))))))
----------------------------------------
(154)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
TOP(up(g(f(f(b))))) -> TOP(g_flat(f_flat(down(f(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(155) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(156)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(157) TransformationProof (EQUIVALENT)
By narrowing [LPAR04] the rule TOP(up(g(f(g(b))))) -> TOP(g_flat(down(f(g(b))))) at position [0] we obtained the following new rules [LPAR04]:
(TOP(up(g(f(g(b))))) -> TOP(g_flat(f_flat(down(g(b))))),TOP(up(g(f(g(b))))) -> TOP(g_flat(f_flat(down(g(b))))))
----------------------------------------
(158)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
TOP(up(g(f(g(b))))) -> TOP(g_flat(f_flat(down(g(b)))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(159) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------
(160)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(161) SplitQDPProof (EQUIVALENT)
We show in the first subproof that some pairs and rules can be removed, afterwards, we continue with the remaining DP-Problem
----------------------------------------
(162)
Complex Obligation (AND)
----------------------------------------
(163)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
The TRS R consists of the following rules:
down(f(g(b))) -> f_flat(down(g(b)))
g_flat(up(x_1)) -> up(g(x_1))
f_flat(up(x_1)) -> up(f(x_1))
down(f(g(g(fresh_constant)))) -> f_flat(down(g(g(fresh_constant))))
down(g(g(fresh_constant))) -> g_flat(down(g(fresh_constant)))
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
down(g(g(b))) -> g_flat(down(g(b)))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(f(g(fresh_constant))) -> f_flat(down(g(fresh_constant)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(164) SemLabProof (SOUND)
We found the following model for the rules of the TRSs R and P.
Interpretation over the domain with elements from 0 to 1.
a: 0
b: 0
down: 0
f: 0
fresh_constant: 1
up: 0
f_flat: 0
TOP: 0
g_flat: 0
g: x0
By semantic labelling [SEMLAB] we obtain the following labelled QDP problem.
----------------------------------------
(165)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.1(g.1(g.1(g.1(x0)))))) -> TOP.0(f_flat.0(down.1(g.1(g.1(g.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.1(g.1(g.1(fresh_constant.)))) -> f_flat.0(down.1(g.1(g.1(fresh_constant.))))
down.1(g.1(g.1(fresh_constant.))) -> g_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(f.1(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.1(g.1(g.1(g.1(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(f.1(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(f.1(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(f.1(g.1(fresh_constant.))) -> f_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(166) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.0(f.0(g.0(g.0(f.1(x))))) -> up.0(b.)
down.1(g.1(g.1(g.1(x)))) -> up.0(b.)
down.0(f.0(f.0(f.1(x)))) -> up.0(b.)
down.0(g.0(f.0(f.1(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.1(x))))) -> up.0(b.)
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 1 + x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(167)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.1(g.1(g.1(g.1(x0)))))) -> TOP.0(f_flat.0(down.1(g.1(g.1(g.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(f.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.1(g.1(g.1(fresh_constant.)))) -> f_flat.0(down.1(g.1(g.1(fresh_constant.))))
down.1(g.1(g.1(fresh_constant.))) -> g_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(f.1(g.1(fresh_constant.))) -> f_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(168) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
----------------------------------------
(169)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
down.0(f.1(g.1(g.1(fresh_constant.)))) -> f_flat.0(down.1(g.1(g.1(fresh_constant.))))
down.1(g.1(g.1(fresh_constant.))) -> g_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(f.1(g.1(fresh_constant.))) -> f_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(170) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
f_flat.0(up.1(x_1)) -> up.0(f.1(x_1))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(171)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(f.1(g.1(g.1(fresh_constant.)))) -> f_flat.0(down.1(g.1(g.1(fresh_constant.))))
down.1(g.1(g.1(fresh_constant.))) -> g_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(f.1(g.1(fresh_constant.))) -> f_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(172) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.0(f.1(g.1(g.1(fresh_constant.)))) -> f_flat.0(down.1(g.1(g.1(fresh_constant.))))
down.0(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.1(g.1(fresh_constant.))) -> f_flat.0(down.1(g.1(fresh_constant.)))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 1 + x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = x_1
----------------------------------------
(173)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.1(g.1(g.1(fresh_constant.))) -> g_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(174) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
----------------------------------------
(175)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.1(g.1(g.1(fresh_constant.))) -> g_flat.0(down.1(g.1(fresh_constant.)))
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(176) UsableRulesReductionPairsProof (EQUIVALENT)
By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.
No dependency pairs are removed.
The following rules are removed from R:
down.1(g.1(g.1(fresh_constant.))) -> g_flat.0(down.1(g.1(fresh_constant.)))
Used ordering: POLO with Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1 + x_1
POL(up.1(x_1)) = x_1
----------------------------------------
(177)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(178) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(g.0(g.0(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(f.0(x_1)) = 1
POL(f.1(x_1)) = 0
POL(f_flat.0(x_1)) = 1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1
POL(up.1(x_1)) = 1 + x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
----------------------------------------
(179)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(180) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(f.0(g.0(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 0
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = 1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = 1 + x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
----------------------------------------
(181)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.1(fresh_constant.))) -> g_flat.0(down.0(f.1(fresh_constant.)))
down.0(g.0(f.1(g.1(g.1(y28))))) -> g_flat.0(down.0(f.1(g.1(g.1(y28)))))
down.0(g.0(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.1(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(f.1(y24))))) -> g_flat.0(down.0(f.0(f.0(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(f.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.1(fresh_constant.))) -> f_flat.0(down.0(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.0(f.1(y12)))) -> f_flat.0(down.0(g.0(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(182) PisEmptyProof (SOUND)
The TRS P is empty. Hence, there is no (P,Q,R) chain.
----------------------------------------
(183)
TRUE
----------------------------------------
(184)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
The TRS R consists of the following rules:
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
g_flat(up(x_1)) -> up(g(x_1))
down(g(g(b))) -> g_flat(down(g(b)))
f_flat(up(x_1)) -> up(f(x_1))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(185) SplitQDPProof (EQUIVALENT)
We show in the first subproof that some pairs and rules can be removed, afterwards, we continue with the remaining DP-Problem
----------------------------------------
(186)
Complex Obligation (AND)
----------------------------------------
(187)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
The TRS R consists of the following rules:
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
g_flat(up(x_1)) -> up(g(x_1))
down(g(g(b))) -> g_flat(down(g(b)))
f_flat(up(x_1)) -> up(f(x_1))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(fresh_constant))) -> g_flat(down(f(fresh_constant)))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(f(fresh_constant)))) -> g_flat(down(f(f(fresh_constant))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(f(fresh_constant))) -> f_flat(down(f(fresh_constant)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(188) SemLabProof (SOUND)
We found the following model for the rules of the TRSs R and P.
Interpretation over the domain with elements from 0 to 1.
a: 0
b: 0
down: 0
f: x0
fresh_constant: 1
up: 0
f_flat: 0
TOP: 0
g_flat: 0
g: 0
By semantic labelling [SEMLAB] we obtain the following labelled QDP problem.
----------------------------------------
(189)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.1(f.1(f.1(f.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(f.1(f.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.1(f.1(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(g.1(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.1(f.1(f.1(f.1(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.1(f.1(fresh_constant.))) -> g_flat.0(down.1(f.1(fresh_constant.)))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.1(f.1(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.1(f.1(f.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.1(f.1(f.1(fresh_constant.))) -> f_flat.0(down.1(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(190) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.0(f.0(g.0(g.1(f.1(x))))) -> up.0(b.)
down.0(g.0(g.0(g.1(x)))) -> up.0(b.)
down.1(f.1(f.1(f.1(x)))) -> up.0(b.)
down.0(g.0(f.0(f.0(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.1(f.1(x))))) -> up.0(b.)
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 1 + x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(191)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(f.0(g.0(g.0(g.1(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.1(f.1(f.1(f.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(f.1(f.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(g.1(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.1(f.1(fresh_constant.))) -> g_flat.0(down.1(f.1(fresh_constant.)))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.1(f.1(f.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.1(f.1(f.1(fresh_constant.))) -> f_flat.0(down.1(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(192) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
----------------------------------------
(193)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.1(f.1(fresh_constant.))) -> g_flat.0(down.1(f.1(fresh_constant.)))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.1(f.1(f.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.1(f.1(f.1(fresh_constant.))) -> f_flat.0(down.1(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(194) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
g_flat.0(up.1(x_1)) -> up.0(g.1(x_1))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(195)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.1(f.1(fresh_constant.))) -> g_flat.0(down.1(f.1(fresh_constant.)))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.1(f.1(f.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(f.1(fresh_constant.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.1(f.1(f.1(fresh_constant.))) -> f_flat.0(down.1(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(196) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.0(g.1(f.1(fresh_constant.))) -> g_flat.0(down.1(f.1(fresh_constant.)))
down.0(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.1(f.1(f.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(f.1(fresh_constant.))))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = 1 + x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = x_1
----------------------------------------
(197)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.0(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.1(f.1(f.1(fresh_constant.))) -> f_flat.0(down.1(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(198) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
----------------------------------------
(199)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.1(f.1(f.1(fresh_constant.))) -> f_flat.0(down.1(f.1(fresh_constant.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(200) UsableRulesReductionPairsProof (EQUIVALENT)
By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.
No dependency pairs are removed.
The following rules are removed from R:
down.1(f.1(f.1(fresh_constant.))) -> f_flat.0(down.1(f.1(fresh_constant.)))
Used ordering: POLO with Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1 + x_1
POL(up.1(x_1)) = x_1
----------------------------------------
(201)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(202) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].
The following pairs can be oriented strictly and are deleted.
TOP.0(up.0(f.0(f.0(g.1(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.1(x0)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = 1
POL(g.1(x_1)) = 0
POL(g_flat.0(x_1)) = 1
POL(up.0(x_1)) = 1
POL(up.1(x_1)) = 1 + x_1
The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
----------------------------------------
(203)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(204) UsableRulesReductionPairsProof (EQUIVALENT)
By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.
No dependency pairs are removed.
The following rules are removed from R:
down.0(f.0(g.1(f.1(y12)))) -> f_flat.0(down.0(g.1(f.1(y12))))
Used ordering: POLO with Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1 + x_1
POL(up.1(x_1)) = x_1
----------------------------------------
(205)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(g.1(y22))))) -> f_flat.0(down.0(g.0(g.0(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(g.0(g.1(y28))))) -> g_flat.0(down.0(f.0(g.0(g.1(y28)))))
down.0(g.0(f.0(g.1(fresh_constant.)))) -> g_flat.0(down.0(f.0(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(206) PisEmptyProof (SOUND)
The TRS P is empty. Hence, there is no (P,Q,R) chain.
----------------------------------------
(207)
TRUE
----------------------------------------
(208)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
The TRS R consists of the following rules:
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
g_flat(up(x_1)) -> up(g(x_1))
down(g(g(b))) -> g_flat(down(g(b)))
f_flat(up(x_1)) -> up(f(x_1))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(209) SplitQDPProof (EQUIVALENT)
We show in the first subproof that some pairs and rules can be removed, afterwards, we continue with the remaining DP-Problem
----------------------------------------
(210)
Complex Obligation (AND)
----------------------------------------
(211)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
The TRS R consists of the following rules:
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
g_flat(up(x_1)) -> up(g(x_1))
down(g(g(b))) -> g_flat(down(g(b)))
f_flat(up(x_1)) -> up(f(x_1))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(g(fresh_constant)))) -> g_flat(down(f(g(fresh_constant))))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(212) SemLabProof (SOUND)
We found the following model for the rules of the TRSs R and P.
Interpretation over the domain with elements from 0 to 1.
a: 0
b: 0
down: 0
f: x0
fresh_constant: 1
up: 0
f_flat: 0
TOP: 0
g_flat: 0
g: x0
By semantic labelling [SEMLAB] we obtain the following labelled QDP problem.
----------------------------------------
(213)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.1(f.1(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.1(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.1(f.1(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.1(g.1(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.1(f.1(g.1(g.1(g.1(x0)))))) -> TOP.0(f_flat.0(down.1(g.1(g.1(g.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.1(g.1(f.1(f.1(f.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(f.1(f.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.1(g.1(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.1(f.1(g.1(g.1(f.1(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.1(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.1(g.1(g.1(g.1(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.1(f.1(f.1(f.1(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.1(g.1(f.1(g.1(g.1(y28))))) -> g_flat.0(down.1(f.1(g.1(g.1(y28)))))
down.1(g.1(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.1(g.1(f.1(f.1(g.1(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.1(g.1(f.1(g.1(f.1(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.1(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.1(f.1(g.1(f.1(y12)))) -> f_flat.0(down.1(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(214) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
down.1(f.1(g.1(g.1(f.1(x))))) -> up.0(b.)
down.1(g.1(g.1(g.1(x)))) -> up.0(b.)
down.1(f.1(f.1(f.1(x)))) -> up.0(b.)
down.1(g.1(f.1(f.1(g.1(x))))) -> up.0(b.)
down.1(g.1(f.1(g.1(f.1(x))))) -> up.0(b.)
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = x_1
POL(down.1(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(215)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.1(f.1(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.1(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.1(f.1(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.1(g.1(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.1(f.1(g.1(g.1(g.1(x0)))))) -> TOP.0(f_flat.0(down.1(g.1(g.1(g.1(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.1(g.1(f.1(f.1(f.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(f.1(f.1(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.1(g.1(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.1(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.1(g.1(f.1(g.1(g.1(y28))))) -> g_flat.0(down.1(f.1(g.1(g.1(y28)))))
down.1(g.1(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.1(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.1(f.1(g.1(f.1(y12)))) -> f_flat.0(down.1(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(216) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
----------------------------------------
(217)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.1(f.1(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.1(f.1(g.1(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.1(f.1(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.1(g.1(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
TOP.0(up.1(g.1(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(g.1(g.1(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.1(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.1(g.1(f.1(g.1(g.1(y28))))) -> g_flat.0(down.1(f.1(g.1(g.1(y28)))))
down.1(g.1(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.1(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.1(f.1(g.1(f.1(y12)))) -> f_flat.0(down.1(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(218) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:
TOP.0(up.1(f.1(f.1(g.1(x0))))) -> TOP.0(f_flat.0(down.1(f.1(g.1(x0)))))
TOP.0(up.1(f.1(g.1(f.1(x0))))) -> TOP.0(f_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.1(g.1(g.1(f.1(x0))))) -> TOP.0(g_flat.0(down.1(g.1(f.1(x0)))))
TOP.0(up.1(g.1(f.1(g.1(g.1(x0)))))) -> TOP.0(g_flat.0(down.1(f.1(g.1(g.1(x0))))))
Used ordering: Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 1 + x_1
POL(down.1(x_1)) = x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(fresh_constant.) = 0
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1 + x_1
POL(up.1(x_1)) = 1 + x_1
----------------------------------------
(219)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.1(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.1(g.1(f.1(g.1(g.1(y28))))) -> g_flat.0(down.1(f.1(g.1(g.1(y28)))))
down.1(g.1(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(g.1(fresh_constant.))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.1(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
down.1(f.1(g.1(f.1(y12)))) -> f_flat.0(down.1(g.1(f.1(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(220) UsableRulesReductionPairsProof (EQUIVALENT)
By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.
No dependency pairs are removed.
The following rules are removed from R:
down.1(f.1(g.1(g.1(g.1(y22))))) -> f_flat.0(down.1(g.1(g.1(g.1(y22)))))
down.1(g.1(f.1(g.1(g.1(y28))))) -> g_flat.0(down.1(f.1(g.1(g.1(y28)))))
down.1(g.1(f.1(g.1(fresh_constant.)))) -> g_flat.0(down.1(f.1(g.1(fresh_constant.))))
down.1(g.1(f.1(f.1(f.1(y24))))) -> g_flat.0(down.1(f.1(f.1(f.1(y24)))))
down.1(f.1(g.1(f.1(y12)))) -> f_flat.0(down.1(g.1(f.1(y12))))
Used ordering: POLO with Polynomial interpretation [POLO]:
POL(TOP.0(x_1)) = x_1
POL(a.) = 0
POL(b.) = 0
POL(down.0(x_1)) = 1 + x_1
POL(f.0(x_1)) = x_1
POL(f.1(x_1)) = x_1
POL(f_flat.0(x_1)) = x_1
POL(g.0(x_1)) = x_1
POL(g.1(x_1)) = x_1
POL(g_flat.0(x_1)) = x_1
POL(up.0(x_1)) = 1 + x_1
POL(up.1(x_1)) = x_1
----------------------------------------
(221)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP.0(up.0(f.0(f.0(g.0(x0))))) -> TOP.0(f_flat.0(down.0(f.0(g.0(x0)))))
TOP.0(up.0(f.0(g.0(f.0(x0))))) -> TOP.0(f_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(g.0(g.0(f.0(x0))))) -> TOP.0(g_flat.0(down.0(g.0(f.0(x0)))))
TOP.0(up.0(f.0(g.0(g.0(a.))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(a.)))))
TOP.0(up.0(f.0(g.0(g.0(g.0(x0)))))) -> TOP.0(f_flat.0(down.0(g.0(g.0(g.0(x0))))))
TOP.0(up.0(g.0(f.0(f.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(a.)))))
TOP.0(up.0(g.0(f.0(f.0(f.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(f.0(f.0(x0))))))
TOP.0(up.0(g.0(f.0(g.0(a.))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(a.)))))
TOP.0(up.0(g.0(f.0(g.0(g.0(x0)))))) -> TOP.0(g_flat.0(down.0(f.0(g.0(g.0(x0))))))
The TRS R consists of the following rules:
down.0(f.0(g.0(g.0(a.)))) -> f_flat.0(down.0(g.0(g.0(a.))))
down.0(f.0(g.0(g.0(f.0(x))))) -> up.0(b.)
down.0(f.0(g.0(g.0(g.0(y22))))) -> f_flat.0(down.0(g.0(g.0(g.0(y22)))))
down.0(f.0(g.0(g.0(b.)))) -> f_flat.0(down.0(g.0(g.0(b.))))
g_flat.0(up.0(x_1)) -> up.0(g.0(x_1))
g_flat.0(up.1(x_1)) -> up.1(g.1(x_1))
down.0(g.0(g.0(b.))) -> g_flat.0(down.0(g.0(b.)))
f_flat.0(up.0(x_1)) -> up.0(f.0(x_1))
f_flat.0(up.1(x_1)) -> up.1(f.1(x_1))
down.0(g.0(g.0(g.0(x)))) -> up.0(b.)
down.0(g.0(g.0(a.))) -> g_flat.0(down.0(g.0(a.)))
down.0(g.0(a.)) -> g_flat.0(down.0(a.))
down.0(a.) -> up.0(f.0(a.))
down.0(a.) -> up.0(g.0(a.))
down.0(f.0(g.0(a.))) -> f_flat.0(down.0(g.0(a.)))
down.0(f.0(f.0(f.0(x)))) -> up.0(b.)
down.0(f.0(f.0(a.))) -> f_flat.0(down.0(f.0(a.)))
down.0(f.0(a.)) -> f_flat.0(down.0(a.))
down.0(g.0(f.0(g.0(g.0(y28))))) -> g_flat.0(down.0(f.0(g.0(g.0(y28)))))
down.0(g.0(f.0(a.))) -> g_flat.0(down.0(f.0(a.)))
down.0(g.0(f.0(f.0(g.0(x))))) -> up.0(b.)
down.0(g.0(f.0(g.0(f.0(x))))) -> up.0(b.)
down.0(g.0(f.0(b.))) -> g_flat.0(down.0(f.0(b.)))
down.0(g.0(f.0(f.0(a.)))) -> g_flat.0(down.0(f.0(f.0(a.))))
down.0(g.0(f.0(f.0(f.0(y24))))) -> g_flat.0(down.0(f.0(f.0(f.0(y24)))))
down.0(g.0(f.0(f.0(b.)))) -> g_flat.0(down.0(f.0(f.0(b.))))
down.0(g.0(f.0(g.0(a.)))) -> g_flat.0(down.0(f.0(g.0(a.))))
down.0(g.0(f.0(g.0(b.)))) -> g_flat.0(down.0(f.0(g.0(b.))))
down.0(f.0(g.0(b.))) -> f_flat.0(down.0(g.0(b.)))
down.0(f.0(f.0(b.))) -> f_flat.0(down.0(f.0(b.)))
down.0(f.0(g.0(f.0(y12)))) -> f_flat.0(down.0(g.0(f.0(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------
(222) PisEmptyProof (SOUND)
The TRS P is empty. Hence, there is no (P,Q,R) chain.
----------------------------------------
(223)
TRUE
----------------------------------------
(224)
Obligation:
Q DP problem:
The TRS P consists of the following rules:
TOP(up(f(f(g(x0))))) -> TOP(f_flat(down(f(g(x0)))))
TOP(up(f(g(f(x0))))) -> TOP(f_flat(down(g(f(x0)))))
TOP(up(g(g(f(x0))))) -> TOP(g_flat(down(g(f(x0)))))
TOP(up(f(g(g(a))))) -> TOP(f_flat(down(g(g(a)))))
TOP(up(f(g(g(g(x0)))))) -> TOP(f_flat(down(g(g(g(x0))))))
TOP(up(g(f(f(a))))) -> TOP(g_flat(down(f(f(a)))))
TOP(up(g(f(f(f(x0)))))) -> TOP(g_flat(down(f(f(f(x0))))))
TOP(up(g(f(g(a))))) -> TOP(g_flat(down(f(g(a)))))
TOP(up(g(f(g(g(x0)))))) -> TOP(g_flat(down(f(g(g(x0))))))
The TRS R consists of the following rules:
down(f(g(g(a)))) -> f_flat(down(g(g(a))))
down(f(g(g(f(x))))) -> up(b)
down(f(g(g(g(y22))))) -> f_flat(down(g(g(g(y22)))))
down(f(g(g(b)))) -> f_flat(down(g(g(b))))
g_flat(up(x_1)) -> up(g(x_1))
down(g(g(b))) -> g_flat(down(g(b)))
f_flat(up(x_1)) -> up(f(x_1))
down(g(g(g(x)))) -> up(b)
down(g(g(a))) -> g_flat(down(g(a)))
down(g(a)) -> g_flat(down(a))
down(a) -> up(f(a))
down(a) -> up(g(a))
down(f(g(a))) -> f_flat(down(g(a)))
down(f(f(f(x)))) -> up(b)
down(f(f(a))) -> f_flat(down(f(a)))
down(f(a)) -> f_flat(down(a))
down(g(f(g(g(y28))))) -> g_flat(down(f(g(g(y28)))))
down(g(f(a))) -> g_flat(down(f(a)))
down(g(f(f(g(x))))) -> up(b)
down(g(f(g(f(x))))) -> up(b)
down(g(f(b))) -> g_flat(down(f(b)))
down(g(f(f(a)))) -> g_flat(down(f(f(a))))
down(g(f(f(f(y24))))) -> g_flat(down(f(f(f(y24)))))
down(g(f(f(b)))) -> g_flat(down(f(f(b))))
down(g(f(g(a)))) -> g_flat(down(f(g(a))))
down(g(f(g(b)))) -> g_flat(down(f(g(b))))
down(f(g(b))) -> f_flat(down(g(b)))
down(f(f(b))) -> f_flat(down(f(b)))
down(f(g(f(y12)))) -> f_flat(down(g(f(y12))))
Q is empty.
We have to consider all minimal (P,Q,R)-chains.