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/38vbx.pl
# AProVE Commit ID: 23a904c96b029b0a549cde0d0d17dbccf967db59 jckassing 20260626 unpublished dirty


Left Termination of the query pattern

p2(a)

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) PrologToTRSTransformerProof [SOUND, 0 ms]
(12) QTRS
    (13) QTRSRRRProof [EQUIVALENT, 24 ms]
    (14) QTRS
    (15) Overlay + Local Confluence [EQUIVALENT, 0 ms]
    (16) QTRS
    (17) DependencyPairsProof [EQUIVALENT, 0 ms]
    (18) QDP
    (19) UsableRulesProof [EQUIVALENT, 0 ms]
    (20) QDP
    (21) QReductionProof [EQUIVALENT, 0 ms]
    (22) QDP
(23) PrologToPiTRSProof [SOUND, 0 ms]
(24) PiTRS
    (25) DependencyPairsProof [EQUIVALENT, 0 ms]
    (26) PiDP
    (27) DependencyGraphProof [EQUIVALENT, 0 ms]
    (28) PiDP
    (29) UsableRulesProof [EQUIVALENT, 0 ms]
    (30) PiDP
    (31) PiDPToQDPProof [SOUND, 0 ms]
    (32) QDP
(33) PrologToDTProblemTransformerProof [SOUND, 0 ms]
(34) TRIPLES
    (35) TriplesToPiDPProof [SOUND, 0 ms]
    (36) PiDP
    (37) DependencyGraphProof [EQUIVALENT, 0 ms]
    (38) PiDP
    (39) PiDPToQDPProof [SOUND, 0 ms]
    (40) QDP
(41) PrologToIRSwTTransformerProof [SOUND, 0 ms]
(42) IRSwT
    (43) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms]
    (44) IRSwT
    (45) IntTRSCompressionProof [EQUIVALENT, 16 ms]
    (46) IRSwT
    (47) IRSFormatTransformerProof [EQUIVALENT, 0 ms]
    (48) IRSwT
    (49) IRSwTTerminationDigraphProof [EQUIVALENT, 0 ms]
    (50) IRSwT
    (51) FilterProof [EQUIVALENT, 0 ms]
    (52) IntTRS
    (53) IntTRSPeriodicNontermProof [COMPLETE, 2 ms]
    (54) NO


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

(0)
Obligation:
Clauses:

p1(f(X)) :- p1(X).
p2(f(X)) :- p2(X).


Query: p2(a)
----------------------------------------

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

p2_in_1: (f)

Transforming Prolog into the following Term Rewriting System:

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

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(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:

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(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:

   P2_IN_A(f(X)) -> U2_A(X, p2_in_a(X))
   P2_IN_A(f(X)) -> P2_IN_A(X)

The TRS R consists of the following rules:

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)

P2_IN_A(x1)  =  P2_IN_A

U2_A(x1, x2)  =  U2_A(x2)


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

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

   P2_IN_A(f(X)) -> U2_A(X, p2_in_a(X))
   P2_IN_A(f(X)) -> P2_IN_A(X)

The TRS R consists of the following rules:

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)

P2_IN_A(x1)  =  P2_IN_A

U2_A(x1, x2)  =  U2_A(x2)


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:

   P2_IN_A(f(X)) -> P2_IN_A(X)

The TRS R consists of the following rules:

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)

P2_IN_A(x1)  =  P2_IN_A


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:

   P2_IN_A(f(X)) -> P2_IN_A(X)

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

P2_IN_A(x1)  =  P2_IN_A


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:

   P2_IN_A -> P2_IN_A

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

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

{
    "root": 1,
    "program": {
        "directives": [],
        "clauses": [
            [
                "(p1 (f X))",
                "(p1 X)"
            ],
            [
                "(p2 (f X))",
                "(p2 X)"
            ]
        ]
    },
    "graph": {
        "nodes": {
            "1": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p2 T1)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "13": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p2 T5)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "15": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "5": {
                "goal": [{
                    "clause": 1,
                    "scope": 1,
                    "term": "(p2 T1)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "type": "Nodes"
        },
        "edges": [
            {
                "from": 1,
                "to": 5,
                "label": "CASE"
            },
            {
                "from": 5,
                "to": 13,
                "label": "EVAL with clause\np2(f(X3)) :- p2(X3).\nand substitutionX3 -> T5,\nT1 -> f(T5),\nT4 -> T5"
            },
            {
                "from": 5,
                "to": 15,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 13,
                "to": 1,
                "label": "INSTANCE with matching:\nT1 -> T5"
            }
        ],
        "type": "Graph"
    }
}

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

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

   f1_in -> U1(f1_in)
   U1(f1_out1(T5)) -> f1_out1(f(T5))

Q is empty.

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

(13) QTRSRRRProof (EQUIVALENT)
Used ordering:
Polynomial interpretation [POLO]:

   POL(U1(x_1)) = 2*x_1
   POL(f(x_1)) = x_1
   POL(f1_in) = 0
   POL(f1_out1(x_1)) = 2 + x_1
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

   U1(f1_out1(T5)) -> f1_out1(f(T5))




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

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

   f1_in -> U1(f1_in)

Q is empty.

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

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

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

   f1_in -> U1(f1_in)

The set Q consists of the following terms:

   f1_in


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

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

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

   F1_IN -> F1_IN

The TRS R consists of the following rules:

   f1_in -> U1(f1_in)

The set Q consists of the following terms:

   f1_in

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

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

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

   F1_IN -> F1_IN

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

   f1_in

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

(21) 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


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

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

   F1_IN -> F1_IN

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

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

p2_in_1: (f)

Transforming Prolog into the following Term Rewriting System:

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

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)





Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



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

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

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)



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

(25) 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:

   P2_IN_A(f(X)) -> U2_A(X, p2_in_a(X))
   P2_IN_A(f(X)) -> P2_IN_A(X)

The TRS R consists of the following rules:

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)

P2_IN_A(x1)  =  P2_IN_A

U2_A(x1, x2)  =  U2_A(x2)


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

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

   P2_IN_A(f(X)) -> U2_A(X, p2_in_a(X))
   P2_IN_A(f(X)) -> P2_IN_A(X)

The TRS R consists of the following rules:

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)

P2_IN_A(x1)  =  P2_IN_A

U2_A(x1, x2)  =  U2_A(x2)


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

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

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

   P2_IN_A(f(X)) -> P2_IN_A(X)

The TRS R consists of the following rules:

   p2_in_a(f(X)) -> U2_a(X, p2_in_a(X))
   U2_a(X, p2_out_a(X)) -> p2_out_a(f(X))

The argument filtering Pi contains the following mapping:
p2_in_a(x1)  =  p2_in_a

U2_a(x1, x2)  =  U2_a(x2)

p2_out_a(x1)  =  p2_out_a(x1)

f(x1)  =  f(x1)

P2_IN_A(x1)  =  P2_IN_A


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

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

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

   P2_IN_A(f(X)) -> P2_IN_A(X)

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

P2_IN_A(x1)  =  P2_IN_A


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

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

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

   P2_IN_A -> P2_IN_A

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

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

{
    "root": 2,
    "program": {
        "directives": [],
        "clauses": [
            [
                "(p1 (f X))",
                "(p1 X)"
            ],
            [
                "(p2 (f X))",
                "(p2 X)"
            ]
        ]
    },
    "graph": {
        "nodes": {
            "2": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p2 T1)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "35": {
                "goal": [{
                    "clause": 1,
                    "scope": 2,
                    "term": "(p2 T4)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "14": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p2 T4)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "36": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p2 T8)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "4": {
                "goal": [{
                    "clause": 1,
                    "scope": 1,
                    "term": "(p2 T1)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "26": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "37": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "type": "Nodes"
        },
        "edges": [
            {
                "from": 2,
                "to": 4,
                "label": "CASE"
            },
            {
                "from": 4,
                "to": 14,
                "label": "EVAL with clause\np2(f(X2)) :- p2(X2).\nand substitutionX2 -> T4,\nT1 -> f(T4),\nT3 -> T4"
            },
            {
                "from": 4,
                "to": 26,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 14,
                "to": 35,
                "label": "CASE"
            },
            {
                "from": 35,
                "to": 36,
                "label": "EVAL with clause\np2(f(X5)) :- p2(X5).\nand substitutionX5 -> T8,\nT4 -> f(T8),\nT7 -> T8"
            },
            {
                "from": 35,
                "to": 37,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 36,
                "to": 2,
                "label": "INSTANCE with matching:\nT1 -> T8"
            }
        ],
        "type": "Graph"
    }
}

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

(34)
Obligation:
Triples:

p2A(f(f(X1))) :- p2A(X1).

Clauses:

p2cA(f(f(X1))) :- p2cA(X1).

Afs:

p2A(x1)  =  p2A


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

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

p2A_in_1: (f)

Transforming TRIPLES into the following Term Rewriting System:

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

   P2A_IN_A(f(f(X1))) -> U1_A(X1, p2A_in_a(X1))
   P2A_IN_A(f(f(X1))) -> P2A_IN_A(X1)

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

f(x1)  =  f(x1)

P2A_IN_A(x1)  =  P2A_IN_A

U1_A(x1, x2)  =  U1_A(x2)


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


Infinitary Constructor Rewriting Termination of PiDP implies Termination of TRIPLES



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

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

   P2A_IN_A(f(f(X1))) -> U1_A(X1, p2A_in_a(X1))
   P2A_IN_A(f(f(X1))) -> P2A_IN_A(X1)

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

f(x1)  =  f(x1)

P2A_IN_A(x1)  =  P2A_IN_A

U1_A(x1, x2)  =  U1_A(x2)


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

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

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

   P2A_IN_A(f(f(X1))) -> P2A_IN_A(X1)

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

P2A_IN_A(x1)  =  P2A_IN_A


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

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

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

   P2A_IN_A -> P2A_IN_A

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

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

{
    "root": 3,
    "program": {
        "directives": [],
        "clauses": [
            [
                "(p1 (f X))",
                "(p1 X)"
            ],
            [
                "(p2 (f X))",
                "(p2 X)"
            ]
        ]
    },
    "graph": {
        "nodes": {
            "3": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p2 T1)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "6": {
                "goal": [{
                    "clause": 1,
                    "scope": 1,
                    "term": "(p2 T1)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "type": "Nodes",
            "74": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(p2 T5)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "75": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            }
        },
        "edges": [
            {
                "from": 3,
                "to": 6,
                "label": "CASE"
            },
            {
                "from": 6,
                "to": 74,
                "label": "EVAL with clause\np2(f(X3)) :- p2(X3).\nand substitutionX3 -> T5,\nT1 -> f(T5),\nT4 -> T5"
            },
            {
                "from": 6,
                "to": 75,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 74,
                "to": 3,
                "label": "INSTANCE with matching:\nT1 -> T5"
            }
        ],
        "type": "Graph"
    }
}

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

(42)
Obligation:
Rules:
f3_in -> f6_in :|: TRUE
f6_out -> f3_out :|: TRUE
f3_out -> f74_out :|: TRUE
f74_in -> f3_in :|: TRUE
f6_in -> f74_in :|: TRUE
f74_out -> f6_out :|: TRUE
f6_in -> f75_in :|: TRUE
f75_out -> f6_out :|: TRUE
Start term: f3_in

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

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

Simplified to the following IRSwTs:

intTRSProblem:
f3_in -> f6_in :|: TRUE
f74_in -> f3_in :|: TRUE
f6_in -> f74_in :|: TRUE


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

(44)
Obligation:
Rules:
f3_in -> f6_in :|: TRUE
f74_in -> f3_in :|: TRUE
f6_in -> f74_in :|: TRUE

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

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

(46)
Obligation:
Rules:
f74_in -> f74_in :|: TRUE

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

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

(48)
Obligation:
Rules:
f74_in -> f74_in :|: TRUE

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

(49) IRSwTTerminationDigraphProof (EQUIVALENT)
Constructed termination digraph!
Nodes:
(1) f74_in -> f74_in :|: TRUE

Arcs:
(1) -> (1)

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

(50)
Obligation:

Termination digraph:
Nodes:
(1) f74_in -> f74_in :|: TRUE

Arcs:
(1) -> (1)

This digraph is fully evaluated!

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

(51) FilterProof (EQUIVALENT)
Used the following sort dictionary for filtering: 
f74_in()
Replaced non-predefined constructor symbols by 0.
----------------------------------------

(52)
Obligation:
Rules:
f74_in -> f74_in :|: TRUE

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

(53) IntTRSPeriodicNontermProof (COMPLETE)
Normalized system to the following form:
f(pc) -> f(1) :|: pc = 1 && TRUE
Witness term starting non-terminating reduction: f(1)
----------------------------------------

(54)
NO
