├── scripts ├── __init__.py ├── util.py ├── config.py └── cache.py ├── rustfmt.toml ├── .gitignore ├── Cargo.toml ├── benchmarks ├── thesy │ ├── clam │ │ ├── goal15.smt2.th │ │ ├── goal51.smt2.th │ │ ├── goal74.smt2.th │ │ ├── goal67.smt2.th │ │ ├── goal8.smt2.th │ │ ├── goal54.smt2.th │ │ ├── goal9.smt2.th │ │ ├── goal56.smt2.th │ │ ├── goal72.smt2.th │ │ ├── goal55.smt2.th │ │ ├── goal61.smt2.th │ │ ├── goal63.smt2.th │ │ ├── goal57.smt2.th │ │ ├── goal16.smt2.th │ │ ├── goal24.smt2.th │ │ ├── goal1.smt2.th │ │ ├── goal73.smt2.th │ │ ├── goal66.smt2.th │ │ ├── goal2.smt2.th │ │ ├── goal39.smt2.th │ │ ├── goal53.smt2.th │ │ ├── goal52.smt2.th │ │ ├── goal13.smt2.th │ │ ├── goal65.smt2.th │ │ ├── goal10.smt2.th │ │ ├── goal26.smt2.th │ │ ├── goal30.smt2.th │ │ ├── goal36.smt2.th │ │ ├── goal37.smt2.th │ │ ├── goal11.smt2.th │ │ ├── goal18.smt2.th │ │ ├── goal38.smt2.th │ │ ├── goal79.smt2.th │ │ ├── goal80.smt2.th │ │ ├── goal19.smt2.th │ │ ├── goal58.smt2.th │ │ ├── goal17.smt2.th │ │ ├── goal59.smt2.th │ │ ├── goal60.smt2.th │ │ ├── goal34.smt2.th │ │ ├── goal85.smt2.th │ │ ├── goal20.smt2.th │ │ ├── goal3.smt2.th │ │ ├── goal5.smt2.th │ │ ├── goal22.smt2.th │ │ ├── goal4.smt2.th │ │ ├── goal64.smt2.th │ │ ├── goal27.smt2.th │ │ ├── goal29.smt2.th │ │ ├── goal31.smt2.th │ │ ├── goal32.smt2.th │ │ ├── goal12.smt2.th │ │ ├── goal75.smt2.th │ │ ├── goal77.smt2.th │ │ ├── goal78.smt2.th │ │ ├── goal81.smt2.th │ │ ├── goal82.smt2.th │ │ ├── goal21.smt2.th │ │ ├── goal83.smt2.th │ │ ├── goal23.smt2.th │ │ ├── goal42.smt2.th │ │ ├── goal43.smt2.th │ │ ├── goal33.smt2.th │ │ ├── goal35.smt2.th │ │ ├── goal84.smt2.th │ │ ├── goal86.smt2.th │ │ ├── goal44.smt2.th │ │ ├── goal25.smt2.th │ │ ├── goal6.smt2.th │ │ ├── goal40.smt2.th │ │ ├── goal48.smt2.th │ │ ├── goal68.smt2.th │ │ ├── goal7.smt2.th │ │ ├── goal41.smt2.th │ │ ├── goal45.smt2.th │ │ ├── goal49.smt2.th │ │ ├── goal46.smt2.th │ │ ├── goal47.smt2.th │ │ ├── goal69.smt2.th │ │ ├── goal50.smt2.th │ │ ├── goal70.smt2.th │ │ ├── goal71.smt2.th │ │ ├── goal14.smt2.th │ │ ├── goal62.smt2.th │ │ ├── goal28.smt2.th │ │ └── goal76.smt2.th │ ├── isaplanner │ │ ├── goal11.smt2.th │ │ ├── goal10.smt2.th │ │ ├── goal16.smt2.th │ │ ├── goal17.smt2.th │ │ ├── goal13.smt2.th │ │ ├── goal63.smt2.th │ │ ├── goal55.smt2.th │ │ ├── goal71.smt2.th │ │ ├── goal81.smt2.th │ │ ├── goal40.smt2.th │ │ ├── goal46.smt2.th │ │ ├── goal42.smt2.th │ │ ├── goal23.smt2.th │ │ ├── goal32.smt2.th │ │ ├── goal45.smt2.th │ │ ├── goal24.smt2.th │ │ ├── goal25.smt2.th │ │ ├── goal33.smt2.th │ │ ├── goal34.smt2.th │ │ ├── goal22.smt2.th │ │ ├── goal31.smt2.th │ │ ├── goal44.smt2.th │ │ ├── goal54.smt2.th │ │ ├── goal7.smt2.th │ │ ├── goal6.smt2.th │ │ ├── goal18.smt2.th │ │ ├── goal66.smt2.th │ │ ├── goal57.smt2.th │ │ ├── goal8.smt2.th │ │ ├── goal9.smt2.th │ │ ├── goal21.smt2.th │ │ ├── goal70.smt2.th │ │ ├── goal60.smt2.th │ │ ├── goal61.smt2.th │ │ ├── goal62.smt2.th │ │ ├── goal12.smt2.th │ │ ├── goal28.smt2.th │ │ ├── goal26.smt2.th │ │ ├── goal27.smt2.th │ │ ├── goal4.smt2.th │ │ ├── goal37.smt2.th │ │ ├── goal39.smt2.th │ │ ├── goal75.smt2.th │ │ ├── goal78.smt2.th │ │ ├── goal5.smt2.th │ │ ├── goal35.smt2.th │ │ ├── goal38.smt2.th │ │ ├── goal41.smt2.th │ │ ├── goal29.smt2.th │ │ ├── goal77.smt2.th │ │ ├── goal14.smt2.th │ │ ├── goal19.smt2.th │ │ ├── goal36.smt2.th │ │ ├── goal83.smt2.th │ │ ├── goal1.smt2.th │ │ ├── goal51.smt2.th │ │ ├── goal58.smt2.th │ │ ├── goal48.smt2.th │ │ ├── goal69.smt2.th │ │ ├── goal2.smt2.th │ │ ├── goal65.smt2.th │ │ ├── goal49.smt2.th │ │ ├── goal52.smt2.th │ │ ├── goal67.smt2.th │ │ ├── goal64.smt2.th │ │ ├── goal3.smt2.th │ │ ├── goal59.smt2.th │ │ ├── goal56.smt2.th │ │ ├── goal68.smt2.th │ │ ├── goal47.smt2.th │ │ ├── goal82.smt2.th │ │ ├── goal20.smt2.th │ │ ├── goal84.smt2.th │ │ ├── goal15.smt2.th │ │ ├── goal30.smt2.th │ │ ├── goal72.smt2.th │ │ ├── goal73.smt2.th │ │ ├── goal53.smt2.th │ │ ├── goal50.smt2.th │ │ ├── goal80.smt2.th │ │ ├── goal79.smt2.th │ │ ├── goal43.smt2.th │ │ ├── goal74.smt2.th │ │ ├── goal76.smt2.th │ │ ├── goal85.smt2.th │ │ ├── goal86.smt2.th │ │ └── goal201.smt2.th │ └── optimization │ │ ├── synduce-tree-sumtree.th │ │ ├── autolifter-single-pass-length.th │ │ ├── autolifter-single-pass-sum.th │ │ ├── synduce-list-last.th │ │ ├── fusion-deforestation-page7-2.th │ │ ├── synduce-tree-min.th │ │ └── synduce-tree-maxtree.th ├── cclemma │ └── optimization │ │ ├── synduce-tree-sumtree.ceg │ │ ├── autolifter-single-pass-length.ceg │ │ ├── autolifter-single-pass-sum.ceg │ │ ├── fusion-deforestation-page7-2.ceg │ │ ├── synduce-list-last.ceg │ │ ├── synduce-tree-maxtree.ceg │ │ ├── synduce-tree-min.ceg │ │ └── synduce-tree-maxtree2.ceg └── cvc4 │ └── clam │ ├── goal15.smt2 │ ├── goal51.smt2 │ ├── goal74.smt2 │ ├── goal67.smt2 │ └── goal72.smt2 └── examples └── add.ceg /scripts/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /rustfmt.toml: -------------------------------------------------------------------------------- 1 | tab_spaces = 2 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | .liquid 3 | .DS_Store 4 | .idea/ 5 | .stack-work 6 | .auctex-auto 7 | /cvc4-comparison/ind/** 8 | /cvc4-comparison/cvc4 9 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "cc-lemma" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | egg = "0.9.5" 10 | symbolic_expressions = "5.0.3" 11 | lazy_static = "1.4.0" 12 | log = "0.4.14" 13 | simple_logger = "2.1.0" 14 | clap = { version = "3.0.13", features = ["derive"] } 15 | colored = "2" 16 | itertools = "0.11.0" 17 | indexmap = "2.0.0" 18 | clippy = "0.0.302" 19 | rand = "0.8.5" 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal15.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (plus zero ?n) ?n) 7 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 8 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 9 | (prove (forall ((x Nat)) (= (plus x (succ x)) (succ (plus x x))))) 10 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal51.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (plus zero ?n) ?n) 7 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 8 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 9 | (prove (forall ((y Nat)(x Nat)) (= (plus x (succ y)) (succ (plus x y))))) 10 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal74.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (plus zero ?n) ?n) 7 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 8 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 9 | (prove (forall ((y Nat)(z Nat)(x Nat)) (= (plus (plus x y) z) (plus x (plus y z))))) 10 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal67.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (plus zero ?n) ?n) 7 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 8 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 9 | (prove (forall ((y Nat)(x Nat)) (= (plus x (succ (succ y))) (succ (succ (plus x y)))))) 10 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal11.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((xs Lst)) (= (drop zero xs) xs))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal10.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun minus (Nat Nat) Nat) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (minus zero ?n) zero) 7 | (=> rule3 (minus ?n zero) ?n) 8 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 9 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 10 | (prove (forall ((m Nat)) (= (minus m m) zero))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal16.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun last (Lst) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (last (cons ?x ?y)) (ite (= ?y nil) ?x (last ?y))) 8 | (=> rule3 (ite (= ?y nil) ?x (last ?y)) (last (cons ?x ?y))) 9 | (prove (forall ((xs Lst)(x Nat)) (=> (= xs nil) (= (last (cons x xs)) x)))) 10 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal8.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((x Nat)(z Lst)(y Nat)) (= (drop x (drop y z)) (drop y (drop x z))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal17.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (less ?x zero) false) 7 | (=> rule3 (less zero (succ ?x)) true) 8 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 9 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 10 | (prove (forall ((n Nat)) (= (or (= n zero) (less n zero)) (= n zero)))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal13.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((xs Lst)(x Nat)(n Nat)) (= (drop (succ n) (cons x xs)) (drop n xs)))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal63.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun last (Lst) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (last (cons ?x ?y)) (ite (= ?y nil) ?x (last ?y))) 8 | (=> rule3 (ite (= ?y nil) ?x (last ?y)) (last (cons ?x ?y))) 9 | (prove (forall ((xs Lst)(x Nat)) (=> (not (= xs nil)) (= (last (cons x xs)) (last xs))))) 10 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal55.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun minus (Nat Nat) Nat) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (minus zero ?n) zero) 7 | (=> rule3 (minus ?n zero) ?n) 8 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 9 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 10 | (prove (forall ((i Nat)(j Nat)(k Nat)) (= (minus (minus i j) k) (minus (minus i k) j)))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal54.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((w Nat)(z Lst)(x Nat)(y Nat)) (= (drop (succ w) (drop x (cons y z))) (drop w (drop x z))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal9.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((z Lst)(x Nat)(w Nat)(y Nat)) (= (drop w (drop x (drop y z))) (drop y (drop x (drop w z)))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal71.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (less ?x zero) false) 7 | (=> rule3 (less zero (succ ?x)) true) 8 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 9 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 10 | (prove (forall ((n Nat)(m Nat)) (=> (or (= m n) (less m n)) (or (= m (succ n)) (less m (succ n)))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal81.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun minus (Nat Nat) Nat) 3 | (declare-fun leq (Nat Nat) Bool) 4 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 5 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 6 | (=> rule2 (minus zero ?n) zero) 7 | (=> rule3 (minus ?n zero) ?n) 8 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 9 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 10 | (prove (forall ((k Nat)(m Nat)(n Nat)) (= (minus (minus (succ m) n) (succ k)) (minus (minus m n) k)))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal56.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((y Nat)(z Lst)(v Nat)(w Nat)(x Nat)) (= (drop (succ v) (drop w (drop x (cons y z)))) (drop v (drop w (drop x z)))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal72.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (append nil ?x) ?x) 8 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 9 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 10 | (prove (forall ((y Lst)(z Lst)(x Lst)) (= (append (append x y) z) (append x (append y z))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal40.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun take (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (take ?x nil) nil) 8 | (=> rule3 (take zero ?x2) nil) 9 | (=> rule4 (take (succ ?x) (cons ?y ?z)) (cons ?y (take ?x ?z))) 10 | (=> rule5 (cons ?y (take ?x ?z)) (take (succ ?x) (cons ?y ?z))) 11 | (prove (forall ((xs Lst)) (= (take zero xs) nil))) 12 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal55.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((y Nat)(z Lst)(v Nat)(w Nat)(x Nat)) (= (drop (succ v) (drop (succ w) (cons x (cons y z)))) (drop (succ v) (drop w (cons x z)))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal61.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (append nil ?x) ?x) 8 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 9 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 10 | (prove (forall ((y3 Nat)(z Lst)(x Lst)) (= (append (append x (cons y3 nil)) z) (append x (cons y3 z))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal63.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (append nil ?x) ?x) 8 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 9 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 10 | (prove (forall ((z3 Nat)(y Lst)(x Lst)) (= (append (append x y) (cons z3 nil)) (append x (append y (cons z3 nil)))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal46.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun zip (Lst Lst) ZLst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (zip nil ?x) znil) 8 | (=> rule3 (zip ?x nil) znil) 9 | (=> rule4 (zip (cons ?x2 ?y) (cons ?z ?w)) (zcons (mkpair ?x2 ?z) (zip ?y ?w))) 10 | (=> rule5 (zcons (mkpair ?x2 ?z) (zip ?y ?w)) (zip (cons ?x2 ?y) (cons ?z ?w))) 11 | (prove (forall ((ys Lst)) (= (zip nil ys) znil))) 12 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal57.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (drop ?x nil) nil) 8 | (=> rule3 (drop zero ?x2) ?x2) 9 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 10 | (prove (forall ((y Nat)(z Lst)(u Nat)(v Nat)(w Nat)(x Nat)) (= (drop (succ u) (drop v (drop (succ w) (cons x (cons y z))))) (drop (succ u) (drop v (drop w (cons x z))))))) 11 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal42.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun take (Nat Lst) Lst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (take ?x nil) nil) 8 | (=> rule3 (take zero ?x2) nil) 9 | (=> rule4 (take (succ ?x) (cons ?y ?z)) (cons ?y (take ?x ?z))) 10 | (=> rule5 (cons ?y (take ?x ?z)) (take (succ ?x) (cons ?y ?z))) 11 | (prove (forall ((n Nat)(xs Lst)(x Nat)) (= (take (succ n) (cons x xs)) (cons x (take n xs))))) 12 | -------------------------------------------------------------------------------- /scripts/util.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | def switch_dir(path, output_path): 4 | file_name = os.path.basename(path) 5 | return os.path.join(output_path, file_name) 6 | 7 | def create_path(file): 8 | dir_path = os.path.dirname(file) 9 | os.makedirs(dir_path, exist_ok=True) 10 | 11 | def split_suffix(file): 12 | return os.path.splitext(file) 13 | 14 | def collect_benchmarks(dataset_path, expected_suffix): 15 | all_files = [] 16 | for file in os.listdir(dataset_path): 17 | if "." not in file: continue 18 | name, suffix = split_suffix(file) 19 | if suffix != expected_suffix: continue 20 | all_files.append((name, os.path.join(dataset_path, file))) 21 | return all_files -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal16.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun even (Nat) Bool) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (even zero) true) 11 | (=> rule6 true (even zero)) 12 | (=> rule7 (even (succ ?n)) (not (even ?n))) 13 | (=> rule8 (not (even ?n)) (even (succ ?n))) 14 | (prove (forall ((x Nat)) (= (even (plus x x)) true))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal23.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmax (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmax ?n ?m) (ite (less ?n ?m) ?m ?n)) 12 | (=> rule7 (ite (less ?n ?m) ?m ?n) (nmax ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)) (= (nmax a b) (nmax b a)))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal32.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmin (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmin ?n ?m) (ite (less ?n ?m) ?n ?m)) 12 | (=> rule7 (ite (less ?n ?m) ?n ?m) (nmin ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)) (= (nmin a b) (nmin b a)))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal24.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun even (Nat) Bool) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (even zero) true) 11 | (=> rule6 true (even zero)) 12 | (=> rule7 (even (succ ?n)) (not (even ?n))) 13 | (=> rule8 (not (even ?n)) (even (succ ?n))) 14 | (prove (forall ((x Nat)(y Nat)) (= (even (plus x y)) (even (plus y x))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal45.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun zip (Lst Lst) ZLst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (zip nil ?x) znil) 8 | (=> rule3 (zip ?x nil) znil) 9 | (=> rule4 (zip (cons ?x2 ?y) (cons ?z ?w)) (zcons (mkpair ?x2 ?z) (zip ?y ?w))) 10 | (=> rule5 (zcons (mkpair ?x2 ?z) (zip ?y ?w)) (zip (cons ?x2 ?y) (cons ?z ?w))) 11 | (prove (forall ((x3 Nat)(xs Lst)(y4 Nat)(ys Lst)) (= (zip (cons x3 xs) (cons y4 ys)) (zcons (mkpair x3 y4) (zip xs ys))))) 12 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal1.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun double (Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (double zero) zero) 11 | (=> rule6 zero (double zero)) 12 | (=> rule7 (double (succ ?n)) (succ (succ (double ?n)))) 13 | (=> rule8 (succ (succ (double ?n))) (double (succ ?n))) 14 | (prove (forall ((x Nat)) (= (double x) (plus x x)))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal73.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun mult (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (mult zero ?n) zero) 11 | (=> rule6 (mult (succ ?n) ?m) (plus (mult ?n ?m) ?m)) 12 | (=> rule7 (plus (mult ?n ?m) ?m) (mult (succ ?n) ?m)) 13 | (prove (forall ((y Nat)(z Nat)(x Nat)) (= (mult (mult x y) z) (mult x (mult y z))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal24.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmax (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmax ?n ?m) (ite (less ?n ?m) ?m ?n)) 12 | (=> rule7 (ite (less ?n ?m) ?m ?n) (nmax ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)) (= (= (nmax a b) a) (or (= b a) (less b a))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal25.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmax (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmax ?n ?m) (ite (less ?n ?m) ?m ?n)) 12 | (=> rule7 (ite (less ?n ?m) ?m ?n) (nmax ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)) (= (= (nmax a b) b) (or (= a b) (less a b))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal33.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmin (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmin ?n ?m) (ite (less ?n ?m) ?n ?m)) 12 | (=> rule7 (ite (less ?n ?m) ?n ?m) (nmin ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)) (= (= (nmin a b) a) (or (= a b) (less a b))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal34.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmin (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmin ?n ?m) (ite (less ?n ?m) ?n ?m)) 12 | (=> rule7 (ite (less ?n ?m) ?n ?m) (nmin ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)) (= (= (nmin a b) b) (or (= b a) (less b a))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal22.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmax (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmax ?n ?m) (ite (less ?n ?m) ?m ?n)) 12 | (=> rule7 (ite (less ?n ?m) ?m ?n) (nmax ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)(c Nat)) (= (nmax (nmax a b) c) (nmax a (nmax b c))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal31.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun nmin (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (nmin ?n ?m) (ite (less ?n ?m) ?n ?m)) 12 | (=> rule7 (ite (less ?n ?m) ?n ?m) (nmin ?n ?m)) 13 | (prove (forall ((a Nat)(b Nat)(c Nat)) (= (nmin (nmin a b) c) (nmin a (nmin b c))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal66.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun even (Nat) Bool) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (even zero) true) 11 | (=> rule6 true (even zero)) 12 | (=> rule7 (even (succ ?n)) (not (even ?n))) 13 | (=> rule8 (not (even ?n)) (even (succ ?n))) 14 | (prove (forall ((x Nat)(y Nat)) (= (even (plus x y)) (even (plus x (succ (succ y))))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal44.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun zip (Lst Lst) ZLst) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (zip nil ?x) znil) 8 | (=> rule3 (zip ?x nil) znil) 9 | (=> rule4 (zip (cons ?x2 ?y) (cons ?z ?w)) (zcons (mkpair ?x2 ?z) (zip ?y ?w))) 10 | (=> rule5 (zcons (mkpair ?x2 ?z) (zip ?y ?w)) (zip (cons ?x2 ?y) (cons ?z ?w))) 11 | (prove (forall ((x3 Nat)(xs Lst)(ys Lst)) (= (zip (cons x3 xs) ys) (ite (= ys nil) znil (zcons (mkpair x3 (head ys)) (zip xs (tail ys))))))) 12 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal54.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (minus zero ?n) zero) 11 | (=> rule6 (minus ?n zero) ?n) 12 | (=> rule7 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule8 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (prove (forall ((m Nat)(n Nat)) (= (minus (plus m n) n) m))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal7.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (minus zero ?n) zero) 11 | (=> rule6 (minus ?n zero) ?n) 12 | (=> rule7 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule8 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (prove (forall ((m Nat)(n Nat)) (= (minus (plus n m) n) m))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal6.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (minus zero ?n) zero) 11 | (=> rule6 (minus ?n zero) ?n) 12 | (=> rule7 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule8 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (prove (forall ((m Nat)(n Nat)) (= (minus n (plus n m)) zero))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal2.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (len nil) zero) 12 | (=> rule6 zero (len nil)) 13 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 14 | (prove (forall ((y Lst)(x Lst)) (= (len (append x y)) (len (append y x))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal18.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (plus zero ?n) ?n) 12 | (=> rule7 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 13 | (=> rule8 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 14 | (prove (forall ((i Nat)(m Nat)) (= (less i (succ (plus i m))) true))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal66.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (plus zero ?n) ?n) 12 | (=> rule7 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 13 | (=> rule8 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 14 | (prove (forall ((i Nat)(m Nat)) (= (less i (succ (plus m i))) true))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal39.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun drop (Nat Lst) Lst) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (drop ?x nil) nil) 9 | (=> rule3 (drop zero ?x2) ?x2) 10 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 11 | (=> rule5 (mem ?x nil) false) 12 | (=> rule6 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 13 | (=> rule7 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 14 | (prove (forall ((x Nat)(z Lst)(y Nat)) (=> (mem x (drop y z)) (mem x z)))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal53.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (len nil) zero) 12 | (=> rule6 zero (len nil)) 13 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 14 | (prove (forall ((y4 Nat)(x Lst)) (= (len (append x (cons y4 nil))) (succ (len x))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal57.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun drop (Nat Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (plus zero ?n) ?n) 9 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 10 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 11 | (=> rule5 (drop ?x nil) nil) 12 | (=> rule6 (drop zero ?x2) ?x2) 13 | (=> rule7 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 14 | (prove (forall ((xs Lst)(m Nat)(n Nat)) (= (drop n (drop m xs)) (drop (plus n m) xs)))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal8.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (minus zero ?n) zero) 11 | (=> rule6 (minus ?n zero) ?n) 12 | (=> rule7 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule8 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (prove (forall ((m Nat)(k Nat)(n Nat)) (= (minus (plus k m) (plus k n)) (minus m n)))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal9.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (minus zero ?n) zero) 11 | (=> rule6 (minus ?n zero) ?n) 12 | (=> rule7 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule8 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (prove (forall ((i Nat)(j Nat)(k Nat)) (= (minus (minus i j) k) (minus i (plus j k))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal21.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (plus zero ?n) ?n) 12 | (=> rule7 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 13 | (=> rule8 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 14 | (prove (forall ((m Nat)(n Nat)) (= (or (= n (plus n m)) (less n (plus n m))) true))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal70.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun less (Nat Nat) Bool) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (less ?x zero) false) 8 | (=> rule3 (less zero (succ ?x)) true) 9 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 10 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 11 | (=> rule6 (plus zero ?n) ?n) 12 | (=> rule7 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 13 | (=> rule8 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 14 | (prove (forall ((m Nat)(n Nat)) (= (or (= n (plus m n)) (less n (plus m n))) true))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal52.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (len nil) zero) 12 | (=> rule6 zero (len nil)) 13 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 14 | (prove (forall ((y4 Nat)(x Lst)(z Lst)) (= (len (append x (cons y4 z))) (succ (len (append x z)))))) 15 | -------------------------------------------------------------------------------- /scripts/config.py: -------------------------------------------------------------------------------- 1 | timeout = 2 2 | memory_limit = 16 3 | 4 | dataset_root = "/home/artifact/cc-lemma/benchmarks" 5 | cclemma_path = "/home/artifact/cc-lemma" 6 | hipspec_path = "/home/artifact/hipspec" 7 | thesy_path = "/home/artifact/TheSy" 8 | cvc4_bin_name = "cvc4-vmcai2015" 9 | output_path = "/home/artifact/cc-lemma/results" 10 | 11 | hipspec_expensive_props = { 12 | "clam": [81], 13 | "isaplanner": [33, 34, 35, 84, 85, 86], 14 | } 15 | 16 | cvc4_args = "--quant-ind --quant-cf --conjecture-gen --conjecture-gen-per-round=3 --full-saturate-quant --stats" 17 | hipspec_args = "--auto --verbosity=85 --cg -luU" 18 | hipspec_expensive_args = "--pvars --size 7" 19 | cclemma_args = "--no-generalization --exclude-bid-reachable --saturate-only-parent -r" 20 | thesy_args = "" 21 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal60.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun last (Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (last (cons ?x3 ?y)) (ite (= ?y nil) ?x3 (last ?y))) 12 | (=> rule6 (ite (= ?y nil) ?x3 (last ?y)) (last (cons ?x3 ?y))) 13 | (prove (forall ((xs Lst)(ys Lst)) (=> (= ys nil) (= (last (append xs ys)) (last xs))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal13.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun half (Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (half zero) zero) 11 | (=> rule6 zero (half zero)) 12 | (=> rule7 (half (succ zero)) zero) 13 | (=> rule8 zero (half (succ zero))) 14 | (=> rule9 (half (succ (succ ?n))) (succ (half ?n))) 15 | (=> rule10 (succ (half ?n)) (half (succ (succ ?n)))) 16 | (prove (forall ((x Nat)) (= (half (plus x x)) x))) 17 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal65.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (len nil) zero) 12 | (=> rule6 zero (len nil)) 13 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 14 | (prove (forall ((w Lst)(x4 Nat)(y5 Nat)(z Lst)) (= (len (append w (cons x4 (cons y5 z)))) (succ (succ (len (append w z))))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal61.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun last (Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (last (cons ?x3 ?y)) (ite (= ?y nil) ?x3 (last ?y))) 12 | (=> rule6 (ite (= ?y nil) ?x3 (last ?y)) (last (cons ?x3 ?y))) 13 | (prove (forall ((xs Lst)(ys Lst)) (=> (not (= ys nil)) (= (last (append xs ys)) (last ys))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal10.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((x Lst)) (= (rev (rev x)) x))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal62.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun last (Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (last (cons ?x3 ?y)) (ite (= ?y nil) ?x3 (last ?y))) 12 | (=> rule6 (ite (= ?y nil) ?x3 (last ?y)) (last (cons ?x3 ?y))) 13 | (prove (forall ((xs Lst)(ys Lst)) (= (last (append xs ys)) (ite (= ys nil) (last xs) (last ys))))) 14 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal26.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun half (Nat) Nat) 4 | (declare-fun leq (Nat Nat) Bool) 5 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 6 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 7 | (=> rule2 (plus zero ?n) ?n) 8 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 9 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 10 | (=> rule5 (half zero) zero) 11 | (=> rule6 zero (half zero)) 12 | (=> rule7 (half (succ zero)) zero) 13 | (=> rule8 zero (half (succ zero))) 14 | (=> rule9 (half (succ (succ ?n))) (succ (half ?n))) 15 | (=> rule10 (succ (half ?n)) (half (succ (succ ?n)))) 16 | (prove (forall ((x Nat)(y Nat)) (= (half (plus x y)) (half (plus y x))))) 17 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal30.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((x Lst)) (= (rev (append (rev x) nil)) x))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal36.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (mem ?x3 nil) false) 12 | (=> rule6 (mem ?x4 (cons ?y5 ?z)) (or (= ?x4 ?y5) (mem ?x4 ?z))) 13 | (=> rule7 (or (= ?x4 ?y5) (mem ?x4 ?z)) (mem ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((y Lst)(z Lst)(x6 Nat)) (=> (mem x6 y) (mem x6 (append y z))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal37.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (mem ?x3 nil) false) 12 | (=> rule6 (mem ?x4 (cons ?y5 ?z)) (or (= ?x4 ?y5) (mem ?x4 ?z))) 13 | (=> rule7 (or (= ?x4 ?y5) (mem ?x4 ?z)) (mem ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((y Lst)(z Lst)(x6 Nat)) (=> (mem x6 z) (mem x6 (append y z))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal12.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun f (Nat) Nat) 4 | (declare-fun drop (Nat Lst) Lst) 5 | (declare-fun lmap (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (drop ?x nil) nil) 10 | (=> rule3 (drop zero ?x2) ?x2) 11 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 12 | (=> rule5 (lmap nil) nil) 13 | (=> rule6 nil (lmap nil)) 14 | (=> rule7 (lmap (cons ?x ?y3)) (cons (f ?x) (lmap ?y3))) 15 | (=> rule8 (cons (f ?x) (lmap ?y3)) (lmap (cons ?x ?y3))) 16 | (prove (forall ((n Nat)(xs Lst)) (= (drop n (lmap xs)) (lmap (drop n xs))))) 17 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal28.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (mem ?x3 nil) false) 12 | (=> rule6 (mem ?x4 (cons ?y5 ?z)) (or (= ?x4 ?y5) (mem ?x4 ?z))) 13 | (=> rule7 (or (= ?x4 ?y5) (mem ?x4 ?z)) (mem ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((x6 Nat)(l Lst)) (= (mem x6 (append l (cons x6 nil))) true))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal26.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (mem ?x3 nil) false) 12 | (=> rule6 (mem ?x4 (cons ?y5 ?z)) (or (= ?x4 ?y5) (mem ?x4 ?z))) 13 | (=> rule7 (or (= ?x4 ?y5) (mem ?x4 ?z)) (mem ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((x6 Nat)(l Lst)(t Lst)) (=> (mem x6 l) (mem x6 (append l t))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal27.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (mem ?x3 nil) false) 12 | (=> rule6 (mem ?x4 (cons ?y5 ?z)) (or (= ?x4 ?y5) (mem ?x4 ?z))) 13 | (=> rule7 (or (= ?x4 ?y5) (mem ?x4 ?z)) (mem ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((x6 Nat)(l Lst)(t Lst)) (=> (mem x6 t) (mem x6 (append l t))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal11.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y Lst)(x Lst)) (= (rev (append (rev x) (rev y))) (append y x)))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal18.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y Lst)(x Lst)) (= (rev (append (rev x) y)) (append (rev y) x)))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal38.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (mem ?x3 nil) false) 12 | (=> rule6 (mem ?x4 (cons ?y5 ?z)) (or (= ?x4 ?y5) (mem ?x4 ?z))) 13 | (=> rule7 (or (= ?x4 ?y5) (mem ?x4 ?z)) (mem ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((y Lst)(z Lst)(x6 Nat)) (=> (or (mem x6 y) (mem x6 z)) (mem x6 (append y z))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal79.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y Lst)(x Lst)) (= (rev (append (rev x) y)) (append (rev y) x)))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal80.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y Lst)(x Lst)) (= (rev (append (rev x) (rev y))) (append y x)))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal19.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y Lst)(x Lst)) (= (append (rev (rev x)) y) (rev (rev (append x y)))))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal58.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y4 Nat)(x Lst)) (= (rev (append x (cons y4 nil))) (cons y4 (rev x))))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal4.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (plus zero ?n) ?n) 9 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 10 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 11 | (=> rule5 (count ?x nil) zero) 12 | (=> rule6 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 13 | (=> rule7 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 14 | (prove (forall ((l Lst)(n Nat)) (= (plus (succ zero) (count n l)) (count n (cons n l))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal17.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y Lst)(x Lst)) (= (rev (rev (append x y))) (append (rev (rev x)) (rev (rev y)))))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal37.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun mem (Nat Lst) Bool) 4 | (declare-fun delete (Nat Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (mem ?x nil) false) 9 | (=> rule3 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 10 | (=> rule4 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 11 | (=> rule5 (delete ?x nil) nil) 12 | (=> rule6 (delete ?x (cons ?y ?z)) (ite (= ?x ?y) (delete ?x ?z) (cons ?y (delete ?x ?z)))) 13 | (=> rule7 (ite (= ?x ?y) (delete ?x ?z) (cons ?y (delete ?x ?z))) (delete ?x (cons ?y ?z))) 14 | (prove (forall ((l Lst)(x Nat)) (= (not (mem x (delete x l))) true))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal39.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (plus zero ?n) ?n) 9 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 10 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 11 | (=> rule5 (count ?x nil) zero) 12 | (=> rule6 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 13 | (=> rule7 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 14 | (prove (forall ((h Nat)(t Lst)(n Nat)) (= (plus (count n (cons h nil)) (count n t)) (count n (cons h t))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal75.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun filter (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (prove (forall ((xs Lst)) (= (rev (filter xs)) (filter (rev xs))))) 17 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal78.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (plus zero ?n) ?n) 9 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 10 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 11 | (=> rule5 (count ?x nil) zero) 12 | (=> rule6 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 13 | (=> rule7 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 14 | (prove (forall ((h Nat)(t Lst)(n Nat)) (= (plus (count n t) (count n (cons h nil))) (count n (cons h t))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal59.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y Lst)(z4 Nat)(x Lst)) (= (rev (append x (append y (cons z4 nil)))) (cons z4 (rev (append x y)))))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal60.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (rev nil) nil) 12 | (=> rule6 nil (rev nil)) 13 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 14 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 15 | (prove (forall ((y4 Nat)(x Lst)) (= (rev (append (append x (cons y4 nil)) nil)) (cons y4 (rev (append x nil)))))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal5.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (plus zero ?n) ?n) 9 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 10 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 11 | (=> rule5 (count ?x nil) zero) 12 | (=> rule6 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 13 | (=> rule7 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 14 | (prove (forall ((l Lst)(x Nat)(n Nat)) (=> (= n x) (= (plus (succ zero) (count n l)) (count n (cons x l)))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal35.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun P (Nat) Bool) 4 | (declare-fun drop (Nat Lst) Lst) 5 | (declare-fun dropWhile (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (drop ?x nil) nil) 10 | (=> rule3 (drop zero ?x2) ?x2) 11 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 12 | (=> rule5 (dropWhile nil) nil) 13 | (=> rule6 nil (dropWhile nil)) 14 | (=> rule7 (dropWhile (cons ?x ?y3)) (ite (P ?x) (dropWhile ?y3) (cons ?x ?y3))) 15 | (=> rule8 (ite (P ?x) (dropWhile ?y3) (cons ?x ?y3)) (dropWhile (cons ?x ?y3))) 16 | (prove (forall ((xs Lst)) (=> (forall ((x Nat)) (not (P x))) (= (dropWhile xs) xs)))) 17 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal38.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (count ?x3 nil) zero) 12 | (=> rule6 (count ?x4 (cons ?y5 ?z)) (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z))) 13 | (=> rule7 (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z)) (count ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((n Nat)(x Lst)) (= (count n (append x (cons n nil))) (succ (count n x))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal41.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun f (Nat) Nat) 4 | (declare-fun take (Nat Lst) Lst) 5 | (declare-fun lmap (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (take ?x nil) nil) 10 | (=> rule3 (take zero ?x2) nil) 11 | (=> rule4 (take (succ ?x) (cons ?y ?z)) (cons ?y (take ?x ?z))) 12 | (=> rule5 (cons ?y (take ?x ?z)) (take (succ ?x) (cons ?y ?z))) 13 | (=> rule6 (lmap nil) nil) 14 | (=> rule7 nil (lmap nil)) 15 | (=> rule8 (lmap (cons ?x ?y3)) (cons (f ?x) (lmap ?y3))) 16 | (=> rule9 (cons (f ?x) (lmap ?y3)) (lmap (cons ?x ?y3))) 17 | (prove (forall ((n Nat)(xs Lst)) (= (take n (lmap xs)) (lmap (take n xs))))) 18 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal29.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun mem (Nat Lst) Bool) 4 | (declare-fun ins1 (Nat Lst) Lst) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (mem ?x nil) false) 9 | (=> rule3 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 10 | (=> rule4 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 11 | (=> rule5 (ins1 ?i nil) (cons ?i nil)) 12 | (=> rule6 (cons ?i nil) (ins1 ?i nil)) 13 | (=> rule7 (ins1 ?i (cons ?x ?y2)) (ite (= ?i ?x) (cons ?x ?y2) (cons ?x (ins1 ?i ?y2)))) 14 | (=> rule8 (ite (= ?i ?x) (cons ?x ?y2) (cons ?x (ins1 ?i ?y2))) (ins1 ?i (cons ?x ?y2))) 15 | (prove (forall ((l Lst)(x Nat)) (= (mem x (ins1 x l)) true))) 16 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal77.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (append nil ?x) ?x) 9 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 10 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 11 | (=> rule5 (count ?x3 nil) zero) 12 | (=> rule6 (count ?x4 (cons ?y5 ?z)) (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z))) 13 | (=> rule7 (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z)) (count ?x4 (cons ?y5 ?z))) 14 | (prove (forall ((n Nat)(h Nat)(x Lst)) (=> (not (= n h)) (= (count n (append x (cons h nil))) (count n x))))) 15 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal34.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun mult (Nat Nat) Nat) 4 | (declare-fun qmult (Nat Nat Nat) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (plus zero ?n) ?n) 9 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 10 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 11 | (=> rule5 (mult zero ?n) zero) 12 | (=> rule6 (mult (succ ?n) ?m) (plus (mult ?n ?m) ?m)) 13 | (=> rule7 (plus (mult ?n ?m) ?m) (mult (succ ?n) ?m)) 14 | (=> rule8 (qmult zero ?n ?m) ?m) 15 | (=> rule9 (qmult (succ ?n) ?m ?p) (qmult ?n ?m (plus ?p ?m))) 16 | (=> rule10 (qmult ?n ?m (plus ?p ?m)) (qmult (succ ?n) ?m ?p)) 17 | (prove (forall ((x Nat)(y Nat)) (= (mult x y) (qmult x y zero)))) 18 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal85.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun mult (Nat Nat) Nat) 4 | (declare-fun qmult (Nat Nat Nat) Nat) 5 | (declare-fun leq (Nat Nat) Bool) 6 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 7 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 8 | (=> rule2 (plus zero ?n) ?n) 9 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 10 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 11 | (=> rule5 (mult zero ?n) zero) 12 | (=> rule6 (mult (succ ?n) ?m) (plus (mult ?n ?m) ?m)) 13 | (=> rule7 (plus (mult ?n ?m) ?m) (mult (succ ?n) ?m)) 14 | (=> rule8 (qmult zero ?n ?m) ?m) 15 | (=> rule9 (qmult (succ ?n) ?m ?p) (qmult ?n ?m (plus ?p ?m))) 16 | (=> rule10 (qmult ?n ?m (plus ?p ?m)) (qmult (succ ?n) ?m ?p)) 17 | (prove (forall ((x Nat)(y Nat)(z Nat)) (= (plus (mult x y) z) (qmult x y z)))) 18 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal20.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun even (Nat) Bool) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (even zero) true) 10 | (=> rule3 true (even zero)) 11 | (=> rule4 (even (succ ?n)) (not (even ?n))) 12 | (=> rule5 (not (even ?n)) (even (succ ?n))) 13 | (=> rule6 (append nil ?x) ?x) 14 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 15 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 16 | (=> rule9 (len nil) zero) 17 | (=> rule10 zero (len nil)) 18 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 19 | (prove (forall ((x Lst)) (= (even (len (append x x))) true))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal3.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (plus zero ?n) ?n) 10 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 11 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 12 | (=> rule5 (append nil ?x) ?x) 13 | (=> rule6 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 14 | (=> rule7 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 15 | (=> rule8 (len nil) zero) 16 | (=> rule9 zero (len nil)) 17 | (=> rule10 (len (cons ?x3 ?y)) (succ (len ?y))) 18 | (prove (forall ((y Lst)(x Lst)) (= (len (append x y)) (plus (len x) (len y))))) 19 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal14.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun P (Nat) Bool) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun filter (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (filter nil) nil) 13 | (=> rule6 nil (filter nil)) 14 | (=> rule7 (filter (cons ?x3 ?y)) (ite (P ?x3) (cons ?x3 (filter ?y)) (filter ?y))) 15 | (=> rule8 (ite (P ?x3) (cons ?x3 (filter ?y)) (filter ?y)) (filter (cons ?x3 ?y))) 16 | (prove (forall ((ys Lst)(xs Lst)) (= (filter (append xs ys)) (append (filter xs) (filter ys))))) 17 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal19.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun drop (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (minus zero ?n) zero) 10 | (=> rule3 (minus ?n zero) ?n) 11 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 12 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 13 | (=> rule6 (len nil) zero) 14 | (=> rule7 zero (len nil)) 15 | (=> rule8 (len (cons ?x ?y)) (succ (len ?y))) 16 | (=> rule9 (drop ?x nil) nil) 17 | (=> rule10 (drop zero ?x2) ?x2) 18 | (=> rule11 (drop (succ ?x) (cons ?y3 ?z)) (drop ?x ?z)) 19 | (prove (forall ((xs Lst)(n Nat)) (= (len (drop n xs)) (minus (len xs) n)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal5.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun rev (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (len nil) zero) 13 | (=> rule6 zero (len nil)) 14 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 15 | (=> rule8 (rev nil) nil) 16 | (=> rule9 nil (rev nil)) 17 | (=> rule10 (rev (cons ?x4 ?y)) (append (rev ?y) (cons ?x4 nil))) 18 | (=> rule11 (append (rev ?y) (cons ?x4 nil)) (rev (cons ?x4 ?y))) 19 | (prove (forall ((x Lst)) (= (len (rev x)) (len x)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal36.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun P (Nat) Bool) 4 | (declare-fun take (Nat Lst) Lst) 5 | (declare-fun takeWhile (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (take ?x nil) nil) 10 | (=> rule3 (take zero ?x2) nil) 11 | (=> rule4 (take (succ ?x) (cons ?y ?z)) (cons ?y (take ?x ?z))) 12 | (=> rule5 (cons ?y (take ?x ?z)) (take (succ ?x) (cons ?y ?z))) 13 | (=> rule6 (takeWhile nil) nil) 14 | (=> rule7 nil (takeWhile nil)) 15 | (=> rule8 (takeWhile (cons ?x ?y3)) (ite (P ?x) (cons ?x (takeWhile ?y3)) nil)) 16 | (=> rule9 (ite (P ?x) (cons ?x (takeWhile ?y3)) nil) (takeWhile (cons ?x ?y3))) 17 | (prove (forall ((xs Lst)) (=> (forall ((x Nat)) (P x)) (= (takeWhile xs) xs)))) 18 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal22.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun even (Nat) Bool) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (even zero) true) 10 | (=> rule3 true (even zero)) 11 | (=> rule4 (even (succ ?n)) (not (even ?n))) 12 | (=> rule5 (not (even ?n)) (even (succ ?n))) 13 | (=> rule6 (append nil ?x) ?x) 14 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 15 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 16 | (=> rule9 (len nil) zero) 17 | (=> rule10 zero (len nil)) 18 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 19 | (prove (forall ((y Lst)(x Lst)) (= (even (len (append x y))) (even (len (append y x)))))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal4.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun double (Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (double zero) zero) 10 | (=> rule3 zero (double zero)) 11 | (=> rule4 (double (succ ?n)) (succ (succ (double ?n)))) 12 | (=> rule5 (succ (succ (double ?n))) (double (succ ?n))) 13 | (=> rule6 (append nil ?x) ?x) 14 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 15 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 16 | (=> rule9 (len nil) zero) 17 | (=> rule10 zero (len nil)) 18 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 19 | (prove (forall ((x Lst)) (= (len (append x x)) (double (len x))))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal64.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun even (Nat) Bool) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (even zero) true) 10 | (=> rule3 true (even zero)) 11 | (=> rule4 (even (succ ?n)) (not (even ?n))) 12 | (=> rule5 (not (even ?n)) (even (succ ?n))) 13 | (=> rule6 (append nil ?x) ?x) 14 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 15 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 16 | (=> rule9 (len nil) zero) 17 | (=> rule10 zero (len nil)) 18 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 19 | (prove (forall ((z Lst)(w Lst)(x4 Nat)(y5 Nat)) (= (even (len (append w z))) (even (len (append w (cons x4 (cons y5 z)))))))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal27.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((x Lst)) (= (rev x) (qreva x nil)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal29.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((x Lst)) (= (rev (qreva x nil)) x))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal83.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun drop (Nat Lst) Lst) 5 | (declare-fun take (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (plus zero ?n) ?n) 10 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 11 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 12 | (=> rule5 (drop ?x nil) nil) 13 | (=> rule6 (drop zero ?x2) ?x2) 14 | (=> rule7 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 15 | (=> rule8 (take ?x nil) nil) 16 | (=> rule9 (take zero ?x3) nil) 17 | (=> rule10 (take (succ ?x) (cons ?y ?z)) (cons ?y (take ?x ?z))) 18 | (=> rule11 (cons ?y (take ?x ?z)) (take (succ ?x) (cons ?y ?z))) 19 | (prove (forall ((m Nat)(xs Lst)(n Nat)) (= (take n (drop m xs)) (drop m (take (plus n m) xs))))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal31.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((x Lst)) (= (qreva (qreva x nil) nil) x))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal32.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun rotate (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (len nil) zero) 13 | (=> rule6 zero (len nil)) 14 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 15 | (=> rule8 (rotate zero ?x) ?x) 16 | (=> rule9 (rotate (succ ?n) nil) nil) 17 | (=> rule10 (rotate (succ ?n) (cons ?y4 ?x)) (rotate ?n (append ?x (cons ?y4 nil)))) 18 | (=> rule11 (rotate ?n (append ?x (cons ?y4 nil))) (rotate (succ ?n) (cons ?y4 ?x))) 19 | (prove (forall ((x Lst)) (= (rotate (len x) x) x))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal12.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((y Lst)(x Lst)) (= (qreva x y) (append (rev x) y)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal75.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((y Lst)(x Lst)) (= (append (rev x) y) (qreva x y)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal1.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun drop (Nat Lst) Lst) 5 | (declare-fun take (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (drop ?x3 nil) nil) 13 | (=> rule6 (drop zero ?x) ?x) 14 | (=> rule7 (drop (succ ?x4) (cons ?y5 ?z)) (drop ?x4 ?z)) 15 | (=> rule8 (take ?x6 nil) nil) 16 | (=> rule9 (take zero ?x) nil) 17 | (=> rule10 (take (succ ?x7) (cons ?y8 ?z)) (cons ?y8 (take ?x7 ?z))) 18 | (=> rule11 (cons ?y8 (take ?x7 ?z)) (take (succ ?x7) (cons ?y8 ?z))) 19 | (prove (forall ((n Nat)(xs Lst)) (= (append (take n xs) (drop n xs)) xs))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal77.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((y Lst)(x Lst)) (= (rev (qreva x y)) (append (rev y) x)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal78.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((y Lst)(x Lst)) (= (rev (qreva x (rev y))) (append y x)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal81.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((y Lst)(x Lst)) (= (qreva (qreva x y) nil) (append (rev y) x)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal82.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun rev (Lst) Lst) 5 | (declare-fun qreva (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (rev nil) nil) 13 | (=> rule6 nil (rev nil)) 14 | (=> rule7 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 15 | (=> rule8 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 16 | (=> rule9 (qreva nil ?x) ?x) 17 | (=> rule10 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 18 | (=> rule11 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 19 | (prove (forall ((y Lst)(x Lst)) (= (qreva (qreva x (rev y)) nil) (append y x)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal21.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun rotate (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (len nil) zero) 13 | (=> rule6 zero (len nil)) 14 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 15 | (=> rule8 (rotate zero ?x) ?x) 16 | (=> rule9 (rotate (succ ?n) nil) nil) 17 | (=> rule10 (rotate (succ ?n) (cons ?y4 ?x)) (rotate ?n (append ?x (cons ?y4 nil)))) 18 | (=> rule11 (rotate ?n (append ?x (cons ?y4 nil))) (rotate (succ ?n) (cons ?y4 ?x))) 19 | (prove (forall ((y Lst)(x Lst)) (= (rotate (len x) (append x y)) (append y x)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal83.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun rotate (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (len nil) zero) 13 | (=> rule6 zero (len nil)) 14 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 15 | (=> rule8 (rotate zero ?x) ?x) 16 | (=> rule9 (rotate (succ ?n) nil) nil) 17 | (=> rule10 (rotate (succ ?n) (cons ?y4 ?x)) (rotate ?n (append ?x (cons ?y4 nil)))) 18 | (=> rule11 (rotate ?n (append ?x (cons ?y4 nil))) (rotate (succ ?n) (cons ?y4 ?x))) 19 | (prove (forall ((y Lst)(x Lst)) (= (rotate (len x) (append x y)) (append y x)))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal51.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun last (Lst) Nat) 5 | (declare-fun butlast (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (last (cons ?x3 ?y)) (ite (= ?y nil) ?x3 (last ?y))) 13 | (=> rule6 (ite (= ?y nil) ?x3 (last ?y)) (last (cons ?x3 ?y))) 14 | (=> rule7 (butlast nil) nil) 15 | (=> rule8 nil (butlast nil)) 16 | (=> rule9 (butlast (cons ?x4 ?y)) (ite (= ?y nil) nil (cons ?x4 (butlast ?y)))) 17 | (=> rule10 (ite (= ?y nil) nil (cons ?x4 (butlast ?y))) (butlast (cons ?x4 ?y))) 18 | (prove (forall ((xs Lst)(x5 Nat)) (= (butlast (append xs (cons x5 nil))) xs))) 19 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal23.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun half (Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (half zero) zero) 10 | (=> rule3 zero (half zero)) 11 | (=> rule4 (half (succ zero)) zero) 12 | (=> rule5 zero (half (succ zero))) 13 | (=> rule6 (half (succ (succ ?n))) (succ (half ?n))) 14 | (=> rule7 (succ (half ?n)) (half (succ (succ ?n)))) 15 | (=> rule8 (append nil ?x) ?x) 16 | (=> rule9 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 17 | (=> rule10 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 18 | (=> rule11 (len nil) zero) 19 | (=> rule12 zero (len nil)) 20 | (=> rule13 (len (cons ?x3 ?y)) (succ (len ?y))) 21 | (prove (forall ((x Lst)(y Lst)) (= (half (len (append x y))) (half (len (append y x)))))) 22 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal42.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun mem (Nat Lst) Bool) 4 | (declare-fun lst-mem (Nat Lst) Bool) 5 | (declare-fun lst-union (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (mem ?x nil) false) 10 | (=> rule3 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 11 | (=> rule4 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 12 | (=> rule5 (lst-mem ?n ?x2) (mem ?n ?x2)) 13 | (=> rule6 (mem ?n ?x2) (lst-mem ?n ?x2)) 14 | (=> rule7 (lst-union nil ?x3) ?x3) 15 | (=> rule8 (lst-union (cons ?n ?x4) ?y5) (ite (lst-mem ?n ?y5) (lst-union ?x4 ?y5) (cons ?n (lst-union ?x4 ?y5)))) 16 | (=> rule9 (ite (lst-mem ?n ?y5) (lst-union ?x4 ?y5) (cons ?n (lst-union ?x4 ?y5))) (lst-union (cons ?n ?x4) ?y5)) 17 | (prove (forall ((z Lst)(x Nat)(y6 Lst)) (=> (lst-mem x y6) (lst-mem x (lst-union y6 z))))) 18 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal43.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun mem (Nat Lst) Bool) 4 | (declare-fun lst-mem (Nat Lst) Bool) 5 | (declare-fun lst-union (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (mem ?x nil) false) 10 | (=> rule3 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 11 | (=> rule4 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 12 | (=> rule5 (lst-mem ?n ?x2) (mem ?n ?x2)) 13 | (=> rule6 (mem ?n ?x2) (lst-mem ?n ?x2)) 14 | (=> rule7 (lst-union nil ?x3) ?x3) 15 | (=> rule8 (lst-union (cons ?n ?x4) ?y5) (ite (lst-mem ?n ?y5) (lst-union ?x4 ?y5) (cons ?n (lst-union ?x4 ?y5)))) 16 | (=> rule9 (ite (lst-mem ?n ?y5) (lst-union ?x4 ?y5) (cons ?n (lst-union ?x4 ?y5))) (lst-union (cons ?n ?x4) ?y5)) 17 | (prove (forall ((z Lst)(x Nat)(y6 Lst)) (=> (lst-mem x y6) (lst-mem x (lst-union z y6))))) 18 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal58.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun drop (Nat Lst) Lst) 5 | (declare-fun take (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (minus zero ?n) zero) 10 | (=> rule3 (minus ?n zero) ?n) 11 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 12 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 13 | (=> rule6 (drop ?x nil) nil) 14 | (=> rule7 (drop zero ?x2) ?x2) 15 | (=> rule8 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 16 | (=> rule9 (take ?x nil) nil) 17 | (=> rule10 (take zero ?x3) nil) 18 | (=> rule11 (take (succ ?x) (cons ?y ?z)) (cons ?y (take ?x ?z))) 19 | (=> rule12 (cons ?y (take ?x ?z)) (take (succ ?x) (cons ?y ?z))) 20 | (prove (forall ((xs Lst)(m Nat)(n Nat)) (= (drop n (take m xs)) (take (minus m n) (drop n xs))))) 21 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal48.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun last (Lst) Nat) 5 | (declare-fun butlast (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (last (cons ?x3 ?y)) (ite (= ?y nil) ?x3 (last ?y))) 13 | (=> rule6 (ite (= ?y nil) ?x3 (last ?y)) (last (cons ?x3 ?y))) 14 | (=> rule7 (butlast nil) nil) 15 | (=> rule8 nil (butlast nil)) 16 | (=> rule9 (butlast (cons ?x4 ?y)) (ite (= ?y nil) nil (cons ?x4 (butlast ?y)))) 17 | (=> rule10 (ite (= ?y nil) nil (cons ?x4 (butlast ?y))) (butlast (cons ?x4 ?y))) 18 | (prove (forall ((xs Lst)) (=> (not (= xs nil)) (= (butlast (append xs (cons (last xs) nil))) xs)))) 19 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal69.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun delete (Nat Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (less ?x zero) false) 10 | (=> rule3 (less zero (succ ?x)) true) 11 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 12 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 13 | (=> rule6 (len nil) zero) 14 | (=> rule7 zero (len nil)) 15 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 16 | (=> rule9 (delete ?x nil) nil) 17 | (=> rule10 (delete ?x (cons ?y ?z)) (ite (= ?x ?y) (delete ?x ?z) (cons ?y (delete ?x ?z)))) 18 | (=> rule11 (ite (= ?x ?y) (delete ?x ?z) (cons ?y (delete ?x ?z))) (delete ?x (cons ?y ?z))) 19 | (prove (forall ((l Lst)(x Nat)) (= (or (= (len (delete x l)) (len l)) (less (len (delete x l)) (len l))) true))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal2.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun count (Nat Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (plus zero ?n) ?n) 10 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 11 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 12 | (=> rule5 (append nil ?x) ?x) 13 | (=> rule6 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 14 | (=> rule7 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 15 | (=> rule8 (count ?x3 nil) zero) 16 | (=> rule9 (count ?x4 (cons ?y5 ?z)) (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z))) 17 | (=> rule10 (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z)) (count ?x4 (cons ?y5 ?z))) 18 | (prove (forall ((l Lst)(m6 Lst)(n Nat)) (= (plus (count n l) (count n m6)) (count n (append l m6))))) 19 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal65.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun P (Nat) Bool) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun last (Lst) Nat) 6 | (declare-fun filter (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (append nil ?x) ?x) 11 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 12 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 13 | (=> rule5 (last (cons ?x3 ?y)) (ite (= ?y nil) ?x3 (last ?y))) 14 | (=> rule6 (ite (= ?y nil) ?x3 (last ?y)) (last (cons ?x3 ?y))) 15 | (=> rule7 (filter nil) nil) 16 | (=> rule8 nil (filter nil)) 17 | (=> rule9 (filter (cons ?x4 ?y)) (ite (P ?x4) (cons ?x4 (filter ?y)) (filter ?y))) 18 | (=> rule10 (ite (P ?x4) (cons ?x4 (filter ?y)) (filter ?y)) (filter (cons ?x4 ?y))) 19 | (prove (forall ((xs Lst)(x5 Nat)) (= (last (append xs (cons x5 nil))) x5))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal49.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun last (Lst) Nat) 5 | (declare-fun butlast (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (last (cons ?x3 ?y)) (ite (= ?y nil) ?x3 (last ?y))) 13 | (=> rule6 (ite (= ?y nil) ?x3 (last ?y)) (last (cons ?x3 ?y))) 14 | (=> rule7 (butlast nil) nil) 15 | (=> rule8 nil (butlast nil)) 16 | (=> rule9 (butlast (cons ?x4 ?y)) (ite (= ?y nil) nil (cons ?x4 (butlast ?y)))) 17 | (=> rule10 (ite (= ?y nil) nil (cons ?x4 (butlast ?y))) (butlast (cons ?x4 ?y))) 18 | (prove (forall ((xs Lst)(ys Lst)) (= (butlast (append xs ys)) (ite (= ys nil) (butlast xs) (append xs (butlast ys)))))) 19 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal33.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun mult (Nat Nat) Nat) 4 | (declare-fun fac (Nat) Nat) 5 | (declare-fun qfac (Nat Nat) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (plus zero ?n) ?n) 10 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 11 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 12 | (=> rule5 (mult zero ?n) zero) 13 | (=> rule6 (mult (succ ?n) ?m) (plus (mult ?n ?m) ?m)) 14 | (=> rule7 (plus (mult ?n ?m) ?m) (mult (succ ?n) ?m)) 15 | (=> rule8 (fac zero) (succ zero)) 16 | (=> rule9 (succ zero) (fac zero)) 17 | (=> rule10 (fac (succ ?n)) (mult (fac ?n) ?n)) 18 | (=> rule11 (mult (fac ?n) ?n) (fac (succ ?n))) 19 | (=> rule12 (qfac zero ?n) ?n) 20 | (=> rule13 (qfac (succ ?n) ?m) (qfac ?n (mult ?m ?n))) 21 | (=> rule14 (qfac ?n (mult ?m ?n)) (qfac (succ ?n) ?m)) 22 | (prove (forall ((x Nat)) (= (fac x) (qfac x (succ zero))))) 23 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal52.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun append (Lst Lst) Lst) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun rev (Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (append nil ?x) ?x) 10 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 11 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 12 | (=> rule5 (count ?x3 nil) zero) 13 | (=> rule6 (count ?x4 (cons ?y5 ?z)) (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z))) 14 | (=> rule7 (ite (= ?x4 ?y5) (succ (count ?x4 ?z)) (count ?x4 ?z)) (count ?x4 (cons ?y5 ?z))) 15 | (=> rule8 (rev nil) nil) 16 | (=> rule9 nil (rev nil)) 17 | (=> rule10 (rev (cons ?x6 ?y)) (append (rev ?y) (cons ?x6 nil))) 18 | (=> rule11 (append (rev ?y) (cons ?x6 nil)) (rev (cons ?x6 ?y))) 19 | (prove (forall ((n Nat)(l Lst)) (= (count n l) (count n (rev l))))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal35.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun mult (Nat Nat) Nat) 4 | (declare-fun exp (Nat Nat) Nat) 5 | (declare-fun qexp (Nat Nat Nat) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (plus zero ?n) ?n) 10 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 11 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 12 | (=> rule5 (mult zero ?n) zero) 13 | (=> rule6 (mult (succ ?n) ?m) (plus (mult ?n ?m) ?m)) 14 | (=> rule7 (plus (mult ?n ?m) ?m) (mult (succ ?n) ?m)) 15 | (=> rule8 (exp ?n zero) (succ zero)) 16 | (=> rule9 (exp ?n (succ ?m)) (mult (exp ?n ?m) ?n)) 17 | (=> rule10 (mult (exp ?n ?m) ?n) (exp ?n (succ ?m))) 18 | (=> rule11 (qexp ?n zero ?m) ?m) 19 | (=> rule12 (qexp ?n (succ ?m) ?p) (qexp ?n ?m (mult ?p ?n))) 20 | (=> rule13 (qexp ?n ?m (mult ?p ?n)) (qexp ?n (succ ?m) ?p)) 21 | (prove (forall ((x Nat)(y Nat)) (= (exp x y) (qexp x y (succ zero))))) 22 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal84.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun mult (Nat Nat) Nat) 4 | (declare-fun fac (Nat) Nat) 5 | (declare-fun qfac (Nat Nat) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (plus zero ?n) ?n) 10 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 11 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 12 | (=> rule5 (mult zero ?n) zero) 13 | (=> rule6 (mult (succ ?n) ?m) (plus (mult ?n ?m) ?m)) 14 | (=> rule7 (plus (mult ?n ?m) ?m) (mult (succ ?n) ?m)) 15 | (=> rule8 (fac zero) (succ zero)) 16 | (=> rule9 (succ zero) (fac zero)) 17 | (=> rule10 (fac (succ ?n)) (mult (fac ?n) ?n)) 18 | (=> rule11 (mult (fac ?n) ?n) (fac (succ ?n))) 19 | (=> rule12 (qfac zero ?n) ?n) 20 | (=> rule13 (qfac (succ ?n) ?m) (qfac ?n (mult ?m ?n))) 21 | (=> rule14 (qfac ?n (mult ?m ?n)) (qfac (succ ?n) ?m)) 22 | (prove (forall ((x Nat)(y Nat)) (= (mult (fac x) y) (qfac x y)))) 23 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal86.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (declare-fun plus (Nat Nat) Nat) 3 | (declare-fun mult (Nat Nat) Nat) 4 | (declare-fun exp (Nat Nat) Nat) 5 | (declare-fun qexp (Nat Nat Nat) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (plus zero ?n) ?n) 10 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 11 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 12 | (=> rule5 (mult zero ?n) zero) 13 | (=> rule6 (mult (succ ?n) ?m) (plus (mult ?n ?m) ?m)) 14 | (=> rule7 (plus (mult ?n ?m) ?m) (mult (succ ?n) ?m)) 15 | (=> rule8 (exp ?n zero) (succ zero)) 16 | (=> rule9 (exp ?n (succ ?m)) (mult (exp ?n ?m) ?n)) 17 | (=> rule10 (mult (exp ?n ?m) ?n) (exp ?n (succ ?m))) 18 | (=> rule11 (qexp ?n zero ?m) ?m) 19 | (=> rule12 (qexp ?n (succ ?m) ?p) (qexp ?n ?m (mult ?p ?n))) 20 | (=> rule13 (qexp ?n ?m (mult ?p ?n)) (qexp ?n (succ ?m) ?p)) 21 | (prove (forall ((x Nat)(y Nat)(z Nat)) (= (mult (exp x y) z) (qexp x y z)))) 22 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal67.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun P (Nat) Bool) 4 | (declare-fun less (Nat Nat) Bool) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun filter (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (len nil) zero) 15 | (=> rule7 zero (len nil)) 16 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 17 | (=> rule9 (filter nil) nil) 18 | (=> rule10 nil (filter nil)) 19 | (=> rule11 (filter (cons ?x ?y3)) (ite (P ?x) (cons ?x (filter ?y3)) (filter ?y3))) 20 | (=> rule12 (ite (P ?x) (cons ?x (filter ?y3)) (filter ?y3)) (filter (cons ?x ?y3))) 21 | (prove (forall ((xs Lst)) (= (or (= (len (filter xs)) (len xs)) (less (len (filter xs)) (len xs))) true))) 22 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal64.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun drop (Nat Lst) Lst) 6 | (declare-fun last (Lst) Nat) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (len nil) zero) 15 | (=> rule7 zero (len nil)) 16 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 17 | (=> rule9 (drop ?x nil) nil) 18 | (=> rule10 (drop zero ?x3) ?x3) 19 | (=> rule11 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 20 | (=> rule12 (last (cons ?x ?y4)) (ite (= ?y4 nil) ?x (last ?y4))) 21 | (=> rule13 (ite (= ?y4 nil) ?x (last ?y4)) (last (cons ?x ?y4))) 22 | (prove (forall ((n Nat)(xs Lst)) (=> (less n (len xs)) (= (last (drop n xs)) (last xs))))) 23 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal44.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun mem (Nat Lst) Bool) 4 | (declare-fun lst-mem (Nat Lst) Bool) 5 | (declare-fun lst-intersection (Lst Lst) Lst) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (mem ?x nil) false) 10 | (=> rule3 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 11 | (=> rule4 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 12 | (=> rule5 (lst-mem ?n ?x2) (mem ?n ?x2)) 13 | (=> rule6 (mem ?n ?x2) (lst-mem ?n ?x2)) 14 | (=> rule7 (lst-intersection nil ?x3) nil) 15 | (=> rule8 (lst-intersection (cons ?n ?x4) ?y5) (ite (lst-mem ?n ?y5) (cons ?n (lst-intersection ?x4 ?y5)) (lst-intersection ?x4 ?y5))) 16 | (=> rule9 (ite (lst-mem ?n ?y5) (cons ?n (lst-intersection ?x4 ?y5)) (lst-intersection ?x4 ?y5)) (lst-intersection (cons ?n ?x4) ?y5)) 17 | (prove (forall ((z Lst)(x Nat)(y6 Lst)) (=> (and (lst-mem x y6) (lst-mem x z)) (lst-mem x (lst-intersection y6 z))))) 18 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal25.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun even (Nat) Bool) 5 | (declare-fun append (Lst Lst) Lst) 6 | (declare-fun len (Lst) Nat) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (plus zero ?n) ?n) 11 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 12 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 13 | (=> rule5 (even zero) true) 14 | (=> rule6 true (even zero)) 15 | (=> rule7 (even (succ ?n)) (not (even ?n))) 16 | (=> rule8 (not (even ?n)) (even (succ ?n))) 17 | (=> rule9 (append nil ?x) ?x) 18 | (=> rule10 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 19 | (=> rule11 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 20 | (=> rule12 (len nil) zero) 21 | (=> rule13 zero (len nil)) 22 | (=> rule14 (len (cons ?x3 ?y)) (succ (len ?y))) 23 | (prove (forall ((y Lst)(x Lst)) (= (even (len (append x y))) (even (plus (len x) (len y)))))) 24 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal3.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun count (Nat Lst) Nat) 6 | (declare-fun leq (Nat Nat) Bool) 7 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 8 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 9 | (=> rule2 (less ?x zero) false) 10 | (=> rule3 (less zero (succ ?x)) true) 11 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 12 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 13 | (=> rule6 (append nil ?x2) ?x2) 14 | (=> rule7 (append (cons ?x ?y3) ?z) (cons ?x (append ?y3 ?z))) 15 | (=> rule8 (cons ?x (append ?y3 ?z)) (append (cons ?x ?y3) ?z)) 16 | (=> rule9 (count ?x nil) zero) 17 | (=> rule10 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 18 | (=> rule11 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 19 | (prove (forall ((n Nat)(l Lst)(m Lst)) (= (or (= (count n l) (count n (append l m))) (less (count n l) (count n (append l m)))) true))) 20 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal59.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (datatype Pair () ((mkpair Nat Nat Pair))) 4 | (datatype ZLst () ((zcons Pair ZLst ZLst) (znil ZLst))) 5 | (declare-fun drop (Nat Lst) Lst) 6 | (declare-fun zip (Lst Lst) ZLst) 7 | (declare-fun zdrop (Nat ZLst) ZLst) 8 | (declare-fun leq (Nat Nat) Bool) 9 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 10 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 11 | (=> rule2 (drop ?x nil) nil) 12 | (=> rule3 (drop zero ?x2) ?x2) 13 | (=> rule4 (drop (succ ?x) (cons ?y ?z)) (drop ?x ?z)) 14 | (=> rule5 (zip nil ?x3) znil) 15 | (=> rule6 (zip ?x4 nil) znil) 16 | (=> rule7 (zip (cons ?x ?y5) (cons ?z6 ?w)) (zcons (mkpair ?x ?z6) (zip ?y5 ?w))) 17 | (=> rule8 (zcons (mkpair ?x ?z6) (zip ?y5 ?w)) (zip (cons ?x ?y5) (cons ?z6 ?w))) 18 | (=> rule9 (zdrop ?x znil) znil) 19 | (=> rule10 (zdrop zero ?x7) ?x7) 20 | (=> rule11 (zdrop (succ ?x) (zcons ?y8 ?z9)) (zdrop ?x ?z9)) 21 | (prove (forall ((n Nat)(xs Lst)(ys Lst)) (= (zdrop n (zip xs ys)) (zip (drop n xs) (drop n ys))))) 22 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal6.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun rev (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (plus zero ?n) ?n) 11 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 12 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 13 | (=> rule5 (append nil ?x) ?x) 14 | (=> rule6 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 15 | (=> rule7 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 16 | (=> rule8 (len nil) zero) 17 | (=> rule9 zero (len nil)) 18 | (=> rule10 (len (cons ?x3 ?y)) (succ (len ?y))) 19 | (=> rule11 (rev nil) nil) 20 | (=> rule12 nil (rev nil)) 21 | (=> rule13 (rev (cons ?x4 ?y)) (append (rev ?y) (cons ?x4 nil))) 22 | (=> rule14 (append (rev ?y) (cons ?x4 nil)) (rev (cons ?x4 ?y))) 23 | (prove (forall ((y Lst)(x Lst)) (= (len (rev (append x y))) (plus (len x) (len y))))) 24 | -------------------------------------------------------------------------------- /examples/add.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Nat (Z S)) 3 | (:: Z Nat) 4 | (:: S (-> (Nat) Nat)) 5 | 6 | (:: add (-> (Nat Nat) Nat)) 7 | (let add (Z ?y) ?y) 8 | (let add ((S ?x) ?y) (S (add ?x ?y))) 9 | 10 | (:: addAccum (-> (Nat Nat Nat) Nat)) 11 | (let addAccum (Z Z ?acc) ?acc) 12 | (let addAccum (Z (S ?n) ?acc) (addAccum Z ?n (S ?acc))) 13 | (let addAccum ((S ?m) ?n ?acc) (addAccum ?m ?n (S ?acc))) 14 | 15 | (:: addAccum2 (-> (Nat Nat) Nat)) 16 | (let addAccum2 (?m ?n) (addAccum ?m ?n Z)) 17 | 18 | (=== add_commutative (n m) (Nat Nat) 19 | (add n m) 20 | (add m n) 21 | ) 22 | 23 | (=== add_accum_move_s (a b c) (Nat Nat Nat) 24 | (addAccum a b (S c)) 25 | (S (addAccum a b c)) 26 | ) 27 | 28 | (=== add_accum_lemma (a b c) (Nat Nat Nat) 29 | (addAccum a b c) 30 | (add (add a b) c) 31 | ((=> (addAccum ?a ?b (S ?c)) (S (addAccum ?a ?b ?c)))) 32 | ) 33 | 34 | (=== add_accum (a b c) (Nat Nat Nat) 35 | (addAccum a b c) 36 | (add (add a b) c) 37 | ) 38 | 39 | (=== add_accum_commutative (a b c) (Nat Nat Nat) 40 | (addAccum a b c) 41 | (addAccum b a c) 42 | ) 43 | 44 | (=== add_accum2_commutative (a b) (Nat Nat) 45 | (addAccum2 a b) 46 | (addAccum2 b a) 47 | ) 48 | 49 | ) 50 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal56.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun drop (Nat Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (minus zero ?n) zero) 11 | (=> rule3 (minus ?n zero) ?n) 12 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (=> rule6 (append nil ?x) ?x) 15 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 16 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 17 | (=> rule9 (len nil) zero) 18 | (=> rule10 zero (len nil)) 19 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 20 | (=> rule12 (drop ?x4 nil) nil) 21 | (=> rule13 (drop zero ?x) ?x) 22 | (=> rule14 (drop (succ ?x5) (cons ?y6 ?z)) (drop ?x5 ?z)) 23 | (prove (forall ((xs Lst)(ys Lst)(n Nat)) (= (drop n (append xs ys)) (append (drop n xs) (drop (minus n (len xs)) ys))))) 24 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal68.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun last (Lst) Nat) 6 | (declare-fun butlast (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (minus zero ?n) zero) 11 | (=> rule3 (minus ?n zero) ?n) 12 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (=> rule6 (len nil) zero) 15 | (=> rule7 zero (len nil)) 16 | (=> rule8 (len (cons ?x ?y)) (succ (len ?y))) 17 | (=> rule9 (last (cons ?x ?y)) (ite (= ?y nil) ?x (last ?y))) 18 | (=> rule10 (ite (= ?y nil) ?x (last ?y)) (last (cons ?x ?y))) 19 | (=> rule11 (butlast nil) nil) 20 | (=> rule12 nil (butlast nil)) 21 | (=> rule13 (butlast (cons ?x ?y)) (ite (= ?y nil) nil (cons ?x (butlast ?y)))) 22 | (=> rule14 (ite (= ?y nil) nil (cons ?x (butlast ?y))) (butlast (cons ?x ?y))) 23 | (prove (forall ((xs Lst)) (= (len (butlast xs)) (minus (len xs) (succ zero))))) 24 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal47.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Tree () ((node Nat Tree Tree Tree) (leaf Tree))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun nmax (Nat Nat) Nat) 5 | (declare-fun mirror (Tree) Tree) 6 | (declare-fun height (Tree) Nat) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (nmax ?n ?m) (ite (less ?n ?m) ?m ?n)) 15 | (=> rule7 (ite (less ?n ?m) ?m ?n) (nmax ?n ?m)) 16 | (=> rule8 (mirror leaf) leaf) 17 | (=> rule9 leaf (mirror leaf)) 18 | (=> rule10 (mirror (node ?x ?y2 ?z)) (node ?x (mirror ?z) (mirror ?y2))) 19 | (=> rule11 (node ?x (mirror ?z) (mirror ?y2)) (mirror (node ?x ?y2 ?z))) 20 | (=> rule12 (height leaf) zero) 21 | (=> rule13 zero (height leaf)) 22 | (=> rule14 (height (node ?x ?y3 ?z)) (succ (nmax (height ?y3) (height ?z)))) 23 | (prove (forall ((a Tree)) (= (height (mirror a)) (height a)))) 24 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal82.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun take (Nat Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (minus zero ?n) zero) 11 | (=> rule3 (minus ?n zero) ?n) 12 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 13 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 14 | (=> rule6 (append nil ?x) ?x) 15 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 16 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 17 | (=> rule9 (len nil) zero) 18 | (=> rule10 zero (len nil)) 19 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 20 | (=> rule12 (take ?x4 nil) nil) 21 | (=> rule13 (take zero ?x) nil) 22 | (=> rule14 (take (succ ?x5) (cons ?y6 ?z)) (cons ?y6 (take ?x5 ?z))) 23 | (=> rule15 (cons ?y6 (take ?x5 ?z)) (take (succ ?x5) (cons ?y6 ?z))) 24 | (prove (forall ((xs Lst)(ys Lst)(n Nat)) (= (take n (append xs ys)) (append (take n xs) (take (minus n (len xs)) ys))))) 25 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal40.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun mem (Nat Lst) Bool) 4 | (declare-fun lst-mem (Nat Lst) Bool) 5 | (declare-fun lst-subset (Lst Lst) Bool) 6 | (declare-fun lst-eq (Lst Lst) Bool) 7 | (declare-fun lst-union (Lst Lst) Lst) 8 | (declare-fun leq (Nat Nat) Bool) 9 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 10 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 11 | (=> rule2 (lst-mem ?n ?x) (mem ?n ?x)) 12 | (=> rule3 (mem ?n ?x) (lst-mem ?n ?x)) 13 | (=> rule4 (lst-subset nil ?x) true) 14 | (=> rule5 (lst-subset (cons ?n ?x) ?y) (and (lst-subset ?x ?y) (lst-mem ?n ?y))) 15 | (=> rule6 (and (lst-subset ?x ?y) (lst-mem ?n ?y)) (lst-subset (cons ?n ?x) ?y)) 16 | (=> rule7 (lst-eq ?x ?y) (and (lst-subset ?x ?y) (lst-subset ?y ?x))) 17 | (=> rule8 (and (lst-subset ?x ?y) (lst-subset ?y ?x)) (lst-eq ?x ?y)) 18 | (=> rule9 (lst-union nil ?x) ?x) 19 | (=> rule10 (lst-union (cons ?n ?x) ?y) (ite (lst-mem ?n ?y) (lst-union ?x ?y) (cons ?n (lst-union ?x ?y)))) 20 | (=> rule11 (ite (lst-mem ?n ?y) (lst-union ?x ?y) (cons ?n (lst-union ?x ?y))) (lst-union (cons ?n ?x) ?y)) 21 | (prove (forall ((y Lst)(x Lst)) (=> (lst-subset x y) (lst-eq (lst-union x y) y)))) 22 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal48.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (len nil) zero) 15 | (=> rule7 zero (len nil)) 16 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y3)) (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3))) (insort ?i (cons ?x ?y3))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 24 | (=> rule16 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 25 | (prove (forall ((x5 Lst)) (= (len (sort x5)) (len x5)))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal20.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (len nil) zero) 15 | (=> rule7 zero (len nil)) 16 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y3)) (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3))) (insort ?i (cons ?x ?y3))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 24 | (=> rule16 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 25 | (prove (forall ((l Lst)) (= (len (sort l)) (len l)))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal84.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (datatype Pair () ((mkpair Nat Nat Pair))) 4 | (datatype ZLst () ((zcons Pair ZLst ZLst) (znil ZLst))) 5 | (declare-fun take (Nat Lst) Lst) 6 | (declare-fun zip (Lst Lst) ZLst) 7 | (declare-fun ztake (Nat ZLst) ZLst) 8 | (declare-fun leq (Nat Nat) Bool) 9 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 10 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 11 | (=> rule2 (take ?x nil) nil) 12 | (=> rule3 (take zero ?x2) nil) 13 | (=> rule4 (take (succ ?x) (cons ?y ?z)) (cons ?y (take ?x ?z))) 14 | (=> rule5 (cons ?y (take ?x ?z)) (take (succ ?x) (cons ?y ?z))) 15 | (=> rule6 (zip nil ?x3) znil) 16 | (=> rule7 (zip ?x4 nil) znil) 17 | (=> rule8 (zip (cons ?x ?y5) (cons ?z6 ?w)) (zcons (mkpair ?x ?z6) (zip ?y5 ?w))) 18 | (=> rule9 (zcons (mkpair ?x ?z6) (zip ?y5 ?w)) (zip (cons ?x ?y5) (cons ?z6 ?w))) 19 | (=> rule10 (ztake ?x znil) znil) 20 | (=> rule11 (ztake zero ?x7) znil) 21 | (=> rule12 (ztake (succ ?x) (zcons ?y8 ?z9)) (zcons ?y8 (ztake ?x ?z9))) 22 | (=> rule13 (zcons ?y8 (ztake ?x ?z9)) (ztake (succ ?x) (zcons ?y8 ?z9))) 23 | (prove (forall ((n Nat)(xs Lst)(ys Lst)) (= (ztake n (zip xs ys)) (zip (take n xs) (take n ys))))) 24 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal68.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (len nil) zero) 15 | (=> rule7 zero (len nil)) 16 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y3)) (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3))) (insort ?i (cons ?x ?y3))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 24 | (=> rule16 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 25 | (prove (forall ((y5 Lst)(x Nat)) (= (len (insort x y5)) (succ (len y5))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal15.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (len nil) zero) 15 | (=> rule7 zero (len nil)) 16 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y3)) (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3))) (insort ?i (cons ?x ?y3))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 24 | (=> rule16 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 25 | (prove (forall ((l Lst)(x Nat)) (= (len (insort x l)) (succ (len l))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal7.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun plus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun rev (Lst) Lst) 7 | (declare-fun qreva (Lst Lst) Lst) 8 | (declare-fun leq (Nat Nat) Bool) 9 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 10 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 11 | (=> rule2 (plus zero ?n) ?n) 12 | (=> rule3 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 13 | (=> rule4 (succ (plus ?n ?m)) (plus (succ ?n) ?m)) 14 | (=> rule5 (append nil ?x) ?x) 15 | (=> rule6 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 16 | (=> rule7 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 17 | (=> rule8 (len nil) zero) 18 | (=> rule9 zero (len nil)) 19 | (=> rule10 (len (cons ?x3 ?y)) (succ (len ?y))) 20 | (=> rule11 (rev nil) nil) 21 | (=> rule12 nil (rev nil)) 22 | (=> rule13 (rev (cons ?x4 ?y)) (append (rev ?y) (cons ?x4 nil))) 23 | (=> rule14 (append (rev ?y) (cons ?x4 nil)) (rev (cons ?x4 ?y))) 24 | (=> rule15 (qreva nil ?x) ?x) 25 | (=> rule16 (qreva (cons ?z5 ?x) ?y) (qreva ?x (cons ?z5 ?y))) 26 | (=> rule17 (qreva ?x (cons ?z5 ?y)) (qreva (cons ?z5 ?x) ?y)) 27 | (prove (forall ((y Lst)(x Lst)) (= (len (qreva x y)) (plus (len x) (len y))))) 28 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal41.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun mem (Nat Lst) Bool) 4 | (declare-fun lst-mem (Nat Lst) Bool) 5 | (declare-fun lst-subset (Lst Lst) Bool) 6 | (declare-fun lst-eq (Lst Lst) Bool) 7 | (declare-fun lst-intersection (Lst Lst) Lst) 8 | (declare-fun leq (Nat Nat) Bool) 9 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 10 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 11 | (=> rule2 (lst-mem ?n ?x) (mem ?n ?x)) 12 | (=> rule3 (mem ?n ?x) (lst-mem ?n ?x)) 13 | (=> rule4 (lst-subset nil ?x) true) 14 | (=> rule5 (lst-subset (cons ?n ?x) ?y) (and (lst-subset ?x ?y) (lst-mem ?n ?y))) 15 | (=> rule6 (and (lst-subset ?x ?y) (lst-mem ?n ?y)) (lst-subset (cons ?n ?x) ?y)) 16 | (=> rule7 (lst-eq ?x ?y) (and (lst-subset ?x ?y) (lst-subset ?y ?x))) 17 | (=> rule8 (and (lst-subset ?x ?y) (lst-subset ?y ?x)) (lst-eq ?x ?y)) 18 | (=> rule9 (lst-intersection nil ?x) nil) 19 | (=> rule10 (lst-intersection (cons ?n ?x) ?y) (ite (lst-mem ?n ?y) (cons ?n (lst-intersection ?x ?y)) (lst-intersection ?x ?y))) 20 | (=> rule11 (ite (lst-mem ?n ?y) (cons ?n (lst-intersection ?x ?y)) (lst-intersection ?x ?y)) (lst-intersection (cons ?n ?x) ?y)) 21 | (prove (forall ((y Lst)(x Lst)) (=> (lst-subset x y) (lst-eq (lst-intersection x y) x)))) 22 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal45.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(y4 Lst)) (= (mem x (insort x y4)) true))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal49.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(y4 Lst)) (=> (mem x (sort y4)) (mem x y4)))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal30.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((l Lst)(x Nat)) (= (mem x (insort x l)) true))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal46.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(z Lst)(y Nat)) (=> (= x y) (mem x (insort y z))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal47.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(z Lst)(y Nat)) (=> (not (= x y)) (= (mem x (insort y z)) (mem x z))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal69.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(z Lst)(y Nat)) (=> (not (= x y)) (=> (mem x (insort y z)) (mem x z))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal72.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((l Lst)(y Nat)(x Nat)) (=> (less x y) (= (mem x (insort y l)) (mem x l))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal73.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun mem (Nat Lst) Bool) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (mem ?x nil) false) 15 | (=> rule7 (mem ?x (cons ?y ?z)) (or (= ?x ?y) (mem ?x ?z))) 16 | (=> rule8 (or (= ?x ?y) (mem ?x ?z)) (mem ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((l Lst)(y Nat)(x Nat)) (=> (not (= x y)) (= (mem x (insort y l)) (mem x l))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal50.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (count ?x nil) zero) 15 | (=> rule7 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 16 | (=> rule8 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(y4 Lst)) (= (count x (sort y4)) (count x y4)))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal53.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (count ?x nil) zero) 15 | (=> rule7 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 16 | (=> rule8 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((l Lst)(x Nat)) (= (count x l) (count x (sort l))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal70.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (count ?x nil) zero) 15 | (=> rule7 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 16 | (=> rule8 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(y4 Lst)) (= (count x (insort x y4)) (succ (count x y4))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal50.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun len (Lst) Nat) 5 | (declare-fun take (Nat Lst) Lst) 6 | (declare-fun last (Lst) Nat) 7 | (declare-fun butlast (Lst) Lst) 8 | (declare-fun leq (Nat Nat) Bool) 9 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 10 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 11 | (=> rule2 (minus zero ?n) zero) 12 | (=> rule3 (minus ?n zero) ?n) 13 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 14 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 15 | (=> rule6 (len nil) zero) 16 | (=> rule7 zero (len nil)) 17 | (=> rule8 (len (cons ?x ?y)) (succ (len ?y))) 18 | (=> rule9 (take ?x nil) nil) 19 | (=> rule10 (take zero ?x2) nil) 20 | (=> rule11 (take (succ ?x) (cons ?y3 ?z)) (cons ?y3 (take ?x ?z))) 21 | (=> rule12 (cons ?y3 (take ?x ?z)) (take (succ ?x) (cons ?y3 ?z))) 22 | (=> rule13 (last (cons ?x ?y)) (ite (= ?y nil) ?x (last ?y))) 23 | (=> rule14 (ite (= ?y nil) ?x (last ?y)) (last (cons ?x ?y))) 24 | (=> rule15 (butlast nil) nil) 25 | (=> rule16 nil (butlast nil)) 26 | (=> rule17 (butlast (cons ?x ?y)) (ite (= ?y nil) nil (cons ?x (butlast ?y)))) 27 | (=> rule18 (ite (= ?y nil) nil (cons ?x (butlast ?y))) (butlast (cons ?x ?y))) 28 | (prove (forall ((xs Lst)) (= (butlast xs) (take (minus (len xs) (succ zero)) xs)))) 29 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal71.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun count (Nat Lst) Nat) 5 | (declare-fun insort (Nat Lst) Lst) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (count ?x nil) zero) 15 | (=> rule7 (count ?x (cons ?y ?z)) (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z))) 16 | (=> rule8 (ite (= ?x ?y) (succ (count ?x ?z)) (count ?x ?z)) (count ?x (cons ?y ?z))) 17 | (=> rule9 (insort ?i nil) (cons ?i nil)) 18 | (=> rule10 (cons ?i nil) (insort ?i nil)) 19 | (=> rule11 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 20 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 21 | (=> rule13 (sort nil) nil) 22 | (=> rule14 nil (sort nil)) 23 | (=> rule15 (sort (cons ?x ?y3)) (insort ?x (sort ?y3))) 24 | (=> rule16 (insort ?x (sort ?y3)) (sort (cons ?x ?y3))) 25 | (prove (forall ((x Nat)(z Lst)(y Nat)) (=> (not (= x y)) (= (count x (insort y z)) (count x z))))) 26 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal14.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun insort (Nat Lst) Lst) 5 | (declare-fun sorted (Lst) Bool) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (insort ?i nil) (cons ?i nil)) 15 | (=> rule7 (cons ?i nil) (insort ?i nil)) 16 | (=> rule8 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 17 | (=> rule9 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 18 | (=> rule10 (sorted nil) true) 19 | (=> rule11 true (sorted nil)) 20 | (=> rule12 (sorted (cons ?x nil)) true) 21 | (=> rule13 (sorted (cons ?x (cons ?z ?y3))) (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z)))) 22 | (=> rule14 (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z))) (sorted (cons ?x (cons ?z ?y3)))) 23 | (=> rule15 (sort nil) nil) 24 | (=> rule16 nil (sort nil)) 25 | (=> rule17 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 26 | (=> rule18 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 27 | (prove (forall ((x5 Lst)) (= (sorted (sort x5)) true))) 28 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal80.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun insort (Nat Lst) Lst) 5 | (declare-fun sorted (Lst) Bool) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (insort ?i nil) (cons ?i nil)) 15 | (=> rule7 (cons ?i nil) (insort ?i nil)) 16 | (=> rule8 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 17 | (=> rule9 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 18 | (=> rule10 (sorted nil) true) 19 | (=> rule11 true (sorted nil)) 20 | (=> rule12 (sorted (cons ?x nil)) true) 21 | (=> rule13 (sorted (cons ?x (cons ?z ?y3))) (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z)))) 22 | (=> rule14 (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z))) (sorted (cons ?x (cons ?z ?y3)))) 23 | (=> rule15 (sort nil) nil) 24 | (=> rule16 nil (sort nil)) 25 | (=> rule17 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 26 | (=> rule18 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 27 | (prove (forall ((l Lst)) (= (sorted (sort l)) true))) 28 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal62.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun insort (Nat Lst) Lst) 5 | (declare-fun sorted (Lst) Bool) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (insort ?i nil) (cons ?i nil)) 15 | (=> rule7 (cons ?i nil) (insort ?i nil)) 16 | (=> rule8 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 17 | (=> rule9 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 18 | (=> rule10 (sorted nil) true) 19 | (=> rule11 true (sorted nil)) 20 | (=> rule12 (sorted (cons ?x nil)) true) 21 | (=> rule13 (sorted (cons ?x (cons ?z ?y3))) (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z)))) 22 | (=> rule14 (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z))) (sorted (cons ?x (cons ?z ?y3)))) 23 | (=> rule15 (sort nil) nil) 24 | (=> rule16 nil (sort nil)) 25 | (=> rule17 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 26 | (=> rule18 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 27 | (prove (forall ((x5 Lst)(y Nat)) (=> (sorted x5) (sorted (insort y x5))))) 28 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal79.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun insort (Nat Lst) Lst) 5 | (declare-fun sorted (Lst) Bool) 6 | (declare-fun sort (Lst) Lst) 7 | (declare-fun leq (Nat Nat) Bool) 8 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 9 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 10 | (=> rule2 (less ?x zero) false) 11 | (=> rule3 (less zero (succ ?x)) true) 12 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 13 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 14 | (=> rule6 (insort ?i nil) (cons ?i nil)) 15 | (=> rule7 (cons ?i nil) (insort ?i nil)) 16 | (=> rule8 (insort ?i (cons ?x ?y2)) (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2)))) 17 | (=> rule9 (ite (less ?i ?x) (cons ?i (cons ?x ?y2)) (cons ?x (insort ?i ?y2))) (insort ?i (cons ?x ?y2))) 18 | (=> rule10 (sorted nil) true) 19 | (=> rule11 true (sorted nil)) 20 | (=> rule12 (sorted (cons ?x nil)) true) 21 | (=> rule13 (sorted (cons ?x (cons ?z ?y3))) (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z)))) 22 | (=> rule14 (and (sorted (cons ?z ?y3)) (or (= ?x ?z) (less ?x ?z))) (sorted (cons ?x (cons ?z ?y3)))) 23 | (=> rule15 (sort nil) nil) 24 | (=> rule16 nil (sort nil)) 25 | (=> rule17 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 26 | (=> rule18 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 27 | (prove (forall ((l Lst)(x Nat)) (=> (sorted l) (sorted (insort x l))))) 28 | -------------------------------------------------------------------------------- /scripts/cache.py: -------------------------------------------------------------------------------- 1 | import json 2 | import os 3 | 4 | def load_cache(cache_path: str): 5 | if not os.path.exists(cache_path): 6 | return {} 7 | with open(cache_path, "r") as inp: 8 | return json.load(inp) 9 | 10 | def backup_cache(cache_path: str): 11 | if not os.path.exists(cache_path): return 12 | name, ext_name = os.path.splitext(cache_path) 13 | name += "_bk" 14 | backup_id = 0 15 | while os.path.exists(name + str(backup_id) + ext_name): 16 | backup_id += 1 17 | backup_path = name + str(backup_id) + ext_name 18 | os.system("cp %s %s" % (cache_path, backup_path)) 19 | 20 | def clear_cache(cache_path: str, cond): 21 | if not os.path.exists(cache_path): return 22 | cache = load_cache(cache_path) 23 | new_cache = {} 24 | for solver_name, solver_res in cache.items(): 25 | new_solver_res = {} 26 | for benchmark_name, res in solver_res.items(): 27 | print(solver_name, benchmark_name) 28 | new_res = list(filter(lambda r: not cond(solver_name, benchmark_name, r), res)) 29 | new_solver_res[benchmark_name] = new_res 30 | if len(solver_res) > len(new_solver_res): print("remove", solver_name, benchmark_name) 31 | new_cache[solver_name] = new_solver_res 32 | save_cache(cache_path, new_cache, False) 33 | 34 | def save_cache(cache_path: str, cache, is_cover: bool): 35 | if os.path.exists(cache_path) and not is_cover: 36 | backup_cache(cache_path) 37 | with open(cache_path, "w") as oup: 38 | json.dump(cache, oup, indent=4) 39 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/synduce-tree-sumtree.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Unit (Null)) 6 | (:: Null Unit) 7 | (data Nat (Zero Succ)) 8 | (:: Zero Nat) 9 | (:: Succ (-> (Nat) Nat)) 10 | (data Tree (Nil Node)) 11 | (:: Nil (-> (Unit) Tree)) 12 | (:: Node (-> (Nat Tree Tree) Tree)) 13 | (:: plus (-> (Nat Nat) Nat)) 14 | (let plus (Zero ?x) ?x) 15 | (let plus ((Succ ?x) ?y) (Succ (plus ?x ?y))) 16 | (:: tf1 (-> (Nat Tree) Nat)) 17 | (let tf1 (?tv4 (Nil ?tv5)) ?tv4) 18 | (let tf1 (?tv4 (Node ?tv6 ?tv7 ?tv8)) (tf0 (plus (tf0 ?tv4 ?tv7) ?tv6) ?tv8)) 19 | (:: tf0 (-> (Nat Tree) Nat)) 20 | (let tf0 (?tv1 ?tv2) (tf1 ?tv1 ?tv2)) 21 | (:: spec (-> (Tree) Nat)) 22 | (let spec (?tv0) (tf0 Zero ?tv0)) 23 | (:: tf3 (-> (Tree) Tree)) 24 | (let tf3 ((Nil ?tv12)) (Nil Null)) 25 | (let tf3 ((Node ?tv13 ?tv14 ?tv15)) (Node ?tv13 (tf2 ?tv14) (tf2 ?tv15))) 26 | (:: tf2 (-> (Tree) Tree)) 27 | (let tf2 (?tv10) (tf3 ?tv10)) 28 | (:: repr (-> (Tree) Tree)) 29 | (let repr (?tv9) (tf2 ?tv9)) 30 | (:: main (-> (Tree) Nat)) 31 | (let main (?tv16) (spec (repr ?tv16))) 32 | (:: tf5 (-> (Tree) Nat)) 33 | (let tf5 ((Nil ?tv20)) Zero) 34 | (let tf5 ((Node ?tv21 ?tv22 ?tv23)) (plus (tf4 ?tv23) (plus (tf4 ?tv22) ?tv21))) 35 | (:: tf4 (-> (Tree) Nat)) 36 | (let tf4 (?tv18) (tf5 ?tv18)) 37 | (:: reprNew (-> (Tree) Nat)) 38 | (let reprNew (?tv17) (tf4 ?tv17)) 39 | (:: mainNew (-> (Tree) Nat)) 40 | (let mainNew (?tv24) (reprNew ?tv24)) 41 | (=== optimize (inp0) (Tree) (main inp0) (mainNew inp0)) 42 | ) 43 | -------------------------------------------------------------------------------- /benchmarks/thesy/optimization/synduce-tree-sumtree.th: -------------------------------------------------------------------------------- 1 | (datatype Bool () ((true Bool) (false Bool))) 2 | (datatype Unit () ((null Unit))) 3 | (datatype Nat () ((zero Nat) (succ Nat Nat))) 4 | (datatype Tree () ((nil Unit Tree) (node Nat Tree Tree Tree))) 5 | (declare-fun plus (Nat Nat) Nat) 6 | (=> plusr0 (plus zero ?x) ?x) 7 | (=> plusr1 (plus (succ ?x) ?y) (succ (plus ?x ?y))) 8 | (declare-fun tf1 (Nat Tree) Nat) 9 | (=> tf1r0 (tf1 ?tv4 (nil ?tv5)) ?tv4) 10 | (=> tf1r1 (tf1 ?tv4 (node ?tv6 ?tv7 ?tv8)) (tf0 (plus (tf0 ?tv4 ?tv7) ?tv6) ?tv8)) 11 | (declare-fun tf0 (Nat Tree) Nat) 12 | (=> tf0r0 (tf0 ?tv1 ?tv2) (tf1 ?tv1 ?tv2)) 13 | (declare-fun spec (Tree) Nat) 14 | (=> specr0 (spec ?tv0) (tf0 zero ?tv0)) 15 | (declare-fun tf3 (Tree) Tree) 16 | (=> tf3r0 (tf3 (nil ?tv12)) (nil null)) 17 | (=> tf3r1 (tf3 (node ?tv13 ?tv14 ?tv15)) (node ?tv13 (tf2 ?tv14) (tf2 ?tv15))) 18 | (declare-fun tf2 (Tree) Tree) 19 | (=> tf2r0 (tf2 ?tv10) (tf3 ?tv10)) 20 | (declare-fun repr (Tree) Tree) 21 | (=> reprr0 (repr ?tv9) (tf2 ?tv9)) 22 | (declare-fun main (Tree) Nat) 23 | (=> mainr0 (main ?tv16) (spec (repr ?tv16))) 24 | (declare-fun tf5 (Tree) Nat) 25 | (=> tf5r0 (tf5 (nil ?tv20)) zero) 26 | (=> tf5r1 (tf5 (node ?tv21 ?tv22 ?tv23)) (plus (tf4 ?tv23) (plus (tf4 ?tv22) ?tv21))) 27 | (declare-fun tf4 (Tree) Nat) 28 | (=> tf4r0 (tf4 ?tv18) (tf5 ?tv18)) 29 | (declare-fun repr_ (Tree) Nat) 30 | (=> repr_r0 (repr_ ?tv17) (tf4 ?tv17)) 31 | (declare-fun main_ (Tree) Nat) 32 | (=> main_r0 (main_ ?tv24) (repr_ ?tv24)) 33 | (prove (forall ((inp0 Tree)) (= (main inp0) (main_ inp0)))) 34 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal28.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (datatype Tree () ((node Nat Tree Tree Tree) (leaf Tree))) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun rev (Lst) Lst) 6 | (declare-fun qreva (Lst Lst) Lst) 7 | (declare-fun revflat (Tree) Lst) 8 | (declare-fun qrevaflat (Tree Lst) Lst) 9 | (declare-fun leq (Nat Nat) Bool) 10 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 11 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 12 | (=> rule2 (qrevaflat leaf ?x) ?x) 13 | (=> rule3 (qrevaflat (node ?d ?l ?r) ?x) (qrevaflat ?l (cons ?d (qrevaflat ?r ?x)))) 14 | (=> rule4 (qrevaflat ?l (cons ?d (qrevaflat ?r ?x))) (qrevaflat (node ?d ?l ?r) ?x)) 15 | (=> rule5 (append nil ?x) ?x) 16 | (=> rule6 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 17 | (=> rule7 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 18 | (=> rule8 (rev nil) nil) 19 | (=> rule9 nil (rev nil)) 20 | (=> rule10 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 21 | (=> rule11 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 22 | (=> rule12 (qreva nil ?x) ?x) 23 | (=> rule13 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 24 | (=> rule14 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 25 | (=> rule15 (revflat leaf) nil) 26 | (=> rule16 nil (revflat leaf)) 27 | (=> rule17 (revflat (node ?d ?l ?r)) (append (revflat ?l) (cons ?d (revflat ?r)))) 28 | (=> rule18 (append (revflat ?l) (cons ?d (revflat ?r))) (revflat (node ?d ?l ?r))) 29 | (prove (forall ((x5 Tree)) (= (revflat x5) (qrevaflat x5 nil)))) 30 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal43.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun P (Nat) Bool) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun drop (Nat Lst) Lst) 6 | (declare-fun take (Nat Lst) Lst) 7 | (declare-fun dropWhile (Lst) Lst) 8 | (declare-fun takeWhile (Lst) Lst) 9 | (declare-fun leq (Nat Nat) Bool) 10 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 11 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 12 | (=> rule2 (append nil ?x) ?x) 13 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 14 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 15 | (=> rule5 (drop ?x3 nil) nil) 16 | (=> rule6 (drop zero ?x) ?x) 17 | (=> rule7 (drop (succ ?x4) (cons ?y5 ?z)) (drop ?x4 ?z)) 18 | (=> rule8 (take ?x6 nil) nil) 19 | (=> rule9 (take zero ?x) nil) 20 | (=> rule10 (take (succ ?x7) (cons ?y8 ?z)) (cons ?y8 (take ?x7 ?z))) 21 | (=> rule11 (cons ?y8 (take ?x7 ?z)) (take (succ ?x7) (cons ?y8 ?z))) 22 | (=> rule12 (dropWhile nil) nil) 23 | (=> rule13 nil (dropWhile nil)) 24 | (=> rule14 (dropWhile (cons ?x9 ?y)) (ite (P ?x9) (dropWhile ?y) (cons ?x9 ?y))) 25 | (=> rule15 (ite (P ?x9) (dropWhile ?y) (cons ?x9 ?y)) (dropWhile (cons ?x9 ?y))) 26 | (=> rule16 (takeWhile nil) nil) 27 | (=> rule17 nil (takeWhile nil)) 28 | (=> rule18 (takeWhile (cons ?x10 ?y)) (ite (P ?x10) (cons ?x10 (takeWhile ?y)) nil)) 29 | (=> rule19 (ite (P ?x10) (cons ?x10 (takeWhile ?y)) nil) (takeWhile (cons ?x10 ?y))) 30 | (prove (forall ((xs Lst)) (= (append (takeWhile xs) (dropWhile xs)) xs))) 31 | -------------------------------------------------------------------------------- /benchmarks/thesy/clam/goal76.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (datatype Tree () ((node Nat Tree Tree Tree) (leaf Tree))) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun rev (Lst) Lst) 6 | (declare-fun qreva (Lst Lst) Lst) 7 | (declare-fun revflat (Tree) Lst) 8 | (declare-fun qrevaflat (Tree Lst) Lst) 9 | (declare-fun leq (Nat Nat) Bool) 10 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 11 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 12 | (=> rule2 (qrevaflat leaf ?x) ?x) 13 | (=> rule3 (qrevaflat (node ?d ?l ?r) ?x) (qrevaflat ?l (cons ?d (qrevaflat ?r ?x)))) 14 | (=> rule4 (qrevaflat ?l (cons ?d (qrevaflat ?r ?x))) (qrevaflat (node ?d ?l ?r) ?x)) 15 | (=> rule5 (append nil ?x) ?x) 16 | (=> rule6 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 17 | (=> rule7 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 18 | (=> rule8 (rev nil) nil) 19 | (=> rule9 nil (rev nil)) 20 | (=> rule10 (rev (cons ?x3 ?y)) (append (rev ?y) (cons ?x3 nil))) 21 | (=> rule11 (append (rev ?y) (cons ?x3 nil)) (rev (cons ?x3 ?y))) 22 | (=> rule12 (qreva nil ?x) ?x) 23 | (=> rule13 (qreva (cons ?z4 ?x) ?y) (qreva ?x (cons ?z4 ?y))) 24 | (=> rule14 (qreva ?x (cons ?z4 ?y)) (qreva (cons ?z4 ?x) ?y)) 25 | (=> rule15 (revflat leaf) nil) 26 | (=> rule16 nil (revflat leaf)) 27 | (=> rule17 (revflat (node ?d ?l ?r)) (append (revflat ?l) (cons ?d (revflat ?r)))) 28 | (=> rule18 (append (revflat ?l) (cons ?d (revflat ?r))) (revflat (node ?d ?l ?r))) 29 | (prove (forall ((x5 Tree)(y Lst)) (= (append (revflat x5) y) (qrevaflat x5 y)))) 30 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal74.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun drop (Nat Lst) Lst) 7 | (declare-fun take (Nat Lst) Lst) 8 | (declare-fun rev (Lst) Lst) 9 | (declare-fun leq (Nat Nat) Bool) 10 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 11 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 12 | (=> rule2 (minus zero ?n) zero) 13 | (=> rule3 (minus ?n zero) ?n) 14 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 15 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 16 | (=> rule6 (append nil ?x) ?x) 17 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 18 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 19 | (=> rule9 (len nil) zero) 20 | (=> rule10 zero (len nil)) 21 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 22 | (=> rule12 (drop ?x4 nil) nil) 23 | (=> rule13 (drop zero ?x) ?x) 24 | (=> rule14 (drop (succ ?x5) (cons ?y6 ?z)) (drop ?x5 ?z)) 25 | (=> rule15 (take ?x7 nil) nil) 26 | (=> rule16 (take zero ?x) nil) 27 | (=> rule17 (take (succ ?x8) (cons ?y9 ?z)) (cons ?y9 (take ?x8 ?z))) 28 | (=> rule18 (cons ?y9 (take ?x8 ?z)) (take (succ ?x8) (cons ?y9 ?z))) 29 | (=> rule19 (rev nil) nil) 30 | (=> rule20 nil (rev nil)) 31 | (=> rule21 (rev (cons ?x10 ?y)) (append (rev ?y) (cons ?x10 nil))) 32 | (=> rule22 (append (rev ?y) (cons ?x10 nil)) (rev (cons ?x10 ?y))) 33 | (prove (forall ((i Nat)(xs Lst)) (= (rev (drop i xs)) (take (minus (len xs) i) (rev xs))))) 34 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal76.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun minus (Nat Nat) Nat) 4 | (declare-fun append (Lst Lst) Lst) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun drop (Nat Lst) Lst) 7 | (declare-fun take (Nat Lst) Lst) 8 | (declare-fun rev (Lst) Lst) 9 | (declare-fun leq (Nat Nat) Bool) 10 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 11 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 12 | (=> rule2 (minus zero ?n) zero) 13 | (=> rule3 (minus ?n zero) ?n) 14 | (=> rule4 (minus (succ ?n) (succ ?m)) (minus ?n ?m)) 15 | (=> rule5 (minus ?n ?m) (minus (succ ?n) (succ ?m))) 16 | (=> rule6 (append nil ?x) ?x) 17 | (=> rule7 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 18 | (=> rule8 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 19 | (=> rule9 (len nil) zero) 20 | (=> rule10 zero (len nil)) 21 | (=> rule11 (len (cons ?x3 ?y)) (succ (len ?y))) 22 | (=> rule12 (drop ?x4 nil) nil) 23 | (=> rule13 (drop zero ?x) ?x) 24 | (=> rule14 (drop (succ ?x5) (cons ?y6 ?z)) (drop ?x5 ?z)) 25 | (=> rule15 (take ?x7 nil) nil) 26 | (=> rule16 (take zero ?x) nil) 27 | (=> rule17 (take (succ ?x8) (cons ?y9 ?z)) (cons ?y9 (take ?x8 ?z))) 28 | (=> rule18 (cons ?y9 (take ?x8 ?z)) (take (succ ?x8) (cons ?y9 ?z))) 29 | (=> rule19 (rev nil) nil) 30 | (=> rule20 nil (rev nil)) 31 | (=> rule21 (rev (cons ?x10 ?y)) (append (rev ?y) (cons ?x10 nil))) 32 | (=> rule22 (append (rev ?y) (cons ?x10 nil)) (rev (cons ?x10 ?y))) 33 | (prove (forall ((i Nat)(xs Lst)) (= (rev (take i xs)) (drop (minus (len xs) i) (rev xs))))) 34 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/autolifter-single-pass-length.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Nat (Zero Succ)) 6 | (:: Zero Nat) 7 | (:: Succ (-> (Nat) Nat)) 8 | (data Unit (Null)) 9 | (:: Null Unit) 10 | (data List (Cons Nil)) 11 | (:: Cons (-> (Nat List) List)) 12 | (:: Nil (-> (Unit) List)) 13 | (:: tf1 (-> (List List) List)) 14 | (let tf1 (?tv4 (Nil ?tv5)) ?tv4) 15 | (let tf1 (?tv4 (Cons ?tv6 ?tv7)) (Cons ?tv6 (tf0 ?tv7))) 16 | (:: tf0 (-> (List) List)) 17 | (let tf0 (?tv2) (tf1 ?tv2 ?tv2)) 18 | (:: tf2 (-> (List) Nat)) 19 | (let tf2 (?tv9) (length (tf0 ?tv9))) 20 | (:: singlepass (-> (List) Nat)) 21 | (let singlepass (?tv1) (tf2 ?tv1)) 22 | (:: plus (-> (Nat) Nat)) 23 | (let plus (Zero) (Succ Zero)) 24 | (let plus ((Succ ?x)) (Succ (plus ?x))) 25 | (:: tf4 (-> (List) Nat)) 26 | (let tf4 ((Cons ?tv13 ?tv14)) (plus (tf3 ?tv14))) 27 | (let tf4 ((Nil ?tv15)) Zero) 28 | (:: tf3 (-> (List) Nat)) 29 | (let tf3 (?tv11) (tf4 ?tv11)) 30 | (:: length (-> (List) Nat)) 31 | (let length (?tv10) (tf3 ?tv10)) 32 | (:: main (-> (List) Nat)) 33 | (let main (?tv16) (singlepass ?tv16)) 34 | (:: tf6 (-> (List) Nat)) 35 | (let tf6 ((Nil ?tv21)) Zero) 36 | (let tf6 ((Cons ?tv22 ?tv23)) (plus (tf5 ?tv23))) 37 | (:: tf5 (-> (List) Nat)) 38 | (let tf5 (?tv19) (tf6 ?tv19)) 39 | (:: tf7 (-> (List) Nat)) 40 | (let tf7 (?tv24) (tf5 ?tv24)) 41 | (:: singlepassNew (-> (List) Nat)) 42 | (let singlepassNew (?tv18) (tf7 ?tv18)) 43 | (:: mainNew (-> (List) Nat)) 44 | (let mainNew (?tv25) (singlepassNew ?tv25)) 45 | (=== optimize (inp0) (List) (main inp0) (mainNew inp0)) 46 | ) 47 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/autolifter-single-pass-sum.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Nat (Zero Succ)) 6 | (:: Zero Nat) 7 | (:: Succ (-> (Nat) Nat)) 8 | (data Unit (Null)) 9 | (:: Null Unit) 10 | (data List (Cons Nil)) 11 | (:: Cons (-> (Nat List) List)) 12 | (:: Nil (-> (Unit) List)) 13 | (:: tf1 (-> (List List) List)) 14 | (let tf1 (?tv4 (Nil ?tv5)) ?tv4) 15 | (let tf1 (?tv4 (Cons ?tv6 ?tv7)) (Cons ?tv6 (tf0 ?tv7))) 16 | (:: tf0 (-> (List) List)) 17 | (let tf0 (?tv2) (tf1 ?tv2 ?tv2)) 18 | (:: tf2 (-> (List) Nat)) 19 | (let tf2 (?tv9) (sum (tf0 ?tv9))) 20 | (:: singlepass (-> (List) Nat)) 21 | (let singlepass (?tv1) (tf2 ?tv1)) 22 | (:: plus (-> (Nat Nat) Nat)) 23 | (let plus (Zero ?x) ?x) 24 | (let plus ((Succ ?x) ?y) (Succ (plus ?x ?y))) 25 | (:: tf4 (-> (List) Nat)) 26 | (let tf4 ((Nil ?tv13)) Zero) 27 | (let tf4 ((Cons ?tv14 ?tv15)) (plus ?tv14 (tf3 ?tv15))) 28 | (:: tf3 (-> (List) Nat)) 29 | (let tf3 (?tv11) (tf4 ?tv11)) 30 | (:: sum (-> (List) Nat)) 31 | (let sum (?tv10) (tf3 ?tv10)) 32 | (:: main (-> (List) Nat)) 33 | (let main (?tv16) (singlepass ?tv16)) 34 | (:: tf6 (-> (List) Nat)) 35 | (let tf6 ((Nil ?tv21)) Zero) 36 | (let tf6 ((Cons ?tv22 ?tv23)) (plus ?tv22 (tf5 ?tv23))) 37 | (:: tf5 (-> (List) Nat)) 38 | (let tf5 (?tv19) (tf6 ?tv19)) 39 | (:: tf7 (-> (List) Nat)) 40 | (let tf7 (?tv24) (tf5 ?tv24)) 41 | (:: singlepassNew (-> (List) Nat)) 42 | (let singlepassNew (?tv18) (tf7 ?tv18)) 43 | (:: mainNew (-> (List) Nat)) 44 | (let mainNew (?tv25) (singlepassNew ?tv25)) 45 | (=== optimize (inp0) (List) (main inp0) (mainNew inp0)) 46 | ) 47 | -------------------------------------------------------------------------------- /benchmarks/thesy/optimization/autolifter-single-pass-length.th: -------------------------------------------------------------------------------- 1 | (datatype Bool () ((true Bool) (false Bool))) 2 | (datatype Nat () ((zero Nat) (succ Nat Nat))) 3 | (datatype Unit () ((null Unit))) 4 | (datatype List () ((cons Nat List List) (nil Unit List))) 5 | (declare-fun tf1 (List List) List) 6 | (=> tf1r0 (tf1 ?tv4 (nil ?tv5)) ?tv4) 7 | (=> tf1r1 (tf1 ?tv4 (cons ?tv6 ?tv7)) (cons ?tv6 (tf0 ?tv7))) 8 | (declare-fun tf0 (List) List) 9 | (=> tf0r0 (tf0 ?tv2) (tf1 ?tv2 ?tv2)) 10 | (declare-fun tf2 (List) Nat) 11 | (=> tf2r0 (tf2 ?tv9) (length (tf0 ?tv9))) 12 | (declare-fun single_pass (List) Nat) 13 | (=> single_passr0 (single_pass ?tv1) (tf2 ?tv1)) 14 | (declare-fun plus (Nat) Nat) 15 | (=> plusr0 (plus zero) (succ zero)) 16 | (=> plusr1 (plus (succ ?x)) (succ (plus ?x))) 17 | (declare-fun tf4 (List) Nat) 18 | (=> tf4r0 (tf4 (cons ?tv13 ?tv14)) (plus (tf3 ?tv14))) 19 | (=> tf4r1 (tf4 (nil ?tv15)) zero) 20 | (declare-fun tf3 (List) Nat) 21 | (=> tf3r0 (tf3 ?tv11) (tf4 ?tv11)) 22 | (declare-fun length (List) Nat) 23 | (=> lengthr0 (length ?tv10) (tf3 ?tv10)) 24 | (declare-fun main (List) Nat) 25 | (=> mainr0 (main ?tv16) (single_pass ?tv16)) 26 | (declare-fun tf6 (List) Nat) 27 | (=> tf6r0 (tf6 (nil ?tv21)) zero) 28 | (=> tf6r1 (tf6 (cons ?tv22 ?tv23)) (plus (tf5 ?tv23))) 29 | (declare-fun tf5 (List) Nat) 30 | (=> tf5r0 (tf5 ?tv19) (tf6 ?tv19)) 31 | (declare-fun tf7 (List) Nat) 32 | (=> tf7r0 (tf7 ?tv24) (tf5 ?tv24)) 33 | (declare-fun single_pass_ (List) Nat) 34 | (=> single_pass_r0 (single_pass_ ?tv18) (tf7 ?tv18)) 35 | (declare-fun main_ (List) Nat) 36 | (=> main_r0 (main_ ?tv25) (single_pass_ ?tv25)) 37 | (prove (forall ((inp0 List)) (= (main inp0) (main_ inp0)))) 38 | -------------------------------------------------------------------------------- /benchmarks/thesy/optimization/autolifter-single-pass-sum.th: -------------------------------------------------------------------------------- 1 | (datatype Bool () ((true Bool) (false Bool))) 2 | (datatype Nat () ((zero Nat) (succ Nat Nat))) 3 | (datatype Unit () ((null Unit))) 4 | (datatype List () ((cons Nat List List) (nil Unit List))) 5 | (declare-fun tf1 (List List) List) 6 | (=> tf1r0 (tf1 ?tv4 (nil ?tv5)) ?tv4) 7 | (=> tf1r1 (tf1 ?tv4 (cons ?tv6 ?tv7)) (cons ?tv6 (tf0 ?tv7))) 8 | (declare-fun tf0 (List) List) 9 | (=> tf0r0 (tf0 ?tv2) (tf1 ?tv2 ?tv2)) 10 | (declare-fun tf2 (List) Nat) 11 | (=> tf2r0 (tf2 ?tv9) (sum (tf0 ?tv9))) 12 | (declare-fun single_pass (List) Nat) 13 | (=> single_passr0 (single_pass ?tv1) (tf2 ?tv1)) 14 | (declare-fun plus (Nat Nat) Nat) 15 | (=> plusr0 (plus zero ?x) ?x) 16 | (=> plusr1 (plus (succ ?x) ?y) (succ (plus ?x ?y))) 17 | (declare-fun tf4 (List) Nat) 18 | (=> tf4r0 (tf4 (nil ?tv13)) zero) 19 | (=> tf4r1 (tf4 (cons ?tv14 ?tv15)) (plus ?tv14 (tf3 ?tv15))) 20 | (declare-fun tf3 (List) Nat) 21 | (=> tf3r0 (tf3 ?tv11) (tf4 ?tv11)) 22 | (declare-fun sum (List) Nat) 23 | (=> sumr0 (sum ?tv10) (tf3 ?tv10)) 24 | (declare-fun main (List) Nat) 25 | (=> mainr0 (main ?tv16) (single_pass ?tv16)) 26 | (declare-fun tf6 (List) Nat) 27 | (=> tf6r0 (tf6 (nil ?tv21)) zero) 28 | (=> tf6r1 (tf6 (cons ?tv22 ?tv23)) (plus ?tv22 (tf5 ?tv23))) 29 | (declare-fun tf5 (List) Nat) 30 | (=> tf5r0 (tf5 ?tv19) (tf6 ?tv19)) 31 | (declare-fun tf7 (List) Nat) 32 | (=> tf7r0 (tf7 ?tv24) (tf5 ?tv24)) 33 | (declare-fun single_pass_ (List) Nat) 34 | (=> single_pass_r0 (single_pass_ ?tv18) (tf7 ?tv18)) 35 | (declare-fun main_ (List) Nat) 36 | (=> main_r0 (main_ ?tv25) (single_pass_ ?tv25)) 37 | (prove (forall ((inp0 List)) (= (main inp0) (main_ inp0)))) 38 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/fusion-deforestation-page7-2.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Nat (Zero Succ)) 6 | (:: Zero Nat) 7 | (:: Succ (-> (Nat) Nat)) 8 | (data Tree (Leaf Branch)) 9 | (:: Leaf (-> (Nat) Tree)) 10 | (:: Branch (-> (Tree Tree) Tree)) 11 | (:: plus (-> (Nat Nat) Nat)) 12 | (let plus (Zero ?x) ?x) 13 | (let plus ((Succ ?x) ?y) (Succ (plus ?x ?y))) 14 | (:: times (-> (Nat Nat) Nat)) 15 | (let times (Zero ?x) Zero) 16 | (let times ((Succ ?x) ?y) (plus (times ?x ?y) ?y)) 17 | (:: square (-> (Nat) Nat)) 18 | (let square (?tv0) (times ?tv0 ?tv0)) 19 | (:: tf1 (-> (Tree) Tree)) 20 | (let tf1 ((Leaf ?tv4)) (Leaf (square ?tv4))) 21 | (let tf1 ((Branch ?tv5 ?tv6)) (Branch (tf0 ?tv5) (tf0 ?tv6))) 22 | (:: tf0 (-> (Tree) Tree)) 23 | (let tf0 (?tv2) (tf1 ?tv2)) 24 | (:: squaretr (-> (Tree) Tree)) 25 | (let squaretr (?tv1) (tf0 ?tv1)) 26 | (:: tf3 (-> (Tree) Nat)) 27 | (let tf3 ((Leaf ?tv10)) ?tv10) 28 | (let tf3 ((Branch ?tv11 ?tv12)) (plus (tf2 ?tv11) (tf2 ?tv12))) 29 | (:: tf2 (-> (Tree) Nat)) 30 | (let tf2 (?tv8) (tf3 ?tv8)) 31 | (:: sumtr (-> (Tree) Nat)) 32 | (let sumtr (?tv7) (tf2 ?tv7)) 33 | (:: main (-> (Tree) Nat)) 34 | (let main (?tv13) (sumtr (squaretr ?tv13))) 35 | (:: tf5 (-> (Tree) Nat)) 36 | (let tf5 ((Leaf ?tv17)) (square ?tv17)) 37 | (let tf5 ((Branch ?tv18 ?tv19)) (plus (tf4 ?tv18) (tf4 ?tv19))) 38 | (:: tf4 (-> (Tree) Nat)) 39 | (let tf4 (?tv15) (tf5 ?tv15)) 40 | (:: squaretrNew (-> (Tree) Nat)) 41 | (let squaretrNew (?tv14) (tf4 ?tv14)) 42 | (:: mainNew (-> (Tree) Nat)) 43 | (let mainNew (?tv20) (squaretrNew ?tv20)) 44 | (=== optimize (inp0) (Tree) (main inp0) (mainNew inp0)) 45 | ) 46 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/synduce-list-last.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Nat (Zero Succ)) 6 | (:: Zero Nat) 7 | (:: Succ (-> (Nat) Nat)) 8 | (data List (Elt Cons)) 9 | (:: Elt (-> (Nat) List)) 10 | (:: Cons (-> (Nat List) List)) 11 | (data CList (Single Concat)) 12 | (:: Single (-> (Nat) CList)) 13 | (:: Concat (-> (CList CList) CList)) 14 | (:: tf1 (-> (List) Nat)) 15 | (let tf1 ((Elt ?tv3)) ?tv3) 16 | (let tf1 ((Cons ?tv4 ?tv5)) (tf0 ?tv5)) 17 | (:: tf0 (-> (List) Nat)) 18 | (let tf0 (?tv1) (tf1 ?tv1)) 19 | (:: spec (-> (List) Nat)) 20 | (let spec (?tv0) (tf0 ?tv0)) 21 | (:: tf3 (-> (List List) List)) 22 | (let tf3 (?tv11 (Elt ?tv12)) (Cons ?tv12 ?tv11)) 23 | (let tf3 (?tv11 (Cons ?tv13 ?tv14)) (Cons ?tv13 (tf2 ?tv14 ?tv11))) 24 | (:: tf2 (-> (List List) List)) 25 | (let tf2 (?tv8 ?tv9) (tf3 ?tv9 ?tv8)) 26 | (:: cat (-> (List List) List)) 27 | (let cat (?tv6 ?tv7) (tf2 ?tv6 ?tv7)) 28 | (:: tf5 (-> (CList) List)) 29 | (let tf5 ((Single ?tv18)) (Elt ?tv18)) 30 | (let tf5 ((Concat ?tv19 ?tv20)) (cat (tf4 ?tv19) (tf4 ?tv20))) 31 | (:: tf4 (-> (CList) List)) 32 | (let tf4 (?tv16) (tf5 ?tv16)) 33 | (:: repr (-> (CList) List)) 34 | (let repr (?tv15) (tf4 ?tv15)) 35 | (:: main (-> (CList) Nat)) 36 | (let main (?tv21) (spec (repr ?tv21))) 37 | (:: tf7 (-> (CList) Nat)) 38 | (let tf7 ((Single ?tv25)) ?tv25) 39 | (let tf7 ((Concat ?tv26 ?tv27)) (tf6 ?tv27)) 40 | (:: tf6 (-> (CList) Nat)) 41 | (let tf6 (?tv23) (tf7 ?tv23)) 42 | (:: reprNew (-> (CList) Nat)) 43 | (let reprNew (?tv22) (tf6 ?tv22)) 44 | (:: mainNew (-> (CList) Nat)) 45 | (let mainNew (?tv28) (reprNew ?tv28)) 46 | (=== optimize (inp0) (CList) (main inp0) (mainNew inp0)) 47 | ) 48 | -------------------------------------------------------------------------------- /benchmarks/thesy/optimization/synduce-list-last.th: -------------------------------------------------------------------------------- 1 | (datatype Bool () ((true Bool) (false Bool))) 2 | (datatype Nat () ((zero Nat) (succ Nat Nat))) 3 | (datatype List () ((elt Nat List) (cons Nat List List))) 4 | (datatype CList () ((single Nat CList) (concat CList CList CList))) 5 | (declare-fun tf1 (List) Nat) 6 | (=> tf1r0 (tf1 (elt ?tv3)) ?tv3) 7 | (=> tf1r1 (tf1 (cons ?tv4 ?tv5)) (tf0 ?tv5)) 8 | (declare-fun tf0 (List) Nat) 9 | (=> tf0r0 (tf0 ?tv1) (tf1 ?tv1)) 10 | (declare-fun spec (List) Nat) 11 | (=> specr0 (spec ?tv0) (tf0 ?tv0)) 12 | (declare-fun tf3 (List List) List) 13 | (=> tf3r0 (tf3 ?tv11 (elt ?tv12)) (cons ?tv12 ?tv11)) 14 | (=> tf3r1 (tf3 ?tv11 (cons ?tv13 ?tv14)) (cons ?tv13 (tf2 ?tv14 ?tv11))) 15 | (declare-fun tf2 (List List) List) 16 | (=> tf2r0 (tf2 ?tv8 ?tv9) (tf3 ?tv9 ?tv8)) 17 | (declare-fun cat (List List) List) 18 | (=> catr0 (cat ?tv6 ?tv7) (tf2 ?tv6 ?tv7)) 19 | (declare-fun tf5 (CList) List) 20 | (=> tf5r0 (tf5 (single ?tv18)) (elt ?tv18)) 21 | (=> tf5r1 (tf5 (concat ?tv19 ?tv20)) (cat (tf4 ?tv19) (tf4 ?tv20))) 22 | (declare-fun tf4 (CList) List) 23 | (=> tf4r0 (tf4 ?tv16) (tf5 ?tv16)) 24 | (declare-fun repr (CList) List) 25 | (=> reprr0 (repr ?tv15) (tf4 ?tv15)) 26 | (declare-fun main (CList) Nat) 27 | (=> mainr0 (main ?tv21) (spec (repr ?tv21))) 28 | (declare-fun tf7 (CList) Nat) 29 | (=> tf7r0 (tf7 (single ?tv25)) ?tv25) 30 | (=> tf7r1 (tf7 (concat ?tv26 ?tv27)) (tf6 ?tv27)) 31 | (declare-fun tf6 (CList) Nat) 32 | (=> tf6r0 (tf6 ?tv23) (tf7 ?tv23)) 33 | (declare-fun repr_ (CList) Nat) 34 | (=> repr_r0 (repr_ ?tv22) (tf6 ?tv22)) 35 | (declare-fun main_ (CList) Nat) 36 | (=> main_r0 (main_ ?tv28) (repr_ ?tv28)) 37 | (prove (forall ((inp0 CList)) (= (main inp0) (main_ inp0)))) 38 | -------------------------------------------------------------------------------- /benchmarks/thesy/optimization/fusion-deforestation-page7-2.th: -------------------------------------------------------------------------------- 1 | (datatype Bool () ((true Bool) (false Bool))) 2 | (datatype Nat () ((zero Nat) (succ Nat Nat))) 3 | (datatype Tree () ((leaf Nat Tree) (branch Tree Tree Tree))) 4 | (declare-fun plus (Nat Nat) Nat) 5 | (=> plusr0 (plus zero ?x) ?x) 6 | (=> plusr1 (plus (succ ?x) ?y) (succ (plus ?x ?y))) 7 | (declare-fun times (Nat Nat) Nat) 8 | (=> timesr0 (times zero ?x) zero) 9 | (=> timesr1 (times (succ ?x) ?y) (plus (times ?x ?y) ?y)) 10 | (declare-fun square (Nat) Nat) 11 | (=> squarer0 (square ?tv0) (times ?tv0 ?tv0)) 12 | (declare-fun tf1 (Tree) Tree) 13 | (=> tf1r0 (tf1 (leaf ?tv4)) (leaf (square ?tv4))) 14 | (=> tf1r1 (tf1 (branch ?tv5 ?tv6)) (branch (tf0 ?tv5) (tf0 ?tv6))) 15 | (declare-fun tf0 (Tree) Tree) 16 | (=> tf0r0 (tf0 ?tv2) (tf1 ?tv2)) 17 | (declare-fun squaretr (Tree) Tree) 18 | (=> squaretrr0 (squaretr ?tv1) (tf0 ?tv1)) 19 | (declare-fun tf3 (Tree) Nat) 20 | (=> tf3r0 (tf3 (leaf ?tv10)) ?tv10) 21 | (=> tf3r1 (tf3 (branch ?tv11 ?tv12)) (plus (tf2 ?tv11) (tf2 ?tv12))) 22 | (declare-fun tf2 (Tree) Nat) 23 | (=> tf2r0 (tf2 ?tv8) (tf3 ?tv8)) 24 | (declare-fun sumtr (Tree) Nat) 25 | (=> sumtrr0 (sumtr ?tv7) (tf2 ?tv7)) 26 | (declare-fun main (Tree) Nat) 27 | (=> mainr0 (main ?tv13) (sumtr (squaretr ?tv13))) 28 | (declare-fun tf5 (Tree) Nat) 29 | (=> tf5r0 (tf5 (leaf ?tv17)) (square ?tv17)) 30 | (=> tf5r1 (tf5 (branch ?tv18 ?tv19)) (plus (tf4 ?tv18) (tf4 ?tv19))) 31 | (declare-fun tf4 (Tree) Nat) 32 | (=> tf4r0 (tf4 ?tv15) (tf5 ?tv15)) 33 | (declare-fun squaretr_ (Tree) Nat) 34 | (=> squaretr_r0 (squaretr_ ?tv14) (tf4 ?tv14)) 35 | (declare-fun main_ (Tree) Nat) 36 | (=> main_r0 (main_ ?tv20) (squaretr_ ?tv20)) 37 | (prove (forall ((inp0 Tree)) (= (main inp0) (main_ inp0)))) 38 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/synduce-tree-maxtree.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Unit (Null)) 6 | (:: Null Unit) 7 | (data Nat (Zero Succ)) 8 | (:: Zero Nat) 9 | (:: Succ (-> (Nat) Nat)) 10 | (data Tree (Nil Node)) 11 | (:: Nil (-> (Unit) Tree)) 12 | (:: Node (-> (Nat Tree Tree) Tree)) 13 | (:: lq (-> (Nat Nat) Bool)) 14 | (let lq (Zero (Succ ?x)) True) 15 | (let lq (?x Zero) False) 16 | (let lq ((Succ ?x) (Succ ?y)) (lq ?x ?y)) 17 | (:: ite1 (-> (Bool Nat Nat) Nat)) 18 | (let ite1 (True ?x ?y) ?x) 19 | (let ite1 (False ?x ?y) ?y) 20 | (:: max (-> (Nat Nat) Nat)) 21 | (let max (?tv0 ?tv1) (ite1 (lq ?tv0 ?tv1) ?tv1 ?tv0)) 22 | (:: tf1 (-> (Nat Tree) Nat)) 23 | (let tf1 (?tv6 (Nil ?tv7)) ?tv6) 24 | (let tf1 (?tv6 (Node ?tv8 ?tv9 ?tv10)) (tf0 (max (tf0 ?tv6 ?tv9) ?tv8) ?tv10)) 25 | (:: tf0 (-> (Nat Tree) Nat)) 26 | (let tf0 (?tv3 ?tv4) (tf1 ?tv3 ?tv4)) 27 | (:: spec (-> (Tree) Nat)) 28 | (let spec (?tv2) (tf0 Zero ?tv2)) 29 | (:: tf3 (-> (Tree) Tree)) 30 | (let tf3 ((Nil ?tv14)) (Nil Null)) 31 | (let tf3 ((Node ?tv15 ?tv16 ?tv17)) (Node ?tv15 (tf2 ?tv16) (tf2 ?tv17))) 32 | (:: tf2 (-> (Tree) Tree)) 33 | (let tf2 (?tv12) (tf3 ?tv12)) 34 | (:: repr (-> (Tree) Tree)) 35 | (let repr (?tv11) (tf2 ?tv11)) 36 | (:: main (-> (Tree) Nat)) 37 | (let main (?tv18) (spec (repr ?tv18))) 38 | (:: tf5 (-> (Tree) Nat)) 39 | (let tf5 ((Nil ?tv22)) Zero) 40 | (let tf5 ((Node ?tv23 ?tv24 ?tv25)) (max ?tv23 (max (tf4 ?tv25) (tf4 ?tv24)))) 41 | (:: tf4 (-> (Tree) Nat)) 42 | (let tf4 (?tv20) (tf5 ?tv20)) 43 | (:: reprNew (-> (Tree) Nat)) 44 | (let reprNew (?tv19) (tf4 ?tv19)) 45 | (:: mainNew (-> (Tree) Nat)) 46 | (let mainNew (?tv26) (reprNew ?tv26)) 47 | (=== optimize (inp0) (Tree) (main inp0) (mainNew inp0)) 48 | ) 49 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/synduce-tree-min.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Unit (Null)) 6 | (:: Null Unit) 7 | (data Nat (Zero Succ)) 8 | (:: Zero Nat) 9 | (:: Succ (-> (Nat) Nat)) 10 | (data Tree (Nil Node)) 11 | (:: Nil (-> (Unit) Tree)) 12 | (:: Node (-> (Nat Tree Tree) Tree)) 13 | (:: lq (-> (Nat Nat) Bool)) 14 | (let lq (Zero (Succ ?x)) True) 15 | (let lq (?x Zero) False) 16 | (let lq ((Succ ?x) (Succ ?y)) (lq ?x ?y)) 17 | (:: ite1 (-> (Bool Nat Nat) Nat)) 18 | (let ite1 (True ?x ?y) ?x) 19 | (let ite1 (False ?x ?y) ?y) 20 | (:: max (-> (Nat Nat) Nat)) 21 | (let max (?tv0 ?tv1) (ite1 (lq ?tv0 ?tv1) ?tv1 ?tv0)) 22 | (:: tf1 (-> (Nat Tree) Nat)) 23 | (let tf1 (?tv6 (Nil ?tv7)) ?tv6) 24 | (let tf1 (?tv6 (Node ?tv8 ?tv9 ?tv10)) (tf0 (max (tf0 ?tv6 ?tv9) ?tv8) ?tv10)) 25 | (:: tf0 (-> (Nat Tree) Nat)) 26 | (let tf0 (?tv3 ?tv4) (tf1 ?tv3 ?tv4)) 27 | (:: spec (-> (Tree) Nat)) 28 | (let spec (?tv2) (tf0 Zero ?tv2)) 29 | (:: tf3 (-> (Tree) Tree)) 30 | (let tf3 ((Nil ?tv14)) (Nil Null)) 31 | (let tf3 ((Node ?tv15 ?tv16 ?tv17)) (Node ?tv15 (tf2 ?tv16) (tf2 ?tv17))) 32 | (:: tf2 (-> (Tree) Tree)) 33 | (let tf2 (?tv12) (tf3 ?tv12)) 34 | (:: repr (-> (Tree) Tree)) 35 | (let repr (?tv11) (tf2 ?tv11)) 36 | (:: main (-> (Tree) Nat)) 37 | (let main (?tv18) (spec (repr ?tv18))) 38 | (:: tf5 (-> (Tree) Nat)) 39 | (let tf5 ((Nil ?tv22)) Zero) 40 | (let tf5 ((Node ?tv23 ?tv24 ?tv25)) (max ?tv23 (max (tf4 ?tv25) (tf4 ?tv24)))) 41 | (:: tf4 (-> (Tree) Nat)) 42 | (let tf4 (?tv20) (tf5 ?tv20)) 43 | (:: reprNew (-> (Tree) Nat)) 44 | (let reprNew (?tv19) (tf4 ?tv19)) 45 | (:: mainNew (-> (Tree) Nat)) 46 | (let mainNew (?tv26) (reprNew ?tv26)) 47 | (=== optimize (inp0) (Tree) (main inp0) (mainNew inp0)) 48 | ) 49 | -------------------------------------------------------------------------------- /benchmarks/cvc4/clam/goal15.smt2: -------------------------------------------------------------------------------- 1 | (declare-datatypes () ((Nat (succ (pred Nat)) (zero)))) 2 | (declare-datatypes () ((Lst (cons (head Nat) (tail Lst)) (nil)))) 3 | (declare-datatypes () ((Tree (node (data Nat) (left Tree) (right Tree)) (leaf)))) 4 | (declare-datatypes () ((Pair (mkpair (first Nat) (second Nat))) 5 | (ZLst (zcons (zhead Pair) (ztail ZLst)) (znil)))) 6 | (declare-fun less (Nat Nat) Bool) 7 | (declare-fun plus (Nat Nat) Nat) 8 | (declare-fun mult (Nat Nat) Nat) 9 | (declare-fun qmult (Nat Nat Nat) Nat) 10 | (declare-fun exp (Nat Nat) Nat) 11 | (declare-fun qexp (Nat Nat Nat) Nat) 12 | (declare-fun fac (Nat) Nat) 13 | (declare-fun qfac (Nat Nat) Nat) 14 | (declare-fun double (Nat) Nat) 15 | (declare-fun half (Nat) Nat) 16 | (declare-fun even (Nat) Bool) 17 | (declare-fun append (Lst Lst) Lst) 18 | (declare-fun len (Lst) Nat) 19 | (declare-fun drop (Nat Lst) Lst) 20 | (declare-fun take (Nat Lst) Lst) 21 | (declare-fun count (Nat Lst) Nat) 22 | (declare-fun mem (Nat Lst) Bool) 23 | (declare-fun rev (Lst) Lst) 24 | (declare-fun qreva (Lst Lst) Lst) 25 | (declare-fun insort (Nat Lst) Lst) 26 | (declare-fun sorted (Lst) Bool) 27 | (declare-fun sort (Lst) Lst) 28 | (declare-fun rotate (Nat Lst) Lst) 29 | (declare-fun revflat (Tree) Lst) 30 | (declare-fun qrevaflat (Tree Lst) Lst) 31 | (declare-fun lst-mem (Nat Lst) Bool) 32 | (declare-fun lst-subset (Lst Lst) Bool) 33 | (declare-fun lst-eq (Lst Lst) Bool) 34 | (declare-fun lst-intersection (Lst Lst) Lst) 35 | (declare-fun lst-union (Lst Lst) Lst) 36 | (define-fun leq ((x Nat) (y Nat)) Bool (or (= x y) (less x y))) 37 | (assert (forall ((n Nat)) (= (plus zero n) n))) 38 | (assert (forall ((n Nat) (m Nat)) (= (plus (succ n) m) (succ (plus n m))))) 39 | (assert (not 40 | (forall ((x Nat)) (= (plus x (succ x)) (succ (plus x x)))) ; G15 41 | )) 42 | (check-sat) 43 | -------------------------------------------------------------------------------- /benchmarks/cclemma/optimization/synduce-tree-maxtree2.ceg: -------------------------------------------------------------------------------- 1 | ( 2 | (data Bool (True False)) 3 | (:: True Bool) 4 | (:: False Bool) 5 | (data Unit (Null)) 6 | (:: Null Unit) 7 | (data Nat (Zero Succ)) 8 | (:: Zero Nat) 9 | (:: Succ (-> (Nat) Nat)) 10 | (data Tree (Nil Node)) 11 | (:: Nil (-> (Unit) Tree)) 12 | (:: Node (-> (Nat Tree Tree) Tree)) 13 | (:: lq (-> (Nat Nat) Bool)) 14 | (let lq (Zero (Succ ?x)) True) 15 | (let lq (?x Zero) False) 16 | (let lq ((Succ ?x) (Succ ?y)) (lq ?x ?y)) 17 | (:: ite1 (-> (Bool Nat Nat) Nat)) 18 | (let ite1 (True ?x ?y) ?x) 19 | (let ite1 (False ?x ?y) ?y) 20 | (:: max (-> (Nat Nat) Nat)) 21 | (let max (?tv0 ?tv1) (ite1 (lq ?tv0 ?tv1) ?tv1 ?tv0)) 22 | (:: tf1 (-> (Nat Tree) Nat)) 23 | (let tf1 (?tv6 (Nil ?tv7)) ?tv6) 24 | (let tf1 (?tv6 (Node ?tv8 ?tv9 ?tv10)) (max ?tv8 (tf0 (tf0 ?tv6 ?tv10) ?tv9))) 25 | (:: tf0 (-> (Nat Tree) Nat)) 26 | (let tf0 (?tv3 ?tv4) (tf1 ?tv3 ?tv4)) 27 | (:: spec (-> (Tree) Nat)) 28 | (let spec (?tv2) (tf0 Zero ?tv2)) 29 | (:: tf3 (-> (Tree) Tree)) 30 | (let tf3 ((Nil ?tv14)) (Nil Null)) 31 | (let tf3 ((Node ?tv15 ?tv16 ?tv17)) (Node ?tv15 (tf2 ?tv16) (tf2 ?tv17))) 32 | (:: tf2 (-> (Tree) Tree)) 33 | (let tf2 (?tv12) (tf3 ?tv12)) 34 | (:: repr (-> (Tree) Tree)) 35 | (let repr (?tv11) (tf2 ?tv11)) 36 | (:: main (-> (Tree) Nat)) 37 | (let main (?tv18) (spec (repr ?tv18))) 38 | (:: tf5 (-> (Tree) Nat)) 39 | (let tf5 ((Nil ?tv22)) Zero) 40 | (let tf5 ((Node ?tv23 ?tv24 ?tv25)) (max ?tv23 (max (tf4 ?tv25) (tf4 ?tv24)))) 41 | (:: tf4 (-> (Tree) Nat)) 42 | (let tf4 (?tv20) (tf5 ?tv20)) 43 | (:: reprNew (-> (Tree) Nat)) 44 | (let reprNew (?tv19) (tf4 ?tv19)) 45 | (:: mainNew (-> (Tree) Nat)) 46 | (let mainNew (?tv26) (reprNew ?tv26)) 47 | (=== optimize (inp0) (Tree) (main inp0) (mainNew inp0)) 48 | ) 49 | -------------------------------------------------------------------------------- /benchmarks/cvc4/clam/goal51.smt2: -------------------------------------------------------------------------------- 1 | (declare-datatypes () ((Nat (succ (pred Nat)) (zero)))) 2 | (declare-datatypes () ((Lst (cons (head Nat) (tail Lst)) (nil)))) 3 | (declare-datatypes () ((Tree (node (data Nat) (left Tree) (right Tree)) (leaf)))) 4 | (declare-datatypes () ((Pair (mkpair (first Nat) (second Nat))) 5 | (ZLst (zcons (zhead Pair) (ztail ZLst)) (znil)))) 6 | (declare-fun less (Nat Nat) Bool) 7 | (declare-fun plus (Nat Nat) Nat) 8 | (declare-fun mult (Nat Nat) Nat) 9 | (declare-fun qmult (Nat Nat Nat) Nat) 10 | (declare-fun exp (Nat Nat) Nat) 11 | (declare-fun qexp (Nat Nat Nat) Nat) 12 | (declare-fun fac (Nat) Nat) 13 | (declare-fun qfac (Nat Nat) Nat) 14 | (declare-fun double (Nat) Nat) 15 | (declare-fun half (Nat) Nat) 16 | (declare-fun even (Nat) Bool) 17 | (declare-fun append (Lst Lst) Lst) 18 | (declare-fun len (Lst) Nat) 19 | (declare-fun drop (Nat Lst) Lst) 20 | (declare-fun take (Nat Lst) Lst) 21 | (declare-fun count (Nat Lst) Nat) 22 | (declare-fun mem (Nat Lst) Bool) 23 | (declare-fun rev (Lst) Lst) 24 | (declare-fun qreva (Lst Lst) Lst) 25 | (declare-fun insort (Nat Lst) Lst) 26 | (declare-fun sorted (Lst) Bool) 27 | (declare-fun sort (Lst) Lst) 28 | (declare-fun rotate (Nat Lst) Lst) 29 | (declare-fun revflat (Tree) Lst) 30 | (declare-fun qrevaflat (Tree Lst) Lst) 31 | (declare-fun lst-mem (Nat Lst) Bool) 32 | (declare-fun lst-subset (Lst Lst) Bool) 33 | (declare-fun lst-eq (Lst Lst) Bool) 34 | (declare-fun lst-intersection (Lst Lst) Lst) 35 | (declare-fun lst-union (Lst Lst) Lst) 36 | (define-fun leq ((x Nat) (y Nat)) Bool (or (= x y) (less x y))) 37 | (assert (forall ((n Nat)) (= (plus zero n) n))) 38 | (assert (forall ((n Nat) (m Nat)) (= (plus (succ n) m) (succ (plus n m))))) 39 | (assert (not 40 | (forall ((x Nat) (y Nat)) (= (plus x (succ y)) (succ (plus x y)))) ; G51 41 | )) 42 | (check-sat) 43 | -------------------------------------------------------------------------------- /benchmarks/cvc4/clam/goal74.smt2: -------------------------------------------------------------------------------- 1 | (declare-datatypes () ((Nat (succ (pred Nat)) (zero)))) 2 | (declare-datatypes () ((Lst (cons (head Nat) (tail Lst)) (nil)))) 3 | (declare-datatypes () ((Tree (node (data Nat) (left Tree) (right Tree)) (leaf)))) 4 | (declare-datatypes () ((Pair (mkpair (first Nat) (second Nat))) 5 | (ZLst (zcons (zhead Pair) (ztail ZLst)) (znil)))) 6 | (declare-fun less (Nat Nat) Bool) 7 | (declare-fun plus (Nat Nat) Nat) 8 | (declare-fun mult (Nat Nat) Nat) 9 | (declare-fun qmult (Nat Nat Nat) Nat) 10 | (declare-fun exp (Nat Nat) Nat) 11 | (declare-fun qexp (Nat Nat Nat) Nat) 12 | (declare-fun fac (Nat) Nat) 13 | (declare-fun qfac (Nat Nat) Nat) 14 | (declare-fun double (Nat) Nat) 15 | (declare-fun half (Nat) Nat) 16 | (declare-fun even (Nat) Bool) 17 | (declare-fun append (Lst Lst) Lst) 18 | (declare-fun len (Lst) Nat) 19 | (declare-fun drop (Nat Lst) Lst) 20 | (declare-fun take (Nat Lst) Lst) 21 | (declare-fun count (Nat Lst) Nat) 22 | (declare-fun mem (Nat Lst) Bool) 23 | (declare-fun rev (Lst) Lst) 24 | (declare-fun qreva (Lst Lst) Lst) 25 | (declare-fun insort (Nat Lst) Lst) 26 | (declare-fun sorted (Lst) Bool) 27 | (declare-fun sort (Lst) Lst) 28 | (declare-fun rotate (Nat Lst) Lst) 29 | (declare-fun revflat (Tree) Lst) 30 | (declare-fun qrevaflat (Tree Lst) Lst) 31 | (declare-fun lst-mem (Nat Lst) Bool) 32 | (declare-fun lst-subset (Lst Lst) Bool) 33 | (declare-fun lst-eq (Lst Lst) Bool) 34 | (declare-fun lst-intersection (Lst Lst) Lst) 35 | (declare-fun lst-union (Lst Lst) Lst) 36 | (define-fun leq ((x Nat) (y Nat)) Bool (or (= x y) (less x y))) 37 | (assert (forall ((n Nat)) (= (plus zero n) n))) 38 | (assert (forall ((n Nat) (m Nat)) (= (plus (succ n) m) (succ (plus n m))))) 39 | (assert (not 40 | (forall ((x Nat) (y Nat) (z Nat)) (= (plus (plus x y) z) (plus x (plus y z)))) ; G74 41 | )) 42 | (check-sat) 43 | -------------------------------------------------------------------------------- /benchmarks/cvc4/clam/goal67.smt2: -------------------------------------------------------------------------------- 1 | (declare-datatypes () ((Nat (succ (pred Nat)) (zero)))) 2 | (declare-datatypes () ((Lst (cons (head Nat) (tail Lst)) (nil)))) 3 | (declare-datatypes () ((Tree (node (data Nat) (left Tree) (right Tree)) (leaf)))) 4 | (declare-datatypes () ((Pair (mkpair (first Nat) (second Nat))) 5 | (ZLst (zcons (zhead Pair) (ztail ZLst)) (znil)))) 6 | (declare-fun less (Nat Nat) Bool) 7 | (declare-fun plus (Nat Nat) Nat) 8 | (declare-fun mult (Nat Nat) Nat) 9 | (declare-fun qmult (Nat Nat Nat) Nat) 10 | (declare-fun exp (Nat Nat) Nat) 11 | (declare-fun qexp (Nat Nat Nat) Nat) 12 | (declare-fun fac (Nat) Nat) 13 | (declare-fun qfac (Nat Nat) Nat) 14 | (declare-fun double (Nat) Nat) 15 | (declare-fun half (Nat) Nat) 16 | (declare-fun even (Nat) Bool) 17 | (declare-fun append (Lst Lst) Lst) 18 | (declare-fun len (Lst) Nat) 19 | (declare-fun drop (Nat Lst) Lst) 20 | (declare-fun take (Nat Lst) Lst) 21 | (declare-fun count (Nat Lst) Nat) 22 | (declare-fun mem (Nat Lst) Bool) 23 | (declare-fun rev (Lst) Lst) 24 | (declare-fun qreva (Lst Lst) Lst) 25 | (declare-fun insort (Nat Lst) Lst) 26 | (declare-fun sorted (Lst) Bool) 27 | (declare-fun sort (Lst) Lst) 28 | (declare-fun rotate (Nat Lst) Lst) 29 | (declare-fun revflat (Tree) Lst) 30 | (declare-fun qrevaflat (Tree Lst) Lst) 31 | (declare-fun lst-mem (Nat Lst) Bool) 32 | (declare-fun lst-subset (Lst Lst) Bool) 33 | (declare-fun lst-eq (Lst Lst) Bool) 34 | (declare-fun lst-intersection (Lst Lst) Lst) 35 | (declare-fun lst-union (Lst Lst) Lst) 36 | (define-fun leq ((x Nat) (y Nat)) Bool (or (= x y) (less x y))) 37 | (assert (forall ((n Nat)) (= (plus zero n) n))) 38 | (assert (forall ((n Nat) (m Nat)) (= (plus (succ n) m) (succ (plus n m))))) 39 | (assert (not 40 | (forall ((x Nat) (y Nat)) (= (plus x (succ (succ y))) (succ (succ (plus x y))))) ; G67 41 | )) 42 | (check-sat) 43 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal85.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (datatype Pair () ((mkpair Nat Nat Pair))) 4 | (datatype ZLst () ((zcons Pair ZLst ZLst) (znil ZLst))) 5 | (declare-fun append (Lst Lst) Lst) 6 | (declare-fun len (Lst) Nat) 7 | (declare-fun drop (Nat Lst) Lst) 8 | (declare-fun take (Nat Lst) Lst) 9 | (declare-fun zip (Lst Lst) ZLst) 10 | (declare-fun zappend (ZLst ZLst) ZLst) 11 | (declare-fun leq (Nat Nat) Bool) 12 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 13 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 14 | (=> rule2 (append nil ?x) ?x) 15 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 16 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 17 | (=> rule5 (len nil) zero) 18 | (=> rule6 zero (len nil)) 19 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 20 | (=> rule8 (drop ?x4 nil) nil) 21 | (=> rule9 (drop zero ?x) ?x) 22 | (=> rule10 (drop (succ ?x5) (cons ?y6 ?z)) (drop ?x5 ?z)) 23 | (=> rule11 (take ?x7 nil) nil) 24 | (=> rule12 (take zero ?x) nil) 25 | (=> rule13 (take (succ ?x8) (cons ?y9 ?z)) (cons ?y9 (take ?x8 ?z))) 26 | (=> rule14 (cons ?y9 (take ?x8 ?z)) (take (succ ?x8) (cons ?y9 ?z))) 27 | (=> rule15 (zip nil ?x) znil) 28 | (=> rule16 (zip ?x nil) znil) 29 | (=> rule17 (zip (cons ?x10 ?y) (cons ?z11 ?w)) (zcons (mkpair ?x10 ?z11) (zip ?y ?w))) 30 | (=> rule18 (zcons (mkpair ?x10 ?z11) (zip ?y ?w)) (zip (cons ?x10 ?y) (cons ?z11 ?w))) 31 | (=> rule19 (zappend znil ?x12) ?x12) 32 | (=> rule20 (zappend (zcons ?x13 ?y14) ?z15) (zcons ?x13 (zappend ?y14 ?z15))) 33 | (=> rule21 (zcons ?x13 (zappend ?y14 ?z15)) (zappend (zcons ?x13 ?y14) ?z15)) 34 | (prove (forall ((xs Lst)(ys Lst)(zs Lst)) (= (zip (append xs ys) zs) (zappend (zip xs (take (len xs) zs)) (zip ys (drop (len xs) zs)))))) 35 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal86.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (datatype Pair () ((mkpair Nat Nat Pair))) 4 | (datatype ZLst () ((zcons Pair ZLst ZLst) (znil ZLst))) 5 | (declare-fun append (Lst Lst) Lst) 6 | (declare-fun len (Lst) Nat) 7 | (declare-fun drop (Nat Lst) Lst) 8 | (declare-fun take (Nat Lst) Lst) 9 | (declare-fun zip (Lst Lst) ZLst) 10 | (declare-fun zappend (ZLst ZLst) ZLst) 11 | (declare-fun leq (Nat Nat) Bool) 12 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 13 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 14 | (=> rule2 (append nil ?x) ?x) 15 | (=> rule3 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 16 | (=> rule4 (cons ?x2 (append ?y ?z)) (append (cons ?x2 ?y) ?z)) 17 | (=> rule5 (len nil) zero) 18 | (=> rule6 zero (len nil)) 19 | (=> rule7 (len (cons ?x3 ?y)) (succ (len ?y))) 20 | (=> rule8 (drop ?x4 nil) nil) 21 | (=> rule9 (drop zero ?x) ?x) 22 | (=> rule10 (drop (succ ?x5) (cons ?y6 ?z)) (drop ?x5 ?z)) 23 | (=> rule11 (take ?x7 nil) nil) 24 | (=> rule12 (take zero ?x) nil) 25 | (=> rule13 (take (succ ?x8) (cons ?y9 ?z)) (cons ?y9 (take ?x8 ?z))) 26 | (=> rule14 (cons ?y9 (take ?x8 ?z)) (take (succ ?x8) (cons ?y9 ?z))) 27 | (=> rule15 (zip nil ?x) znil) 28 | (=> rule16 (zip ?x nil) znil) 29 | (=> rule17 (zip (cons ?x10 ?y) (cons ?z11 ?w)) (zcons (mkpair ?x10 ?z11) (zip ?y ?w))) 30 | (=> rule18 (zcons (mkpair ?x10 ?z11) (zip ?y ?w)) (zip (cons ?x10 ?y) (cons ?z11 ?w))) 31 | (=> rule19 (zappend znil ?x12) ?x12) 32 | (=> rule20 (zappend (zcons ?x13 ?y14) ?z15) (zcons ?x13 (zappend ?y14 ?z15))) 33 | (=> rule21 (zcons ?x13 (zappend ?y14 ?z15)) (zappend (zcons ?x13 ?y14) ?z15)) 34 | (prove (forall ((xs Lst)(ys Lst)(zs Lst)) (= (zip xs (append ys zs)) (zappend (zip (take (len ys) xs) ys) (zip (drop (len ys) xs) zs))))) 35 | -------------------------------------------------------------------------------- /benchmarks/thesy/isaplanner/goal201.smt2.th: -------------------------------------------------------------------------------- 1 | (datatype Nat () ((succ Nat Nat) (zero Nat))) 2 | (datatype Lst () ((cons Nat Lst Lst) (nil Lst))) 3 | (declare-fun less (Nat Nat) Bool) 4 | (declare-fun plus (Nat Nat) Nat) 5 | (declare-fun len (Lst) Nat) 6 | (declare-fun sum (Lst) Nat) 7 | (declare-fun insort (Nat Lst) Lst) 8 | (declare-fun sort (Lst) Lst) 9 | (declare-fun leq (Nat Nat) Bool) 10 | (declare-fun append (Lst Lst) Lst) 11 | (declare-fun rev (Lst) Lst) 12 | (=> rule0 (leq ?__x0 ?__y1) (or (= ?__x0 ?__y1) (less ?__x0 ?__y1))) 13 | (=> rule1 (or (= ?__x0 ?__y1) (less ?__x0 ?__y1)) (leq ?__x0 ?__y1)) 14 | (=> rule2 (less ?x zero) false) 15 | (=> rule3 (less zero (succ ?x)) true) 16 | (=> rule4 (less (succ ?x) (succ ?y)) (less ?x ?y)) 17 | (=> rule5 (less ?x ?y) (less (succ ?x) (succ ?y))) 18 | (=> rule6 (len nil) zero) 19 | (=> rule7 zero (len nil)) 20 | (=> rule8 (len (cons ?x ?y2)) (succ (len ?y2))) 21 | (=> rule9 (insort ?i nil) (cons ?i nil)) 22 | (=> rule10 (cons ?i nil) (insort ?i nil)) 23 | (=> rule11 (insort ?i (cons ?x ?y3)) (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3)))) 24 | (=> rule12 (ite (less ?i ?x) (cons ?i (cons ?x ?y3)) (cons ?x (insort ?i ?y3))) (insort ?i (cons ?x ?y3))) 25 | (=> rule13 (sort nil) nil) 26 | (=> rule14 nil (sort nil)) 27 | (=> rule15 (sort (cons ?x ?y4)) (insort ?x (sort ?y4))) 28 | (=> rule16 (insort ?x (sort ?y4)) (sort (cons ?x ?y4))) 29 | (=> rule17 (plus zero ?n) ?n) 30 | (=> rule18 (plus (succ ?n) ?m) (succ (plus ?n ?m))) 31 | (=> rule19 (sum nil) (zero)) 32 | (=> rule20 (sum (cons ?x ?xs)) (plus ?x (sum ?xs))) 33 | (=> rule21 (rev nil) nil) 34 | (=> rule22 nil (rev nil)) 35 | (=> rule23 (rev (cons ?x6 ?y)) (append (rev ?y) (cons ?x6 nil))) 36 | (=> rule24 (append nil ?x) ?x) 37 | (=> rule25 (append (cons ?x2 ?y) ?z) (cons ?x2 (append ?y ?z))) 38 | (prove (forall ((l Lst)) (= (sum (sort l)) (sum (rev l))))) 39 | -------------------------------------------------------------------------------- /benchmarks/thesy/optimization/synduce-tree-min.th: -------------------------------------------------------------------------------- 1 | (datatype Bool () ((true Bool) (false Bool))) 2 | (datatype Unit () ((null Unit))) 3 | (datatype Nat () ((zero Nat) (succ Nat Nat))) 4 | (datatype Tree () ((nil Unit Tree) (node Nat Tree Tree Tree))) 5 | (declare-fun lq (Nat Nat) Bool) 6 | (=> lqr0 (lq zero (succ ?x)) true) 7 | (=> lqr1 (lq ?x zero) false) 8 | (=> lqr2 (lq (succ ?x) (succ ?y)) (lq ?x ?y)) 9 | (declare-fun ite1 (Bool Nat Nat) Nat) 10 | (=> ite1r0 (ite1 true ?x ?y) ?x) 11 | (=> ite1r1 (ite1 false ?x ?y) ?y) 12 | (declare-fun max (Nat Nat) Nat) 13 | (=> maxr0 (max ?tv0 ?tv1) (ite1 (lq ?tv0 ?tv1) ?tv1 ?tv0)) 14 | (declare-fun tf1 (Nat Tree) Nat) 15 | (=> tf1r0 (tf1 ?tv6 (nil ?tv7)) ?tv6) 16 | (=> tf1r1 (tf1 ?tv6 (node ?tv8 ?tv9 ?tv10)) (tf0 (max (tf0 ?tv6 ?tv9) ?tv8) ?tv10)) 17 | (declare-fun tf0 (Nat Tree) Nat) 18 | (=> tf0r0 (tf0 ?tv3 ?tv4) (tf1 ?tv3 ?tv4)) 19 | (declare-fun spec (Tree) Nat) 20 | (=> specr0 (spec ?tv2) (tf0 zero ?tv2)) 21 | (declare-fun tf3 (Tree) Tree) 22 | (=> tf3r0 (tf3 (nil ?tv14)) (nil null)) 23 | (=> tf3r1 (tf3 (node ?tv15 ?tv16 ?tv17)) (node ?tv15 (tf2 ?tv16) (tf2 ?tv17))) 24 | (declare-fun tf2 (Tree) Tree) 25 | (=> tf2r0 (tf2 ?tv12) (tf3 ?tv12)) 26 | (declare-fun repr (Tree) Tree) 27 | (=> reprr0 (repr ?tv11) (tf2 ?tv11)) 28 | (declare-fun main (Tree) Nat) 29 | (=> mainr0 (main ?tv18) (spec (repr ?tv18))) 30 | (declare-fun tf5 (Tree) Nat) 31 | (=> tf5r0 (tf5 (nil ?tv22)) zero) 32 | (=> tf5r1 (tf5 (node ?tv23 ?tv24 ?tv25)) (max ?tv23 (max (tf4 ?tv25) (tf4 ?tv24)))) 33 | (declare-fun tf4 (Tree) Nat) 34 | (=> tf4r0 (tf4 ?tv20) (tf5 ?tv20)) 35 | (declare-fun repr_ (Tree) Nat) 36 | (=> repr_r0 (repr_ ?tv19) (tf4 ?tv19)) 37 | (declare-fun main_ (Tree) Nat) 38 | (=> main_r0 (main_ ?tv26) (repr_ ?tv26)) 39 | (prove (forall ((inp0 Tree)) (= (main inp0) (main_ inp0)))) 40 | -------------------------------------------------------------------------------- /benchmarks/cvc4/clam/goal72.smt2: -------------------------------------------------------------------------------- 1 | (declare-datatypes () ((Nat (succ (pred Nat)) (zero)))) 2 | (declare-datatypes () ((Lst (cons (head Nat) (tail Lst)) (nil)))) 3 | (declare-datatypes () ((Tree (node (data Nat) (left Tree) (right Tree)) (leaf)))) 4 | (declare-datatypes () ((Pair (mkpair (first Nat) (second Nat))) 5 | (ZLst (zcons (zhead Pair) (ztail ZLst)) (znil)))) 6 | (declare-fun less (Nat Nat) Bool) 7 | (declare-fun plus (Nat Nat) Nat) 8 | (declare-fun mult (Nat Nat) Nat) 9 | (declare-fun qmult (Nat Nat Nat) Nat) 10 | (declare-fun exp (Nat Nat) Nat) 11 | (declare-fun qexp (Nat Nat Nat) Nat) 12 | (declare-fun fac (Nat) Nat) 13 | (declare-fun qfac (Nat Nat) Nat) 14 | (declare-fun double (Nat) Nat) 15 | (declare-fun half (Nat) Nat) 16 | (declare-fun even (Nat) Bool) 17 | (declare-fun append (Lst Lst) Lst) 18 | (declare-fun len (Lst) Nat) 19 | (declare-fun drop (Nat Lst) Lst) 20 | (declare-fun take (Nat Lst) Lst) 21 | (declare-fun count (Nat Lst) Nat) 22 | (declare-fun mem (Nat Lst) Bool) 23 | (declare-fun rev (Lst) Lst) 24 | (declare-fun qreva (Lst Lst) Lst) 25 | (declare-fun insort (Nat Lst) Lst) 26 | (declare-fun sorted (Lst) Bool) 27 | (declare-fun sort (Lst) Lst) 28 | (declare-fun rotate (Nat Lst) Lst) 29 | (declare-fun revflat (Tree) Lst) 30 | (declare-fun qrevaflat (Tree Lst) Lst) 31 | (declare-fun lst-mem (Nat Lst) Bool) 32 | (declare-fun lst-subset (Lst Lst) Bool) 33 | (declare-fun lst-eq (Lst Lst) Bool) 34 | (declare-fun lst-intersection (Lst Lst) Lst) 35 | (declare-fun lst-union (Lst Lst) Lst) 36 | (define-fun leq ((x Nat) (y Nat)) Bool (or (= x y) (less x y))) 37 | (assert (forall ((x Lst)) (= (append nil x) x))) 38 | (assert (forall ((x Nat) (y Lst) (z Lst)) (= (append (cons x y) z) (cons x (append y z))))) 39 | (assert (not 40 | (forall ((x Lst) (y Lst) (z Lst)) (= (append (append x y) z) (append x (append y z)))) ; G72 41 | )) 42 | (check-sat) 43 | -------------------------------------------------------------------------------- /benchmarks/thesy/optimization/synduce-tree-maxtree.th: -------------------------------------------------------------------------------- 1 | (datatype Bool () ((true Bool) (false Bool))) 2 | (datatype Unit () ((null Unit))) 3 | (datatype Nat () ((zero Nat) (succ Nat Nat))) 4 | (datatype Tree () ((nil Unit Tree) (node Nat Tree Tree Tree))) 5 | (declare-fun lq (Nat Nat) Bool) 6 | (=> lqr0 (lq zero (succ ?x)) true) 7 | (=> lqr1 (lq ?x zero) false) 8 | (=> lqr2 (lq (succ ?x) (succ ?y)) (lq ?x ?y)) 9 | (declare-fun ite1 (Bool Nat Nat) Nat) 10 | (=> ite1r0 (ite1 true ?x ?y) ?x) 11 | (=> ite1r1 (ite1 false ?x ?y) ?y) 12 | (declare-fun max (Nat Nat) Nat) 13 | (=> maxr0 (max ?tv0 ?tv1) (ite1 (lq ?tv0 ?tv1) ?tv1 ?tv0)) 14 | (declare-fun tf1 (Nat Tree) Nat) 15 | (=> tf1r0 (tf1 ?tv6 (nil ?tv7)) ?tv6) 16 | (=> tf1r1 (tf1 ?tv6 (node ?tv8 ?tv9 ?tv10)) (tf0 (max (tf0 ?tv6 ?tv9) ?tv8) ?tv10)) 17 | (declare-fun tf0 (Nat Tree) Nat) 18 | (=> tf0r0 (tf0 ?tv3 ?tv4) (tf1 ?tv3 ?tv4)) 19 | (declare-fun spec (Tree) Nat) 20 | (=> specr0 (spec ?tv2) (tf0 zero ?tv2)) 21 | (declare-fun tf3 (Tree) Tree) 22 | (=> tf3r0 (tf3 (nil ?tv14)) (nil null)) 23 | (=> tf3r1 (tf3 (node ?tv15 ?tv16 ?tv17)) (node ?tv15 (tf2 ?tv16) (tf2 ?tv17))) 24 | (declare-fun tf2 (Tree) Tree) 25 | (=> tf2r0 (tf2 ?tv12) (tf3 ?tv12)) 26 | (declare-fun repr (Tree) Tree) 27 | (=> reprr0 (repr ?tv11) (tf2 ?tv11)) 28 | (declare-fun main (Tree) Nat) 29 | (=> mainr0 (main ?tv18) (spec (repr ?tv18))) 30 | (declare-fun tf5 (Tree) Nat) 31 | (=> tf5r0 (tf5 (nil ?tv22)) zero) 32 | (=> tf5r1 (tf5 (node ?tv23 ?tv24 ?tv25)) (max ?tv23 (max (tf4 ?tv25) (tf4 ?tv24)))) 33 | (declare-fun tf4 (Tree) Nat) 34 | (=> tf4r0 (tf4 ?tv20) (tf5 ?tv20)) 35 | (declare-fun repr_ (Tree) Nat) 36 | (=> repr_r0 (repr_ ?tv19) (tf4 ?tv19)) 37 | (declare-fun main_ (Tree) Nat) 38 | (=> main_r0 (main_ ?tv26) (repr_ ?tv26)) 39 | (prove (forall ((inp0 Tree)) (= (main inp0) (main_ inp0)))) 40 | --------------------------------------------------------------------------------