MAYBE

Found an example we currently can't prove?
-> Consider contributing it to the benchmark set: https://mysolvertimesout.org/

proof of /hpcwork/ff862203/termcomp26/benchmarks/iYRFQ.pl
# AProVE Commit ID: 23a904c96b029b0a549cde0d0d17dbccf967db59 jckassing 20260626 unpublished dirty


Left Termination of the query pattern

p(a,g)

w.r.t. the given Prolog program could not be shown:

(0) Prolog
(1) PrologToPiTRSProof [SOUND, 0 ms]
(2) PiTRS
    (3) DependencyPairsProof [EQUIVALENT, 0 ms]
    (4) PiDP
    (5) DependencyGraphProof [EQUIVALENT, 0 ms]
    (6) PiDP
    (7) UsableRulesProof [EQUIVALENT, 0 ms]
    (8) PiDP
    (9) PiDPToQDPProof [SOUND, 0 ms]
    (10) QDP
    (11) TransformationProof [EQUIVALENT, 0 ms]
    (12) QDP
    (13) TransformationProof [EQUIVALENT, 0 ms]
    (14) QDP
    (15) NonTerminationLoopProof [COMPLETE, 0 ms]
    (16) NO
(17) PrologToPiTRSProof [SOUND, 0 ms]
(18) PiTRS
    (19) DependencyPairsProof [EQUIVALENT, 0 ms]
    (20) PiDP
    (21) DependencyGraphProof [EQUIVALENT, 0 ms]
    (22) PiDP
    (23) UsableRulesProof [EQUIVALENT, 0 ms]
    (24) PiDP
    (25) PiDPToQDPProof [SOUND, 0 ms]
    (26) QDP
    (27) TransformationProof [EQUIVALENT, 0 ms]
    (28) QDP
    (29) TransformationProof [EQUIVALENT, 0 ms]
    (30) QDP
    (31) NonTerminationLoopProof [COMPLETE, 0 ms]
    (32) NO
(33) PrologToTRSTransformerProof [SOUND, 0 ms]
(34) QTRS
    (35) Overlay + Local Confluence [EQUIVALENT, 0 ms]
    (36) QTRS
    (37) DependencyPairsProof [EQUIVALENT, 0 ms]
    (38) QDP
    (39) DependencyGraphProof [EQUIVALENT, 0 ms]
    (40) QDP
    (41) UsableRulesProof [EQUIVALENT, 0 ms]
    (42) QDP
    (43) QReductionProof [EQUIVALENT, 0 ms]
    (44) QDP
    (45) TransformationProof [EQUIVALENT, 0 ms]
    (46) QDP
    (47) TransformationProof [EQUIVALENT, 0 ms]
    (48) QDP
    (49) NonTerminationLoopProof [COMPLETE, 0 ms]
    (50) NO
(51) PrologToDTProblemTransformerProof [SOUND, 0 ms]
(52) TRIPLES
    (53) TriplesToPiDPProof [SOUND, 0 ms]
    (54) PiDP
    (55) DependencyGraphProof [EQUIVALENT, 0 ms]
    (56) PiDP
    (57) PiDPToQDPProof [SOUND, 0 ms]
    (58) QDP
    (59) TransformationProof [EQUIVALENT, 0 ms]
    (60) QDP
    (61) TransformationProof [EQUIVALENT, 0 ms]
    (62) QDP
    (63) NonTerminationLoopProof [COMPLETE, 0 ms]
    (64) NO
(65) PrologToIRSwTTransformerProof [SOUND, 0 ms]
(66) IRSwT
    (67) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms]
    (68) IRSwT
    (69) IntTRSCompressionProof [EQUIVALENT, 21 ms]
    (70) IRSwT
    (71) IRSFormatTransformerProof [EQUIVALENT, 0 ms]
    (72) IRSwT
    (73) IRSwTTerminationDigraphProof [EQUIVALENT, 4 ms]
    (74) IRSwT


----------------------------------------

(0)
Obligation:
Clauses:

p(s(X), Y) :- p(X, s(Y)).


Query: p(a,g)
----------------------------------------

(1) PrologToPiTRSProof (SOUND)
We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes:

p_in_2: (f,b)

Transforming Prolog into the following Term Rewriting System:

Pi-finite rewrite system:
The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x3)

p_out_ag(x1, x2)  =  p_out_ag(x1)

s(x1)  =  s(x1)





Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



----------------------------------------

(2)
Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x3)

p_out_ag(x1, x2)  =  p_out_ag(x1)

s(x1)  =  s(x1)



----------------------------------------

(3) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> U1_AG(X, Y, p_in_ag(X, s(Y)))
   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x3)

p_out_ag(x1, x2)  =  p_out_ag(x1)

s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)

U1_AG(x1, x2, x3)  =  U1_AG(x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(4)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> U1_AG(X, Y, p_in_ag(X, s(Y)))
   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x3)

p_out_ag(x1, x2)  =  p_out_ag(x1)

s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)

U1_AG(x1, x2, x3)  =  U1_AG(x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(5) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LOPSTR] contains 1 SCC with 1 less node.
----------------------------------------

(6)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x3)

p_out_ag(x1, x2)  =  p_out_ag(x1)

s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(7) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(8)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

R is empty.
The argument filtering Pi contains the following mapping:
s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(9) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(10)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   P_IN_AG(Y) -> P_IN_AG(s(Y))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(11) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule P_IN_AG(Y) -> P_IN_AG(s(Y)) we obtained the following new rules [LPAR04]:

   (P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0))),P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0))))


----------------------------------------

(12)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0)))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(13) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0))) we obtained the following new rules [LPAR04]:

   (P_IN_AG(s(s(z0))) -> P_IN_AG(s(s(s(z0)))),P_IN_AG(s(s(z0))) -> P_IN_AG(s(s(s(z0)))))


----------------------------------------

(14)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(s(z0))) -> P_IN_AG(s(s(s(z0))))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(15) 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 = P_IN_AG(s(s(z0))) evaluates to  t =P_IN_AG(s(s(s(z0))))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
* Matcher: [z0 / s(z0)]
* Semiunifier: [ ]

--------------------------------------------------------------------------------
Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from P_IN_AG(s(s(z0))) to P_IN_AG(s(s(s(z0)))).




----------------------------------------

(16)
NO

----------------------------------------

(17) PrologToPiTRSProof (SOUND)
We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes:

p_in_2: (f,b)

Transforming Prolog into the following Term Rewriting System:

Pi-finite rewrite system:
The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x2, x3)

p_out_ag(x1, x2)  =  p_out_ag(x1, x2)

s(x1)  =  s(x1)





Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



----------------------------------------

(18)
Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x2, x3)

p_out_ag(x1, x2)  =  p_out_ag(x1, x2)

s(x1)  =  s(x1)



----------------------------------------

(19) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> U1_AG(X, Y, p_in_ag(X, s(Y)))
   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x2, x3)

p_out_ag(x1, x2)  =  p_out_ag(x1, x2)

s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)

U1_AG(x1, x2, x3)  =  U1_AG(x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(20)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> U1_AG(X, Y, p_in_ag(X, s(Y)))
   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x2, x3)

p_out_ag(x1, x2)  =  p_out_ag(x1, x2)

s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)

U1_AG(x1, x2, x3)  =  U1_AG(x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(21) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LOPSTR] contains 1 SCC with 1 less node.
----------------------------------------

(22)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

The TRS R consists of the following rules:

   p_in_ag(s(X), Y) -> U1_ag(X, Y, p_in_ag(X, s(Y)))
   U1_ag(X, Y, p_out_ag(X, s(Y))) -> p_out_ag(s(X), Y)

The argument filtering Pi contains the following mapping:
p_in_ag(x1, x2)  =  p_in_ag(x2)

U1_ag(x1, x2, x3)  =  U1_ag(x2, x3)

p_out_ag(x1, x2)  =  p_out_ag(x1, x2)

s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(23) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(24)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(X), Y) -> P_IN_AG(X, s(Y))

R is empty.
The argument filtering Pi contains the following mapping:
s(x1)  =  s(x1)

P_IN_AG(x1, x2)  =  P_IN_AG(x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(25) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(26)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   P_IN_AG(Y) -> P_IN_AG(s(Y))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(27) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule P_IN_AG(Y) -> P_IN_AG(s(Y)) we obtained the following new rules [LPAR04]:

   (P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0))),P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0))))


----------------------------------------

(28)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0)))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(29) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule P_IN_AG(s(z0)) -> P_IN_AG(s(s(z0))) we obtained the following new rules [LPAR04]:

   (P_IN_AG(s(s(z0))) -> P_IN_AG(s(s(s(z0)))),P_IN_AG(s(s(z0))) -> P_IN_AG(s(s(s(z0)))))


----------------------------------------

(30)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   P_IN_AG(s(s(z0))) -> P_IN_AG(s(s(s(z0))))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(31) 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 = P_IN_AG(s(s(z0))) evaluates to  t =P_IN_AG(s(s(s(z0))))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
* Matcher: [z0 / s(z0)]
* Semiunifier: [ ]

--------------------------------------------------------------------------------
Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from P_IN_AG(s(s(z0))) to P_IN_AG(s(s(s(z0)))).




----------------------------------------

(32)
NO

----------------------------------------

(33) PrologToTRSTransformerProof (SOUND)
Transformed Prolog program to TRS.

{
    "root": 1,
    "program": {
        "directives": [],
        "clauses": [[
            "(p (s X) Y)",
            "(p X (s Y))"
        ]]
    },
    "graph": {
        "nodes": {
            "44": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "1": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T2"],
                    "free": [],
                    "exprvars": []
                }
            },
            "5": {
                "goal": [{
                    "clause": 0,
                    "scope": 1,
                    "term": "(p T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T2"],
                    "free": [],
                    "exprvars": []
                }
            },
            "type": "Nodes",
            "43": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p T9 (s T8))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T8"],
                    "free": [],
                    "exprvars": []
                }
            }
        },
        "edges": [
            {
                "from": 1,
                "to": 5,
                "label": "CASE"
            },
            {
                "from": 5,
                "to": 43,
                "label": "EVAL with clause\np(s(X5), X6) :- p(X5, s(X6)).\nand substitutionX5 -> T9,\nT1 -> s(T9),\nT2 -> T8,\nX6 -> T8,\nT7 -> T9"
            },
            {
                "from": 5,
                "to": 44,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 43,
                "to": 1,
                "label": "INSTANCE with matching:\nT1 -> T9\nT2 -> s(T8)"
            }
        ],
        "type": "Graph"
    }
}

----------------------------------------

(34)
Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:

   f1_in(T8) -> U1(f1_in(s(T8)), T8)
   U1(f1_out1(T9), T8) -> f1_out1(s(T9))

Q is empty.

----------------------------------------

(35) Overlay + Local Confluence (EQUIVALENT)
The TRS is overlay and locally confluent. By [NOC] we can switch to innermost.
----------------------------------------

(36)
Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:

   f1_in(T8) -> U1(f1_in(s(T8)), T8)
   U1(f1_out1(T9), T8) -> f1_out1(s(T9))

The set Q consists of the following terms:

   f1_in(x0)
   U1(f1_out1(x0), x1)


----------------------------------------

(37) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.
----------------------------------------

(38)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   F1_IN(T8) -> U1^1(f1_in(s(T8)), T8)
   F1_IN(T8) -> F1_IN(s(T8))

The TRS R consists of the following rules:

   f1_in(T8) -> U1(f1_in(s(T8)), T8)
   U1(f1_out1(T9), T8) -> f1_out1(s(T9))

The set Q consists of the following terms:

   f1_in(x0)
   U1(f1_out1(x0), x1)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(39) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(40)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   F1_IN(T8) -> F1_IN(s(T8))

The TRS R consists of the following rules:

   f1_in(T8) -> U1(f1_in(s(T8)), T8)
   U1(f1_out1(T9), T8) -> f1_out1(s(T9))

The set Q consists of the following terms:

   f1_in(x0)
   U1(f1_out1(x0), x1)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(41) 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.
----------------------------------------

(42)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   F1_IN(T8) -> F1_IN(s(T8))

R is empty.
The set Q consists of the following terms:

   f1_in(x0)
   U1(f1_out1(x0), x1)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(43) 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].

   f1_in(x0)
   U1(f1_out1(x0), x1)


----------------------------------------

(44)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   F1_IN(T8) -> F1_IN(s(T8))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(45) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule F1_IN(T8) -> F1_IN(s(T8)) we obtained the following new rules [LPAR04]:

   (F1_IN(s(z0)) -> F1_IN(s(s(z0))),F1_IN(s(z0)) -> F1_IN(s(s(z0))))


----------------------------------------

(46)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   F1_IN(s(z0)) -> F1_IN(s(s(z0)))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(47) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule F1_IN(s(z0)) -> F1_IN(s(s(z0))) we obtained the following new rules [LPAR04]:

   (F1_IN(s(s(z0))) -> F1_IN(s(s(s(z0)))),F1_IN(s(s(z0))) -> F1_IN(s(s(s(z0)))))


----------------------------------------

(48)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   F1_IN(s(s(z0))) -> F1_IN(s(s(s(z0))))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(49) 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 = F1_IN(s(s(z0))) evaluates to  t =F1_IN(s(s(s(z0))))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
* Matcher: [z0 / s(z0)]
* Semiunifier: [ ]

--------------------------------------------------------------------------------
Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from F1_IN(s(s(z0))) to F1_IN(s(s(s(z0)))).




----------------------------------------

(50)
NO

----------------------------------------

(51) PrologToDTProblemTransformerProof (SOUND)
Built DT problem from termination graph DT10.

{
    "root": 3,
    "program": {
        "directives": [],
        "clauses": [[
            "(p (s X) Y)",
            "(p X (s Y))"
        ]]
    },
    "graph": {
        "nodes": {
            "56": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p T14 (s (s T13)))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T13"],
                    "free": [],
                    "exprvars": []
                }
            },
            "57": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "3": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T2"],
                    "free": [],
                    "exprvars": []
                }
            },
            "4": {
                "goal": [{
                    "clause": 0,
                    "scope": 1,
                    "term": "(p T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T2"],
                    "free": [],
                    "exprvars": []
                }
            },
            "49": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p T7 (s T6))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T6"],
                    "free": [],
                    "exprvars": []
                }
            },
            "type": "Nodes",
            "51": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "53": {
                "goal": [{
                    "clause": 0,
                    "scope": 2,
                    "term": "(p T7 (s T6))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T6"],
                    "free": [],
                    "exprvars": []
                }
            }
        },
        "edges": [
            {
                "from": 3,
                "to": 4,
                "label": "CASE"
            },
            {
                "from": 4,
                "to": 49,
                "label": "EVAL with clause\np(s(X3), X4) :- p(X3, s(X4)).\nand substitutionX3 -> T7,\nT1 -> s(T7),\nT2 -> T6,\nX4 -> T6,\nT5 -> T7"
            },
            {
                "from": 4,
                "to": 51,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 49,
                "to": 53,
                "label": "CASE"
            },
            {
                "from": 53,
                "to": 56,
                "label": "EVAL with clause\np(s(X9), X10) :- p(X9, s(X10)).\nand substitutionX9 -> T14,\nT7 -> s(T14),\nT6 -> T13,\nX10 -> s(T13),\nT12 -> T14"
            },
            {
                "from": 53,
                "to": 57,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 56,
                "to": 3,
                "label": "INSTANCE with matching:\nT1 -> T14\nT2 -> s(s(T13))"
            }
        ],
        "type": "Graph"
    }
}

----------------------------------------

(52)
Obligation:
Triples:

pA(s(s(X1)), X2) :- pA(X1, s(s(X2))).

Clauses:

pcA(s(s(X1)), X2) :- pcA(X1, s(s(X2))).

Afs:

pA(x1, x2)  =  pA(x2)


----------------------------------------

(53) TriplesToPiDPProof (SOUND)
We use the technique of [DT09]. With regard to the inferred argument filtering the predicates were used in the following modes:

pA_in_2: (f,b)

Transforming TRIPLES into the following Term Rewriting System:

Pi DP problem:
The TRS P consists of the following rules:

   PA_IN_AG(s(s(X1)), X2) -> U1_AG(X1, X2, pA_in_ag(X1, s(s(X2))))
   PA_IN_AG(s(s(X1)), X2) -> PA_IN_AG(X1, s(s(X2)))

R is empty.
The argument filtering Pi contains the following mapping:
pA_in_ag(x1, x2)  =  pA_in_ag(x2)

s(x1)  =  s(x1)

PA_IN_AG(x1, x2)  =  PA_IN_AG(x2)

U1_AG(x1, x2, x3)  =  U1_AG(x2, x3)


We have to consider all (P,R,Pi)-chains


Infinitary Constructor Rewriting Termination of PiDP implies Termination of TRIPLES



----------------------------------------

(54)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   PA_IN_AG(s(s(X1)), X2) -> U1_AG(X1, X2, pA_in_ag(X1, s(s(X2))))
   PA_IN_AG(s(s(X1)), X2) -> PA_IN_AG(X1, s(s(X2)))

R is empty.
The argument filtering Pi contains the following mapping:
pA_in_ag(x1, x2)  =  pA_in_ag(x2)

s(x1)  =  s(x1)

PA_IN_AG(x1, x2)  =  PA_IN_AG(x2)

U1_AG(x1, x2, x3)  =  U1_AG(x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(55) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LOPSTR] contains 1 SCC with 1 less node.
----------------------------------------

(56)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   PA_IN_AG(s(s(X1)), X2) -> PA_IN_AG(X1, s(s(X2)))

R is empty.
The argument filtering Pi contains the following mapping:
s(x1)  =  s(x1)

PA_IN_AG(x1, x2)  =  PA_IN_AG(x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(57) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(58)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   PA_IN_AG(X2) -> PA_IN_AG(s(s(X2)))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(59) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule PA_IN_AG(X2) -> PA_IN_AG(s(s(X2))) we obtained the following new rules [LPAR04]:

   (PA_IN_AG(s(s(z0))) -> PA_IN_AG(s(s(s(s(z0))))),PA_IN_AG(s(s(z0))) -> PA_IN_AG(s(s(s(s(z0))))))


----------------------------------------

(60)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   PA_IN_AG(s(s(z0))) -> PA_IN_AG(s(s(s(s(z0)))))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(61) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule PA_IN_AG(s(s(z0))) -> PA_IN_AG(s(s(s(s(z0))))) we obtained the following new rules [LPAR04]:

   (PA_IN_AG(s(s(s(s(z0))))) -> PA_IN_AG(s(s(s(s(s(s(z0))))))),PA_IN_AG(s(s(s(s(z0))))) -> PA_IN_AG(s(s(s(s(s(s(z0))))))))


----------------------------------------

(62)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   PA_IN_AG(s(s(s(s(z0))))) -> PA_IN_AG(s(s(s(s(s(s(z0)))))))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(63) 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 = PA_IN_AG(s(s(s(s(z0))))) evaluates to  t =PA_IN_AG(s(s(s(s(s(s(z0)))))))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
* Matcher: [z0 / s(s(z0))]
* Semiunifier: [ ]

--------------------------------------------------------------------------------
Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from PA_IN_AG(s(s(s(s(z0))))) to PA_IN_AG(s(s(s(s(s(s(z0))))))).




----------------------------------------

(64)
NO

----------------------------------------

(65) PrologToIRSwTTransformerProof (SOUND)
Transformed Prolog program to IRSwT according to method in Master Thesis of A. Weinert

{
    "root": 2,
    "program": {
        "directives": [],
        "clauses": [[
            "(p (s X) Y)",
            "(p X (s Y))"
        ]]
    },
    "graph": {
        "nodes": {
            "55": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "2": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T2"],
                    "free": [],
                    "exprvars": []
                }
            },
            "6": {
                "goal": [{
                    "clause": 0,
                    "scope": 1,
                    "term": "(p T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T2"],
                    "free": [],
                    "exprvars": []
                }
            },
            "type": "Nodes",
            "54": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p T9 (s T8))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T8"],
                    "free": [],
                    "exprvars": []
                }
            }
        },
        "edges": [
            {
                "from": 2,
                "to": 6,
                "label": "CASE"
            },
            {
                "from": 6,
                "to": 54,
                "label": "EVAL with clause\np(s(X5), X6) :- p(X5, s(X6)).\nand substitutionX5 -> T9,\nT1 -> s(T9),\nT2 -> T8,\nX6 -> T8,\nT7 -> T9"
            },
            {
                "from": 6,
                "to": 55,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 54,
                "to": 2,
                "label": "INSTANCE with matching:\nT1 -> T9\nT2 -> s(T8)"
            }
        ],
        "type": "Graph"
    }
}

----------------------------------------

(66)
Obligation:
Rules:
f6_in(T2) -> f55_in :|: TRUE
f55_out -> f6_out(x) :|: TRUE
f54_out(T8) -> f6_out(T8) :|: TRUE
f6_in(x1) -> f54_in(x1) :|: TRUE
f54_in(x2) -> f2_in(s(x2)) :|: TRUE
f2_out(s(x3)) -> f54_out(x3) :|: TRUE
f2_in(x4) -> f6_in(x4) :|: TRUE
f6_out(x5) -> f2_out(x5) :|: TRUE
Start term: f2_in(T2)

----------------------------------------

(67) IRSwTSimpleDependencyGraphProof (EQUIVALENT)
Constructed simple dependency graph.

Simplified to the following IRSwTs:

intTRSProblem:
f6_in(x1) -> f54_in(x1) :|: TRUE
f54_in(x2) -> f2_in(s(x2)) :|: TRUE
f2_in(x4) -> f6_in(x4) :|: TRUE


----------------------------------------

(68)
Obligation:
Rules:
f6_in(x1) -> f54_in(x1) :|: TRUE
f54_in(x2) -> f2_in(s(x2)) :|: TRUE
f2_in(x4) -> f6_in(x4) :|: TRUE

----------------------------------------

(69) IntTRSCompressionProof (EQUIVALENT)
Compressed rules.
----------------------------------------

(70)
Obligation:
Rules:
f6_in(x1:0) -> f6_in(s(x1:0)) :|: TRUE

----------------------------------------

(71) IRSFormatTransformerProof (EQUIVALENT)
Reformatted IRS to match normalized format (transformed away non-linear left-hand sides, !=, / and %).
----------------------------------------

(72)
Obligation:
Rules:
f6_in(x1:0) -> f6_in(s(x1:0)) :|: TRUE

----------------------------------------

(73) IRSwTTerminationDigraphProof (EQUIVALENT)
Constructed termination digraph!
Nodes:
(1) f6_in(x1:0) -> f6_in(s(x1:0)) :|: TRUE

Arcs:
(1) -> (1)

This digraph is fully evaluated!
----------------------------------------

(74)
Obligation:

Termination digraph:
Nodes:
(1) f6_in(x1:0) -> f6_in(s(x1:0)) :|: TRUE

Arcs:
(1) -> (1)

This digraph is fully evaluated!
