diff --git a/.gitignore b/.gitignore new file mode 100644 --- /dev/null +++ b/.gitignore @@ -0,0 +1,111 @@ +# cabal stuff +**/.cabal-sandbox +**/cabal.sandbox.config +**/idx/ +**/dist/ +**/log/ +.stack-work + +doc/ + +**.prof +**.swp +**.hi +**.o +**.dyn_hi +**.dyn_o +**.hpc +**.hpc-* +**.tix +**~ + +TAGS +tags +ctags + +etc +eg/*.dot +eg/*.eps +eg/*.pdf +bench/*.dot +bench/*.eps +bench/*.pdf +mk/toplibs + +tests/test-compose-dynamic +tests/test-engine +tests/test-expr +tests/test-eval +tests/test-haexpress +tests/test-kbc +tests/test-match +tests/test-misc +tests/test-order +tests/test-creason +tests/test-reason +tests/test-stats +tests/test-utils +eg/eg +eg/algebraic-graphs +eg/arith +eg/arith-negate-abs +eg/0arith +eg/binarytree +eg/binarytree0 +eg/bool +eg/color +eg/colour +eg/digraphs +eg/fun +eg/list +eg/length +eg/lenzip +eg/zip +eg/minus +eg/numbool +eg/insertsort +eg/insertsort0 +eg/speculate-reason +eg/string +eg/plus-abs +eg/pretty +eg/pretty-compact +eg/ratio +eg/regexes +eg/sets +eg/monad +eg/tauts +eg/tuples +eg/oddeven +bench/expressions +bench/representatives +bench/representatives2 +bench/arithficial +bench/nord +bench/unit +bench/qs*/0arith +bench/qs*/arith-negate-abs +bench/qs*/arith +bench/qs*/binarytree +bench/qs*/binarytree0 +bench/qs*/plus-abs +bench/qs*/plus-abs-ineq +bench/qs*/bool +bench/qs*/list +bench/qs*/list-ineq +bench/qs*/length +bench/qs*/lenzip +bench/qs*/zip +bench/qs*/insertsort +bench/qs*/insertsort0 +bench/qs*/arithficial +bench/qs*/quickspec +bench/qs*/regexes +bench/qs*/regex + +# Haddock +doc/*.html +doc/*.css +doc/*.js +doc/*.png +doc/*.gif diff --git a/.travis.yml b/.travis.yml new file mode 100644 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,107 @@ +# .travis.yml file for Speculate +# +# Copyright: (c) 2017-2018 Rudy Matela +# License: 3-Clause BSD (see the file LICENSE) +# Maintainer: Rudy Matela + +language: c # not really + +notifications: + email: + on_failure: change + +sudo: false + +cache: + directories: + - $HOME/.ghc + - $HOME/.cabal + - $HOME/.stack + +before_install: +- export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH +- ghc --version +- cabal --version +- rm -f ~/.cabal/config && cabal update +# Download and unpack the stack executable +# "Once Travis whitelists the stack.dev files," simply include stack in the +# addons section. -- https://docs.haskellstack.org/en/stable/travis_ci/ +- mkdir -p ~/.local/bin +- export PATH=$HOME/.local/bin:$PATH +- travis_retry curl -L https://www.stackage.org/stack/linux-x86_64 | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack' +- stack config set system-ghc --global true +- stack --version +- cabal install leancheck cmdargs + +script: +- make && make test-without-extra-deps +- make haddock +- make test-sdist +- travis_wait 40 cabal test expr -v +- travis_wait 40 stack $STACKR --no-terminal --skip-ghc-check test speculate:test:expr -v + +matrix: + allow_failures: + - ghc: 'head' + include: + - ghc: 'head' + env: GHCVER=head CABALVER=head + addons: {apt: {packages: [ghc-head, cabal-install-head], sources: hvr-ghc}} + - ghc: '8.4' + env: GHCVER=8.4.2 CABALVER=2.2 + addons: {apt: {packages: [ghc-8.4.2, cabal-install-2.2], sources: hvr-ghc}} + - ghc: '8.2' + env: GHCVER=8.2.2 CABALVER=2.0 + addons: {apt: {packages: [ghc-8.2.2, cabal-install-2.0], sources: hvr-ghc}} + - ghc: '8.0' + env: GHCVER=8.0.2 CABALVER=1.24 + addons: {apt: {packages: [ghc-8.0.2, cabal-install-1.24], sources: hvr-ghc}} + - ghc: '7.10' + env: GHCVER=7.10.3 CABALVER=1.22 STACKR=--resolver=lts-11.11 + addons: {apt: {packages: [ghc-7.10.3, cabal-install-1.22], sources: hvr-ghc}} + # we only support stack with GHC >= 7.10 + - ghc: '7.8' + env: GHCVER=7.8.4 CABALVER=1.18 + addons: {apt: {packages: [ghc-7.8.4, cabal-install-1.18], sources: hvr-ghc}} + before_install: + - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH + - ghc --version + - cabal --version + - rm -f ~/.cabal/config && cabal update + - cabal install Cabal==1.18.* + - cabal install leancheck cmdargs + script: + - make && make test-without-extra-deps + - make haddock HADDOCKFLAGS= + - make test-sdist + - cabal test + - ghc: '7.6' + env: GHCVER=7.6.3 CABALVER=1.18 + addons: {apt: {packages: [ghc-7.6.3, cabal-install-1.18], sources: hvr-ghc}} + before_install: + - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH + - ghc --version + - cabal --version + - rm -f ~/.cabal/config && cabal update + - cabal install Cabal==1.18.* + - cabal install leancheck cmdargs + script: + - make && make test-without-extra-deps + - make haddock HADDOCKFLAGS= + - make test-sdist + - cabal test + - ghc: '7.4' + env: GHCVER=7.4.2 CABALVER=1.18 + addons: {apt: {packages: [ghc-7.4.2, cabal-install-1.18], sources: hvr-ghc}} + before_install: + - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH + - ghc --version + - cabal --version + - rm -f ~/.cabal/config && cabal update + - cabal install Cabal==1.18.* + - cabal install leancheck cmdargs + script: + - make && make test-without-extra-deps + - make haddock HADDOCKFLAGS= + - make test-sdist + - cabal test diff --git a/Makefile b/Makefile new file mode 100644 --- /dev/null +++ b/Makefile @@ -0,0 +1,234 @@ +# Makefile for Speculate +# +# Copyright: (c) 2015-2018 Rudy Matela +# License: 3-Clause BSD (see the file LICENSE) +# Maintainer: Rudy Matela +GHCIMPORTDIRS = src:eg:tests +GHCFLAGS = -O2 $(shell grep -q "Arch Linux" /etc/lsb-release && echo -dynamic) +# -prof -auto-all #-caf-all +# When profiling is enabled, to get the cost centres with more than 6% time: +# $ ./eg/arith +RTS -p -RTS +# $ cat arith.prof | grep -v ' [0-5].[0-9] ......$' +HADDOCKFLAGS = --no-print-missing-docs +MAXTESTS = 4000 +MAXSIZE = -s4 +TESTS = \ + tests/test-creason \ + tests/test-engine \ + tests/test-eval \ + tests/test-expr \ + tests/test-match \ + tests/test-misc \ + tests/test-order \ + tests/test-reason \ + tests/test-utils \ + tests/test-stats +MOSTEG = \ + eg/arith \ + eg/arith-negate-abs \ + eg/bool \ + eg/binarytree \ + eg/binarytree0 \ + eg/colour \ + eg/digraphs \ + eg/fun \ + eg/list \ + eg/length \ + eg/zip \ + eg/minus \ + eg/insertsort \ + eg/insertsort0 \ + eg/string \ + eg/oddeven \ + eg/plus-abs \ + eg/pretty \ + eg/ratio \ + eg/sets \ + eg/tauts \ + eg/monad \ + eg/tuples \ + bench/arithficial \ + bench/nord \ + bench/unit +EG = $(MOSTEG) \ + eg/regexes \ + eg/speculate-reason +EXTRAEG = $(EG) \ + eg/pretty-compact \ + eg/algebraic-graphs +# regexes needs regex-tdfa, which may break the build +# speculate-reason output differs in different GHC versions +QUICKTESTS = \ + tests/test-engine \ + tests/test-eval \ + tests/test-expr \ + tests/test-match \ + tests/test-order \ + tests/test-reason +QUICKEG = \ + eg/arith \ + eg/bool \ + eg/list + +all: mk/toplibs + +quick-test: $(patsubst %,%.test,$(QUICKTESTS)) \ + $(patsubst %,%.test-model,$(QUICKEG)) + +test: all $(patsubst %,%.test,$(TESTS)) \ + $(patsubst %,%.test-model,$(EG) $(wildcard bench/*-c)) + +test-without-extra-deps: all $(patsubst %,%.test,$(TESTS)) \ + $(patsubst %,%.test-model,$(MOSTEG) $(wildcard bench/*-c)) + +test-extra-deps: all $(patsubst %,%.test,$(TESTS)) \ + $(patsubst %,%.test-model,$(EXTRAEG) $(wildcard bench/*-c)) + +test-sdist: + ./tests/test-sdist + +legacy-test: + make clean && make -j8 GHC=ghc-8.2 && make quick-test -j8 GHC=ghc-8.2 + make clean && make -j8 GHC=ghc-8.0 && make quick-test -j8 GHC=ghc-8.0 + make clean && make -j8 GHC=ghc-7.10 && make quick-test -j8 GHC=ghc-7.10 + make clean && make -j8 GHC=ghc-7.8 && make quick-test -j8 GHC=ghc-7.8 + make clean && make -j8 && make slow-test -j8 + +test-via-cabal: + cabal configure --enable-tests --enable-benchmarks --ghc-options="-dynamic -Werror" && cabal build && cabal test + +legacy-test-via-cabal: + cabal clean && cabal-ghc-8.2 configure && cabal-ghc-8.2 test + cabal clean && cabal-ghc-8.0 configure && cabal-ghc-8.0 test + cabal clean && cabal-ghc-7.10 configure && cabal-ghc-7.10 test + cabal clean && cabal-ghc-7.8 configure && cabal-ghc-7.8 test + cabal clean && cabal test + +prepare-test: + cabal --ignore-sandbox install regex-tdfa cmdargs leancheck algebraic-graphs pretty-compact + +prepare-legacy-test: \ + prepare-legacy-test-8.2 \ + prepare-legacy-test-8.0 \ + prepare-legacy-test-7.10 \ + prepare-legacy-test-7.8 + +prepare-legacy-test-8.2: + cabal-ghc-8.2 update + cabal-ghc-8.2 --ignore-sandbox install regex-tdfa cmdargs leancheck + +prepare-legacy-test-8.0: + cabal-ghc-8.0 update + cabal-ghc-8.0 --ignore-sandbox install regex-tdfa cmdargs leancheck + +prepare-legacy-test-7.10: + cabal-ghc-7.10 update + cabal-ghc-7.10 --ignore-sandbox install regex-tdfa cmdargs leancheck + +prepare-legacy-test-7.8: + cabal-ghc-7.8 update + cabal-ghc-7.8 --ignore-sandbox install regex-tdfa cmdargs leancheck + +slow-test: MAXTESTS = +slow-test: MAXSIZE = +slow-test: test + +%.test: % + ./$< $(MAXTESTS) + +bench/%-c.test-model: eg/% + ./tests/test-model $(MAXSIZE) bench/$*-c + +bench/%-c.update-4-test-model: % + ./tests/update-test-model -s4 bench/$*-c + +bench/%-c.update-slow-test-model: % + ./tests/update-test-model bench/$*-c + +%.test-model: % + ./tests/test-model $(MAXSIZE) $< + +%.update-test-model: % + ./tests/update-test-model -s4 $< + ./tests/update-test-model $< + +%.update-4-test-model: % + ./tests/update-test-model -s4 $< + +%.update-slow-test-model: % + ./tests/update-test-model $< + +%.update-7-test-model: % + ./tests/update-test-model -s7 $< + +update-test-model: update-4-test-model update-slow-test-model + +update-4-test-model: $(patsubst %,%.update-4-test-model,$(EG) $(wildcard bench/*-c)) + +update-slow-test-model: $(patsubst %,%.update-slow-test-model,$(EG) $(wildcard bench/*-c)) + +bench: all + ./tests/benchmark-cmp $(EG) bench/*-c + +save-bench: all + ./tests/benchmark-save $(EG) bench/*-c + +memory-benchmark: all + ./tests/memory-benchmark $(EG) bench/*-c + +qs-bench: + make -sC bench/qs1 bench + make -sC bench/qs2 bench + +qs-save-bench: + make -sC bench/qs1 save-bench + make -sC bench/qs2 save-bench + +ghci: tests/Test.ghci + +clean: clean-hi-o + rm -f $(TESTS) $(EG) eg/*.dot eg/*.pdf TAGS tags mk/toplibs + make clean -C bench/qs1 + make clean -C bench/qs2 + rm -f doc/*.html doc/*.gif doc/*.css doc/*.js doc/*.png + +tests/Test.o: src/Test/Speculate.o + +# NOTE: (very hacky!) the following target allows parallel compilation (-jN) of +# eg and tests programs so long as they don't share dependencies _not_ stored +# in src/ and tests/. Runnable binaries should depend on mk/toplibs instead of +# actual Haskell source files +mk/toplibs: src/Test/Speculate.o tests/Test.o + touch mk/toplibs + +hlint: + hlint \ + --ignore "Use import/export shortcut" \ + --ignore "Use first" \ + --ignore "Use second" \ + --ignore "Use ***" \ + src bench tests + +include mk/haskell.mk + +%-3.dot: % + ./$< -gv3 > $@ + +%.dot: % + ./$< -gv2 > $@ + +%-2.dot: % + ./$< -gv2 > $@ + +%-1.dot: % + ./$< -gv1 > $@ + +%.eps: %.dot + dot -Teps $< > $@ + +%.pdf: %.eps + epstopdf $< + +.PHONY: %.view +%.view: %.pdf + o $< diff --git a/bench/arith-c b/bench/arith-c new file mode 100644 --- /dev/null +++ b/bench/arith-c @@ -0,0 +1,3 @@ +#!/bin/bash +EG=`dirname "$0"`/../eg +$EG/arith -ES -r0 -r1 -r2 -r3 diff --git a/bench/arithficial.hs b/bench/arithficial.hs new file mode 100644 --- /dev/null +++ b/bench/arithficial.hs @@ -0,0 +1,27 @@ +import Test.Speculate +import Test.Speculate.Utils (primeCycle) +import System.Environment (getArgs) + +-- How well does this tool performs on artificial operators +f :: Num a => a -> a -> a +f x y = x*17+23 + +g :: Num a => a -> a -> a +g x y = 42 + +h :: Num a => a -> a -> a +h x y = y*13+19 + +main :: IO () +main = speculate args + { instances = [ins "x" int] + , constants = + [ hole int + , showConstant (0::Int) + , constant "id" $ id -:> int + , constant "+" $ (+) -:> int + , constant "f" $ f -:> int + , constant "g" $ g -:> int + , constant "h" $ h -:> int + ] + } diff --git a/bench/bool-c b/bench/bool-c new file mode 100644 --- /dev/null +++ b/bench/bool-c @@ -0,0 +1,3 @@ +#!/bin/bash +EG=`dirname "$0"`/../eg +$EG/bool -ES -r0 -r1 -r2 -r3 diff --git a/bench/list-c b/bench/list-c new file mode 100644 --- /dev/null +++ b/bench/list-c @@ -0,0 +1,3 @@ +#!/bin/bash +EG=`dirname "$0"`/../eg +$EG/list -ES -r0 -r1 -r2 -r3 diff --git a/bench/minus-c b/bench/minus-c new file mode 100644 --- /dev/null +++ b/bench/minus-c @@ -0,0 +1,3 @@ +#!/bin/bash +EG=`dirname "$0"`/../eg +$EG/minus -ES -r0 -r1 -r2 -r3 diff --git a/bench/nord.hs b/bench/nord.hs new file mode 100644 --- /dev/null +++ b/bench/nord.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE CPP, DeriveDataTypeable, StandaloneDeriving #-} -- for GHC < 7.10 +import Test.Speculate +import Test.Speculate.Expr (name, listable, eq, ord) + +#if __GLASGOW_HASKELL__ < 710 +import Data.Typeable (Typeable1) +deriving instance Typeable EqButNotOrd +#endif + +data EqButNotOrd = C0 deriving (Eq, Show) + +instance Listable EqButNotOrd where + list = [C0] + +-- EqButNotOrd is an instance of Eq but not of Ord, +-- Speculate reports a warning reflecting that. +main :: IO () +main = speculate args + { instances = [ name "x" C0 + , listable C0 + , eq C0 + ] + , constants = [ showConstant C0 + , constant "id" (id :: EqButNotOrd -> EqButNotOrd) + ] + } diff --git a/bench/qs1/Makefile b/bench/qs1/Makefile new file mode 100644 --- /dev/null +++ b/bench/qs1/Makefile @@ -0,0 +1,42 @@ +BENCH = \ + arith \ + arith-negate-abs \ + plus-abs \ + bool \ + list \ + regexes \ + arithficial + +all: $(BENCH) + +bench: all + @echo -n "arith "; /usr/bin/time -f%e0 ./arith 2>&1 > arith.out + @echo -n "arith-negate-abs "; /usr/bin/time -f%e0 ./arith-negate-abs 2>&1 > arith-negate-abs.out + @echo -n "bool "; /usr/bin/time -f%e0 ./bool 2>&1 > bool.out + @echo -n "list "; /usr/bin/time -f%e0 ./list 2>&1 > list.out + @echo -n "arithficial "; /usr/bin/time -f%e0 ./arithficial 2>&1 > arithficial.out + @echo -n "plus-abs "; /usr/bin/time -f%e0 ./plus-abs 2>&1 > plus-abs.out + @echo "regexes 0.000"; + #@echo "This will take a couple minutes to run (regexes)" > /dev/stderr + #@echo -n "regexes "; /usr/bin/time -f%e0 ./regexes 2>&1 > regexes.out + +save-bench: bench + make -s bench > runtime-$$HOSTNAME + + +prepare: + cabal sandbox init + cabal install quickspec-0.9.6 + + + +regexes: regexes.hs ../../eg/Regex.hs + +%: %.hs + ghc -O2 -i../../eg -package-db .cabal-sandbox/*-packages.conf.d $< && touch $@ + +clean: + rm -rf *.o *.hi $(BENCH) + +clean-prepare: + rm -rf .cabal-sandbox cabal.sandbox.config diff --git a/bench/qs1/arith-negate-abs.hs b/bench/qs1/arith-negate-abs.hs new file mode 100644 --- /dev/null +++ b/bench/qs1/arith-negate-abs.hs @@ -0,0 +1,15 @@ +import Test.QuickSpec + +type I = Int + +main = + quickSpec + [ ["x", "y", "z"] `vars` (undefined :: I) + , "0" `fun0` (0 :: I) + , "1" `fun0` (1 :: I) + , "+" `fun2` ((+) :: I -> I -> I) + , "*" `fun2` ((*) :: I -> I -> I) + , "id" `fun1` (id :: I -> I) + , "abs" `fun1` (abs :: I -> I) + , "negate" `fun1` (negate :: I -> I) + ] diff --git a/bench/qs1/arith-negate-abs.out b/bench/qs1/arith-negate-abs.out new file mode 100644 --- /dev/null +++ b/bench/qs1/arith-negate-abs.out @@ -0,0 +1,48 @@ +== API == +-- functions -- +(+), (*) :: Int -> Int -> Int +id, abs, negate :: Int -> Int +0, 1 :: Int + +-- variables -- +x, y, z :: Int + +== Testing == +Depth 1: 6 terms, 3 tests, 14 evaluations, 6 classes, 0 raw equations. +Depth 2: 71 terms, 500 tests, 28109 evaluations, 29 classes, 42 raw equations. +Depth 3: 1658 terms, 500 tests, 821215 evaluations, 568 classes, 1090 raw equations. +1090 raw equations; 568 terms in universe. + +== Equations about (+) == + 1: x+y == y+x + 2: x+0 == x + 3: x+(y+z) == y+(x+z) + +== Equations about (*) == + 4: x*y == y*x + 5: x*0 == 0 + 6: x*1 == x + 7: x*(y*z) == y*(x*z) + +== Equations about id == + 8: id x == x + +== Equations about abs == + 9: abs 0 == 0 + 10: abs 1 == 1 + 11: abs (abs x) == abs x + +== Equations about negate == + 12: negate 0 == 0 + 13: negate (negate x) == x + +== Equations about several functions == + 14: x*negate y == negate (x*y) + 15: x*(y+y) == y*(x+x) + 16: abs (negate x) == abs x + 17: abs (x*x) == x*x + 18: x+negate x == 0 + 19: (x*y)+(x*z) == x*(y+z) + 20: abs x*abs y == abs (x*y) + 21: abs x+abs x == abs (x+x) + diff --git a/bench/qs1/arith.hs b/bench/qs1/arith.hs new file mode 100644 --- /dev/null +++ b/bench/qs1/arith.hs @@ -0,0 +1,15 @@ +import Test.QuickSpec + +type I = Int + +main = + quickSpec + [ ["x", "y", "z"] `vars` (undefined :: I) + , "0" `fun0` (0 :: I) + , "1" `fun0` (1 :: I) + , "+" `fun2` ((+) :: I -> I -> I) + , "*" `fun2` ((*) :: I -> I -> I) + , withSize 7 + , withDepth 4 + , withTests 500 + ] diff --git a/bench/qs1/arith.out b/bench/qs1/arith.out new file mode 100644 --- /dev/null +++ b/bench/qs1/arith.out @@ -0,0 +1,30 @@ +== API == +-- functions -- +(+), (*) :: Int -> Int -> Int +0, 1 :: Int + +-- variables -- +x, y, z :: Int + +== Testing == +Depth 1: 6 terms, 2 tests, 10 evaluations, 6 classes, 0 raw equations. +Depth 2: 56 terms, 500 tests, 24069 evaluations, 22 classes, 34 raw equations. +Depth 3: 888 terms, 500 tests, 438420 evaluations, 298 classes, 590 raw equations. +Depth 4: 2268 terms, 500 tests, 1131290 evaluations, 452 classes, 1816 raw equations. +1816 raw equations; 452 terms in universe. + +== Equations about (+) == + 1: x+y == y+x + 2: x+0 == x + 3: x+(y+z) == y+(x+z) + +== Equations about (*) == + 4: x*y == y*x + 5: x*0 == 0 + 6: x*1 == x + 7: x*(y*z) == y*(x*z) + +== Equations about several functions == + 8: x*(y+y) == y*(x+x) + 9: (x*y)+(x*z) == x*(y+z) + diff --git a/bench/qs1/arithficial.hs b/bench/qs1/arithficial.hs new file mode 100644 --- /dev/null +++ b/bench/qs1/arithficial.hs @@ -0,0 +1,23 @@ +import Test.QuickSpec + +f :: Num a => a -> a -> a +f x y = x*17+23 + +g :: Num a => a -> a -> a +g x y = 42 + +h :: Num a => a -> a -> a +h x y = y*13+19 + +type I = Int + +main = + quickSpec + [ ["x", "y", "z", "w"] `vars` (undefined :: I) + , "0" `fun0` (0 :: I) + , "id" `fun1` (id :: I -> I) + , "+" `fun2` ((+) :: I -> I -> I) + , "f" `fun2` (f :: I -> I -> I) + , "g" `fun2` (g :: I -> I -> I) + , "h" `fun2` (h :: I -> I -> I) + ] diff --git a/bench/qs1/arithficial.out b/bench/qs1/arithficial.out new file mode 100644 --- /dev/null +++ b/bench/qs1/arithficial.out @@ -0,0 +1,36 @@ +== API == +-- functions -- +(+), f, g, h :: Int -> Int -> Int +id :: Int -> Int +0 :: Int + +-- variables -- +x, y, z, w :: Int + +== Testing == +Depth 1: 6 terms, 3 tests, 15 evaluations, 6 classes, 0 raw equations. +Depth 2: 111 terms, 500 tests, 53118 evaluations, 27 classes, 84 raw equations. +Depth 3: 2736 terms, 500 tests, 1362764 evaluations, 343 classes, 2393 raw equations. +2393 raw equations; 343 terms in universe. + +== Equations about (+) == + 1: x+y == y+x + 2: x+0 == x + 3: x+(y+z) == y+(x+z) + +== Equations about f == + 4: f x y == f x z + +== Equations about g == + 5: g x y == g x z + 6: g x y == g y x + +== Equations about h == + 7: h x y == h z y + +== Equations about id == + 8: id x == x + +== Equations about several functions == + 9: h x 0+f 0 x == g x y + diff --git a/bench/qs1/bool.hs b/bench/qs1/bool.hs new file mode 100644 --- /dev/null +++ b/bench/qs1/bool.hs @@ -0,0 +1,11 @@ +import Test.QuickSpec + +main = + quickSpec + [ ["p", "q", "r"] `vars` (undefined :: Bool) + , "False" `fun0` False + , "True" `fun0` True + , "not" `fun1` not + , "&&" `fun2` (&&) + , "||" `fun2` (||) + ] diff --git a/bench/qs1/bool.out b/bench/qs1/bool.out new file mode 100644 --- /dev/null +++ b/bench/qs1/bool.out @@ -0,0 +1,44 @@ +== API == +-- functions -- +False, True :: Bool +not :: Bool -> Bool +(&&), (||) :: Bool -> Bool -> Bool + +-- variables -- +p, q, r :: Bool + +== Testing == +Depth 1: 6 terms, 5 tests, 17 evaluations, 6 classes, 0 raw equations. +Depth 2: 61 terms, 500 tests, 28574 evaluations, 15 classes, 46 raw equations. +Depth 3: 412 terms, 500 tests, 205912 evaluations, 53 classes, 359 raw equations. +359 raw equations; 53 terms in universe. + +== Equations about not == + 1: not False == True + 2: not True == False + 3: not (not p) == p + +== Equations about (&&) == + 4: p&&q == q&&p + 5: p&&p == p + 6: p&&False == False + 7: p&&True == p + 8: p&&(q&&r) == q&&(p&&r) + +== Equations about (||) == + 9: p||q == q||p + 10: p||p == p + 11: p||False == p + 12: p||True == True + 13: p||(q||r) == q||(p||r) + +== Equations about several functions == + 14: p&&(p||q) == p + 15: p||(p&&q) == p + 16: p&¬ p == False + 17: p||not p == True + 18: (p||q)&&(p||r) == p||(q&&r) + 19: (p&&q)||(p&&r) == p&&(q||r) + 20: not p&¬ q == not (p||q) + 21: not p||not q == not (p&&q) + diff --git a/bench/qs1/list.hs b/bench/qs1/list.hs new file mode 100644 --- /dev/null +++ b/bench/qs1/list.hs @@ -0,0 +1,15 @@ +import Test.QuickSpec + +main = + quickSpec + [ withTests 500 + , withDepth 4 + , withSize 7 + , ["x", "y", "z"] `vars` (undefined :: Int) + , ["xs", "ys", "zs"] `vars` (undefined :: [Int]) + , "[]" `fun0` ([] :: [Int]) + , ":" `fun2` ((:) :: Int -> [Int] -> [Int]) + , "++" `fun2` ((++) :: [Int] -> [Int] -> [Int]) + , "head" `fun1` (head :: [Int] -> Int) + , "tail" `fun1` (tail :: [Int] -> [Int]) + ] diff --git a/bench/qs1/list.out b/bench/qs1/list.out new file mode 100644 --- /dev/null +++ b/bench/qs1/list.out @@ -0,0 +1,55 @@ +== API == +-- functions -- +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +head :: [Int] -> Int +tail :: [Int] -> [Int] +[] :: [Int] + +-- variables -- +x, y, z :: Int +xs, ys, zs :: [Int] + +== Testing == +Depth 1: 9 terms, 3 tests, 18 evaluations, 9 classes, 0 raw equations. +Depth 2: 45 terms, 500 tests, 7585 evaluations, 36 classes, 9 raw equations. +Depth 3: 1017 terms, 500 tests, 182341 evaluations, 795 classes, 222 raw equations. +Depth 4: 4575 terms, 500 tests, 1724824 evaluations, 2316 classes, 2259 raw equations. +2259 raw equations; 2316 terms in universe. + +== Equations about (++) == + 1: xs++[] == xs + 2: []++xs == xs + 3: (xs++ys)++zs == xs++(ys++zs) + +== Equations about head == + 4: head [] == undefined + +== Equations about tail == + 5: tail [] == undefined + +== Equations about several functions == + 6: (x:xs)++ys == x:(xs++ys) + 7: head (x:xs) == x + 8: tail (x:xs) == xs + 9: head (xs++xs) == head xs + 10: tail xs++xs == tail (xs++xs) + 11: head (xs++(x:ys)) == head (xs++(x:zs)) + 12: head (xs++(xs++ys)) == head (xs++ys) + 13: head (xs++(ys++xs)) == head (xs++ys) + 14: head (xs++(ys++ys)) == head (xs++ys) + 15: tail (xs++ys)++xs == tail (xs++(ys++xs)) + 16: tail (xs++ys)++ys == tail (xs++(ys++ys)) + 17: head (xs++tail xs) == head xs + 18: tail (xs++tail xs) == tail xs++tail xs + 19: head ((x:xs)++tail ys) == x + 20: tail ((x:xs)++tail ys) == xs++tail ys + 21: head ((xs++ys)++tail xs) == head (xs++ys) + 22: head ((xs++ys)++tail ys) == head (xs++ys) + 23: head (tail xs++(xs++ys)) == head (tail (xs++xs)) + 24: head xs:(tail xs++ys) == head xs:tail (xs++ys) + 25: tail xs++(tail xs++ys) == tail xs++tail (xs++ys) + 26: tail (xs++ys)++tail xs == tail ((xs++ys)++tail xs) + 27: tail (xs++ys)++tail ys == tail ((xs++ys)++tail ys) + 28: head xs:tail (xs++xs) == xs++(head xs:tail xs) + diff --git a/bench/qs1/plus-abs.hs b/bench/qs1/plus-abs.hs new file mode 100644 --- /dev/null +++ b/bench/qs1/plus-abs.hs @@ -0,0 +1,13 @@ +import Test.QuickSpec + +main = quickSpec + [ withSize 7 + , withDepth 4 + , withTests 500 + , ["x", "y", "z"] `vars` (undefined :: Int) + , "0" `fun0` (0 :: Int) + , "1" `fun0` (1 :: Int) + , "+" `fun2` ((+) :: Int -> Int -> Int) + , "id" `fun1` (id :: Int -> Int) + , "abs" `fun1` (abs :: Int -> Int) + ] diff --git a/bench/qs1/plus-abs.out b/bench/qs1/plus-abs.out new file mode 100644 --- /dev/null +++ b/bench/qs1/plus-abs.out @@ -0,0 +1,38 @@ +== API == +-- functions -- +(+) :: Int -> Int -> Int +id, abs :: Int -> Int +0, 1 :: Int + +-- variables -- +x, y, z :: Int + +== Testing == +Depth 1: 6 terms, 3 tests, 12 evaluations, 6 classes, 0 raw equations. +Depth 2: 41 terms, 500 tests, 16556 evaluations, 19 classes, 22 raw equations. +Depth 3: 366 terms, 500 tests, 177899 evaluations, 128 classes, 238 raw equations. +Depth 4: 1080 terms, 500 tests, 520862 evaluations, 243 classes, 837 raw equations. +837 raw equations; 243 terms in universe. + +== Equations about (+) == + 1: x+y == y+x + 2: x+0 == x + 3: x+(y+z) == y+(x+z) + +== Equations about id == + 4: id x == x + +== Equations about abs == + 5: abs 0 == 0 + 6: abs 1 == 1 + 7: abs (abs x) == abs x + +== Equations about several functions == + 8: abs x+abs x == abs (x+x) + 9: abs (x+abs x) == x+abs x + 10: abs (abs x+abs y) == abs x+abs y + 11: abs (abs x+(x+x)) == x+abs (x+x) + 12: abs x+abs (x+x) == abs (x+(x+x)) + 13: abs (abs x+(x+1)) == abs x+(x+1) + 14: abs x+abs (x+1) == abs (x+(x+1)) + diff --git a/bench/qs1/regexes.hs b/bench/qs1/regexes.hs new file mode 100644 --- /dev/null +++ b/bench/qs1/regexes.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE StandaloneDeriving #-} +import Regex +import Test.QuickCheck +import Control.Monad +import Test.QuickSpec + +deriving instance Eq a => Eq (RE a) +deriving instance Ord a => Ord (RE a) + +instance Arbitrary Symbol where + arbitrary = elements $ map Symbol ['a','b','c'] + +instance Arbitrary a => Arbitrary (RE a) where + arbitrary = sized re + where + re 0 = oneof + [ return Empty + , return None + , liftM Lit arbitrary + ] + re n = oneof + [ re 0 + , liftM Star (re (n - 1)) + , liftM2 (:.) re2 re2 + , liftM2 (:+) re2 re2 + ] where re2 = re (n `div` 2) + shrink Empty = [] + shrink None = [] + shrink (Lit _) = [Empty, None] + shrink (Star r) = [r] ++ [Star r' | r' <- shrink r] + shrink (r :+ s) = [r, s] ++ [r' :+ s' | (r',s') <- shrink (r,s)] + shrink (r :. s) = [r, s] ++ [r' :. s' | (r',s') <- shrink (r,s)] + +main = quickSpec + [ ["r1", "r2", "r3"] `vars` (undefined :: RE Symbol) + , "Empty" `fun0` (Empty :: RE Symbol) + , "None" `fun0` (None :: RE Symbol) + , "Star" `fun1` (Star :: RE Symbol -> RE Symbol) + , ":+" `fun2` ((:+) :: RE Symbol -> RE Symbol -> RE Symbol) + , ":." `fun2` ((:.) :: RE Symbol -> RE Symbol -> RE Symbol) +--, "=~" `fun2` (=~) +--, "Lit" `fun2` (Lit :: Symbol -> RE Symbol) + , observer2 (=~) + , withDepth 3 + , withSize 100 + , withTests 500 + , withQuickCheckSize 20 + ] diff --git a/bench/qs1/regexes.out b/bench/qs1/regexes.out new file mode 100644 --- /dev/null +++ b/bench/qs1/regexes.out @@ -0,0 +1,48 @@ +== API == +-- functions -- +Empty, None :: RE Symbol +Star :: RE Symbol -> RE Symbol +(:+), (:.) :: RE Symbol -> RE Symbol -> RE Symbol + +-- variables -- +r1, r2, r3 :: RE Symbol + +-- the following types are using non-standard equality -- +RE Symbol + +== Testing == +Depth 1: 6 terms, 22 tests, 81 evaluations, 6 classes, 0 raw equations. +Depth 2: 61 terms, 1000 tests, 28370 evaluations, 24 classes, 37 raw equations. +Depth 3: 1087 terms, 2000 tests, 543254 evaluations, 532 classes, 555 raw equations. +555 raw equations; 532 terms in universe. + +== Equations about Star == + 1: Star Empty == Empty + 2: Star None == Empty + 3: Star (Star r1) == Star r1 + +== Equations about (:+) == + 4: r1:+r2 == r2:+r1 + 5: r1:+r1 == r1 + 6: r1:+None == r1 + 7: r1:+(r2:+r3) == r2:+(r1:+r3) + +== Equations about (:.) == + 8: r1:.Empty == r1 + 9: r1:.None == None + 10: Empty:.r1 == r1 + 11: None:.r1 == None + 12: (r1:.r2):.r3 == r1:.(r2:.r3) + +== Equations about several functions == + 13: r1:+Star r1 == Star r1 + 14: Star r1:.r1 == r1:.Star r1 + 15: (r1:.r2):+(r1:.r3) == r1:.(r2:+r3) + 16: (r1:.r2):+(r3:.r2) == (r1:+r3):.r2 + 17: Star (r1:+Empty) == Star r1 + 18: Star r1:+(r1:.r1) == Star r1 + 19: Star r1:.Star r1 == Star r1 + 20: (r1:.r1):.Star r1 == Star r1:.(r1:.r1) + 21: Star r1:.(r1:+Empty) == Star r1 + 22: (r1:+Empty):.(r1:+Empty) == (r1:.r1):+(r1:+Empty) + diff --git a/bench/qs1/runtime-zero b/bench/qs1/runtime-zero new file mode 100644 --- /dev/null +++ b/bench/qs1/runtime-zero @@ -0,0 +1,7 @@ +arith 94.190 +arith-negate-abs 0.830 +bool 0.230 +list 49.290 +arithficial 1.260 +plus-abs 6.330 +regexes 0.000 diff --git a/bench/qs2/Makefile b/bench/qs2/Makefile new file mode 100644 --- /dev/null +++ b/bench/qs2/Makefile @@ -0,0 +1,58 @@ +BENCH = \ + arith \ + arithficial \ + arith-negate-abs \ + binarytree \ + bool \ + insertsort \ + list \ + list-ineq \ + plus-abs \ + plus-abs-ineq \ + regexes \ + zip + +all: $(BENCH) + +bench: all + @echo -n "arith "; /usr/bin/time -f%e0 ./arith 2>&1 > arith.out + @echo -n "arith-negate-abs "; /usr/bin/time -f%e0 ./arith-negate-abs 2>&1 > arith-negate-abs.out + @echo -n "bool "; /usr/bin/time -f%e0 ./bool 2>&1 > bool.out + @echo -n "list "; /usr/bin/time -f%e0 ./list 2>&1 > list.out + @echo -n "insertsort "; /usr/bin/time -f%e0 ./insertsort 2>&1 > insertsort.out + @echo -n "zip "; /usr/bin/time -f%e0 ./zip 2>&1 > zip.out + @echo -n "arithficial "; /usr/bin/time -f%e0 ./arithficial 2>&1 > arithficial.out + @echo -n "plus-abs "; /usr/bin/time -f%e0 ./plus-abs 2>&1 > plus-abs.out + @echo -n "regexes "; /usr/bin/time -f%e0 ./regexes 2>&1 > regexes.out + @echo -n "binarytree "; /usr/bin/time -f%e0 ./binarytree 2>&1 > binarytree.out + +bench-binarytree: binarytree + for i in {1..6}; do /usr/bin/time -f%e0 ./binarytree 2>&1 > binarytree.out$$i; done | tee binarytree.runtime-zero + +save-bench: bench + make -s bench > runtime-$$HOSTNAME + +# this takes a few minutes +prepare: + cabal sandbox init + git clone https://github.com/nick8325/quickspec + cabal sandbox add-source quickspec + cabal install quickspec + +prepare-algehed: + cabal sandbox init + git clone https://github.com/MaximilianAlgehed/quickspec + # git -C quickspec checkout fd53aae3acdcba0e962a72bce652f102c13aaeb9 + cabal sandbox add-source quickspec + cabal install quickspec + +regexes: regexes.hs ../../eg/Regex.hs + +%: %.hs + ghc -O2 -i../../eg -package-db .cabal-sandbox/*-packages.conf.d $< && touch $@ + +clean: + rm -rf *.o *.hi $(BENCH) + +clean-prepare: + rm -rf .cabal-sandbox cabal.sandbox.config quickspec diff --git a/bench/qs2/arith-negate-abs.hs b/bench/qs2/arith-negate-abs.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/arith-negate-abs.hs @@ -0,0 +1,14 @@ +import QuickSpec + +main = quickSpec signature + { maxTermSize = Just 5 + , constants = + [ constant "0" (0 :: Int) + , constant "1" (1 :: Int) + , constant "+" ((+) :: Int -> Int -> Int) + , constant "*" ((*) :: Int -> Int -> Int) + , constant "id" (id :: Int -> Int) + , constant "negate" (negate :: Int -> Int) + , constant "abs" (abs :: Int -> Int) + ] + } diff --git a/bench/qs2/arith-negate-abs.out b/bench/qs2/arith-negate-abs.out new file mode 100644 --- /dev/null +++ b/bench/qs2/arith-negate-abs.out @@ -0,0 +1,40 @@ +== Signature == + 0 :: Int + 1 :: Int + (+) :: Int -> Int -> Int + (*) :: Int -> Int -> Int + id :: Int -> Int +negate :: Int -> Int + abs :: Int -> Int + +== Laws == + 1. id x = x + 2. abs 0 = 0 + 3. abs 1 = 1 + 4. negate 0 = 0 + 5. x * 0 = 0 + 6. x * 1 = x + 7. 0 * x = 0 + 8. 1 * x = x + 9. x + 0 = x + 10. 0 + x = x + 11. abs (abs x) = abs x + 12. abs (negate x) = abs x + 13. negate (negate x) = x + 14. x * y = y * x + 15. x + y = y + x + 16. negate x * y = x * negate y + 17. x + negate x = 0 + 18. abs (x * x) = x * x + 19. negate (x * y) = x * negate y + 20. abs (1 + 1) = 1 + 1 + 21. (x * y) * z = x * (y * z) + 22. (x + y) + z = x + (y + z) + 23. x * (y + 1) = x + (x * y) + 24. abs x * abs y = abs (x * y) + 25. abs x + abs x = abs (x + x) + 26. negate x + negate y = negate (x + y) + 27. abs (x + abs x) = x + abs x + 28. abs (1 + abs x) = 1 + abs x + 29. x * (y + y) = y * (x + x) + diff --git a/bench/qs2/arith.hs b/bench/qs2/arith.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/arith.hs @@ -0,0 +1,13 @@ +import QuickSpec + +main = quickSpec signature + { maxTermSize = Just 7 + , maxTermDepth = Just 4 + , maxTests = Just 500 + , constants = + [ constant "0" (0 :: Int) + , constant "1" (1 :: Int) + , constant "+" ((+) :: Int -> Int -> Int) + , constant "*" ((*) :: Int -> Int -> Int) + ] + } diff --git a/bench/qs2/arith.out b/bench/qs2/arith.out new file mode 100644 --- /dev/null +++ b/bench/qs2/arith.out @@ -0,0 +1,21 @@ +== Signature == + 0 :: Int + 1 :: Int +(+) :: Int -> Int -> Int +(*) :: Int -> Int -> Int + +== Laws == + 1. x * 0 = 0 + 2. x * 1 = x + 3. 0 * x = 0 + 4. 1 * x = x + 5. x + 0 = x + 6. 0 + x = x + 7. x * y = y * x + 8. x + y = y + x + 9. (x * y) * z = x * (y * z) + 10. (x + y) + z = x + (y + z) + 11. x * (y + 1) = x + (x * y) + 12. (x * y) + (x * z) = x * (y + z) + 13. x * (y + (y + y)) = y * (x + (x + x)) + diff --git a/bench/qs2/arithficial.hs b/bench/qs2/arithficial.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/arithficial.hs @@ -0,0 +1,22 @@ +import QuickSpec + +f :: Num a => a -> a -> a +f x y = x*17+23 + +g :: Num a => a -> a -> a +g x y = 42 + +h :: Num a => a -> a -> a +h x y = y*13+19 + +main = quickSpec signature + { maxTermSize = Just 5 + , constants = + [ constant "0" (0 :: Int) + , constant "id" (id :: Int -> Int) + , constant "+" ((+) :: Int -> Int -> Int) + , constant "f" (f :: Int -> Int -> Int) + , constant "g" (g :: Int -> Int -> Int) + , constant "h" (h :: Int -> Int -> Int) + ] + } diff --git a/bench/qs2/arithficial.out b/bench/qs2/arithficial.out new file mode 100644 --- /dev/null +++ b/bench/qs2/arithficial.out @@ -0,0 +1,19 @@ +== Signature == + 0 :: Int + id :: Int -> Int +(+) :: Int -> Int -> Int + f :: Int -> Int -> Int + g :: Int -> Int -> Int + h :: Int -> Int -> Int + +== Laws == + 1. id x = x + 2. x + 0 = x + 3. 0 + x = x + 4. x + y = y + x + 5. f x x = f x y + 6. g x y = g y x + 7. g x x = g x y + 8. h y y = h x y + 9. (x + y) + z = x + (y + z) + diff --git a/bench/qs2/binarytree.hs b/bench/qs2/binarytree.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.hs @@ -0,0 +1,121 @@ +import QuickSpec hiding (insert) +import Test.QuickCheck hiding (insert,(==>)) +import Data.Function (on) +import Data.List (isSubsequenceOf) + +data BT a = Null | Fork (BT a) a (BT a) + deriving (Show) + +instance (Eq a, Ord a) => Eq (BT a) where + (==) = (==) `on` toList + +instance (Eq a, Ord a) => Ord (BT a) where + (<=) = isSubsequenceOf `on` toList + +insert :: Ord a => a -> BT a -> BT a +insert x Null = Fork Null x Null +insert x t@(Fork t1 y t2) = case compare x y of + LT -> Fork (insert x t1) y t2 + EQ -> t + GT -> Fork t1 y (insert x t2) + +delete :: Ord a => a -> BT a -> BT a +delete x Null = Null +delete x t@(Fork t1 y t2) = case compare x y of + LT -> Fork (delete x t1) y t2 + EQ -> graft t1 t2 + GT -> Fork t1 y (delete x t2) + +isIn :: Ord a => a -> BT a -> Bool +isIn x t = x `elem` toList t + +graft :: Ord a => BT a -> BT a -> BT a +graft Null t = t +graft (Fork t1 x t2) t = Fork t1 x (graft t2 t) + +toList :: Ord a => BT a -> [a] +toList Null = [] +toList (Fork t1 x t2) = toList t1 ++ [x] ++ toList t2 + +fromList :: Ord a => [a] -> BT a +fromList = foldr insert Null + +{- +fromList :: Ord a => [a] -> BT a +fromList [] = Null +fromList xs = Fork (fromList ys) x (fromList zs) + where + (x:ys,zs) = deal xs + +deal :: [a] -> ([a],[a]) +deal [] = ([],[]) +deal (x:xs) = (x:ys,zs) + where + (zs,ys) = deal xs +-} + +isSearch :: Ord a => BT a -> Bool +isSearch = strictlyOrdered . toList + +ordered :: Ord a => [a] -> Bool +ordered [] = True +ordered xs = and (zipWith (<=) xs $ tail xs) + +strictlyOrdered :: Ord a => [a] -> Bool +strictlyOrdered [] = True +strictlyOrdered xs = and (zipWith (<) xs $ tail xs) + +-- | truncate tiers of values in the presence of one empty size +-- +-- truncateT [[x,y],[z,w],[],[],[],...] == [[x,y],[z,w]] +truncateT :: [[a]] -> [[a]] +truncateT ([]:xss) = [] +truncateT (xs:xss) = xs:truncateT xss +truncateT xss = xss + +instance (Ord a, Arbitrary a) => Arbitrary (BT a) where + arbitrary = sized arbtree + where + arbtree 0 = return Null + arbtree n = oneof + [ return Null + , (Fork <$> arbtree (n `div` 2) <*> arbitrary <*> arbtree (n `div` 2)) + `suchThat` isSearch + ] + +type Item = Int + +main = quickSpec signature + { maxTermSize = Just 9 + , maxTests = Just 2000 +-- the maximum number of tests above needs to be 2000, +-- otherwise the law `isIn x t1 ==> isIn x (insert y t1) = True` +-- does not appear in the output (which is mainly what I want with this +-- benchmark). Even so, it works only about 2/3 of the time. + , constants = + [ constant "Null" (Null :: BT Item) + , constant "insert" (insert :: Item -> BT Item -> BT Item) + , constant "delete" (delete :: Item -> BT Item -> BT Item) + , constant "isIn" (isIn :: Item -> BT Item -> Bool) +-- , constant "<=" ((<=) :: Item -> Item -> Bool) +-- , constant "<=" ((<=) :: BT Item -> BT Item -> Bool) +-- , constant "/=" ((/=) :: Item -> Item -> Bool) +-- , constant "ordered" (ordered :: [Item] -> Bool) +-- , constant "strictlyOrdered" (strictlyOrdered :: [Item] -> Bool) +-- , constant "toList" (toList :: BT Item -> [Item]) +-- , constant "fromList" (fromList :: [Item] -> BT Item) +-- , constant "isSearch" (isSearch :: BT Item -> Bool) +-- , constant "[]" ([]::[Item]) + , constant "==>" ((==>) :: Bool -> Bool -> Bool) + , constant "True" True + , constant "False" False + ] + , instances = + [ baseType (undefined :: BT Item) + , baseTypeNames ["t1","t2","t3"] (undefined :: BT Item) + ] + } + +(==>) :: Bool -> Bool -> Bool +False ==> _ = True +True ==> p = p diff --git a/bench/qs2/binarytree.out b/bench/qs2/binarytree.out new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.out @@ -0,0 +1,55 @@ +== Signature == + Null :: BT Int +insert :: Int -> BT Int -> BT Int +delete :: Int -> BT Int -> BT Int + isIn :: Int -> BT Int -> Bool + (==>) :: Bool -> Bool -> Bool + True :: Bool + False :: Bool + +== Laws == + 1. x ==> x = True + 2. x ==> True = True + 3. False ==> x = True + 4. True ==> x = x + 5. delete x Null = Null + 6. isIn x Null = False + 7. x ==> (x ==> y) = x ==> y + 8. x ==> (y ==> x) = True + 9. (x ==> y) ==> x = x + 10. delete x (delete x t1) = delete x t1 + 11. delete x (insert x t1) = delete x (delete x t1) + 12. insert x (delete x t1) = insert x t1 + 13. isIn x (delete x t1) = False + 14. isIn x (insert x t1) = True + 15. (x ==> False) ==> False = x + 16. x ==> (y ==> z) = y ==> (x ==> z) + 17. (x ==> y) ==> y = (y ==> x) ==> x + 18. delete y (delete x t1) = delete x (delete y t1) + 19. insert y (insert x t1) = insert x (insert y t1) + 20. isIn x (insert y Null) = isIn y (insert x Null) + 21. isIn x (insert y (delete x t1)) = isIn x (insert y Null) + 22. isIn x (insert y Null) ==> False = + isIn x (delete y (insert x t1)) + 23. isIn x (delete y (insert z Null)) = + isIn z (delete y (insert x Null)) + 24. (((x ==> y) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 25. isIn x t1 ==> isIn x (insert y t1) = True + 26. isIn x t1 ==> isIn y (insert x t1) = isIn x t1 ==> isIn y t1 + 27. isIn x (delete y t1) ==> isIn x t2 = + isIn x t1 ==> isIn x (insert y t2) + 28. isIn x (delete y t1) ==> isIn y t1 = isIn x t1 ==> isIn y t1 + 29. isIn x (delete y (insert z (delete x t1))) = + isIn x (delete y (insert z Null)) + 30. isIn x (insert y (insert z (delete x t1))) = + isIn x (insert y (insert z Null)) + 31. isIn x (delete y (insert z Null)) ==> False = + isIn x (insert y (delete z (insert x t1))) + 32. isIn x (insert y (insert z Null)) ==> False = + isIn x (delete y (delete z (insert x t1))) + 33. (((x ==> x2) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 34. isIn x t1 ==> isIn y (delete z t2) = + isIn x t1 ==> isIn y (delete x t2) + diff --git a/bench/qs2/binarytree.out1 b/bench/qs2/binarytree.out1 new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.out1 @@ -0,0 +1,55 @@ +== Signature == + Null :: BT Int +insert :: Int -> BT Int -> BT Int +delete :: Int -> BT Int -> BT Int + isIn :: Int -> BT Int -> Bool + (==>) :: Bool -> Bool -> Bool + True :: Bool + False :: Bool + +== Laws == + 1. x ==> x = True + 2. x ==> True = True + 3. False ==> x = True + 4. True ==> x = x + 5. delete x Null = Null + 6. isIn x Null = False + 7. x ==> (x ==> y) = x ==> y + 8. x ==> (y ==> x) = True + 9. (x ==> y) ==> x = x + 10. delete x (delete x t1) = delete x t1 + 11. delete x (insert x t1) = delete x (delete x t1) + 12. insert x (delete x t1) = insert x t1 + 13. isIn x (delete x t1) = False + 14. isIn x (insert x t1) = True + 15. (x ==> False) ==> False = x + 16. x ==> (y ==> z) = y ==> (x ==> z) + 17. (x ==> y) ==> y = (y ==> x) ==> x + 18. delete y (delete x t1) = delete x (delete y t1) + 19. insert y (insert x t1) = insert x (insert y t1) + 20. isIn x (insert y Null) = isIn y (insert x Null) + 21. isIn x (insert y (delete x t1)) = isIn x (insert y Null) + 22. isIn x (insert y Null) ==> False = + isIn x (delete y (insert x t1)) + 23. isIn x (delete y (insert z Null)) = + isIn z (delete y (insert x Null)) + 24. (((x ==> y) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 25. isIn x t1 ==> isIn x (insert y t1) = True + 26. isIn x t1 ==> isIn y (insert x t1) = isIn x t1 ==> isIn y t1 + 27. isIn x (delete y t1) ==> isIn x t2 = + isIn x t1 ==> isIn x (insert y t2) + 28. isIn x (delete y t1) ==> isIn y t1 = isIn x t1 ==> isIn y t1 + 29. isIn x (delete y (insert z (delete x t1))) = + isIn x (delete y (insert z Null)) + 30. isIn x (insert y (insert z (delete x t1))) = + isIn x (insert y (insert z Null)) + 31. isIn x (delete y (insert z Null)) ==> False = + isIn x (insert y (delete z (insert x t1))) + 32. isIn x (insert y (insert z Null)) ==> False = + isIn x (delete y (delete z (insert x t1))) + 33. (((x ==> x2) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 34. isIn x t1 ==> isIn y (delete x t2) = + isIn x t1 ==> isIn y (delete z t2) + diff --git a/bench/qs2/binarytree.out2 b/bench/qs2/binarytree.out2 new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.out2 @@ -0,0 +1,55 @@ +== Signature == + Null :: BT Int +insert :: Int -> BT Int -> BT Int +delete :: Int -> BT Int -> BT Int + isIn :: Int -> BT Int -> Bool + (==>) :: Bool -> Bool -> Bool + True :: Bool + False :: Bool + +== Laws == + 1. x ==> x = True + 2. x ==> True = True + 3. False ==> x = True + 4. True ==> x = x + 5. delete x Null = Null + 6. isIn x Null = False + 7. x ==> (x ==> y) = x ==> y + 8. x ==> (y ==> x) = True + 9. (x ==> y) ==> x = x + 10. delete x (delete x t1) = delete x t1 + 11. delete x (insert x t1) = delete x (delete x t1) + 12. insert x (delete x t1) = insert x t1 + 13. isIn x (delete x t1) = False + 14. isIn x (insert x t1) = True + 15. (x ==> False) ==> False = x + 16. x ==> (y ==> z) = y ==> (x ==> z) + 17. (x ==> y) ==> y = (y ==> x) ==> x + 18. delete y (delete x t1) = delete x (delete y t1) + 19. insert y (insert x t1) = insert x (insert y t1) + 20. isIn x (insert y Null) = isIn y (insert x Null) + 21. isIn x (insert y (delete x t1)) = isIn x (insert y Null) + 22. isIn x (insert y Null) ==> False = + isIn x (delete y (insert x t1)) + 23. isIn x (delete y (insert z Null)) = + isIn z (delete y (insert x Null)) + 24. (((x ==> y) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 25. isIn x t1 ==> isIn x (insert y t1) = True + 26. isIn x t1 ==> isIn y (insert x t1) = isIn x t1 ==> isIn y t1 + 27. isIn x (delete y t1) ==> isIn x t2 = + isIn x t1 ==> isIn x (insert y t2) + 28. isIn x (delete y t1) ==> isIn y t1 = isIn x t1 ==> isIn y t1 + 29. isIn x (delete y (insert z (delete x t1))) = + isIn x (delete y (insert z Null)) + 30. isIn x (insert y (insert z (delete x t1))) = + isIn x (insert y (insert z Null)) + 31. isIn x (delete y (insert z Null)) ==> False = + isIn x (insert y (delete z (insert x t1))) + 32. isIn x (insert y (insert z Null)) ==> False = + isIn x (delete y (delete z (insert x t1))) + 33. (((x ==> x2) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 34. isIn x t1 ==> isIn y (delete z t2) = + isIn x t1 ==> isIn y (delete x t2) + diff --git a/bench/qs2/binarytree.out3 b/bench/qs2/binarytree.out3 new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.out3 @@ -0,0 +1,37 @@ +== Signature == + Null :: BT Int +insert :: Int -> BT Int -> BT Int +delete :: Int -> BT Int -> BT Int + isIn :: Int -> BT Int -> Bool + (==>) :: Bool -> Bool -> Bool + True :: Bool + False :: Bool + +== Laws == + 1. x ==> x = True + 2. x ==> True = True + 3. False ==> x = True + 4. True ==> x = x + 5. delete x Null = Null + 6. isIn x Null = False + 7. x ==> (x ==> y) = x ==> y + 8. x ==> (y ==> x) = True + 9. (x ==> y) ==> x = x + 10. delete x (delete x t1) = delete x t1 + 11. delete x (insert x t1) = delete x (delete x t1) + 12. insert x (delete x t1) = insert x t1 + 13. isIn x (delete x t1) = False + 14. isIn x (insert x t1) = True + 15. (x ==> False) ==> False = x + 16. x ==> (y ==> z) = y ==> (x ==> z) + 17. (x ==> y) ==> y = (y ==> x) ==> x + 18. delete y (delete x t1) = delete x (delete y t1) + 19. insert y (insert x t1) = insert x (insert y t1) + 20. isIn x (insert y Null) = isIn y (insert x Null) + 21. isIn x (insert y (delete x t1)) = isIn x (insert y Null) + 22. isIn x (insert y Null) ==> False = + isIn x (delete y (insert x t1)) + 23. isIn x (delete y (insert z Null)) = + isIn z (delete y (insert x Null)) + 24. x ==> (isIn y (delete x2 t1) ==> z) = x ==> (isIn y t1 ==> z) + diff --git a/bench/qs2/binarytree.out4 b/bench/qs2/binarytree.out4 new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.out4 @@ -0,0 +1,44 @@ +== Signature == + Null :: BT Int +insert :: Int -> BT Int -> BT Int +delete :: Int -> BT Int -> BT Int + isIn :: Int -> BT Int -> Bool + (==>) :: Bool -> Bool -> Bool + True :: Bool + False :: Bool + +== Laws == + 1. x ==> x = True + 2. x ==> True = True + 3. False ==> x = True + 4. True ==> x = x + 5. delete x Null = Null + 6. isIn x Null = False + 7. x ==> (x ==> y) = x ==> y + 8. x ==> (y ==> x) = True + 9. (x ==> y) ==> x = x + 10. delete x (delete x t1) = delete x t1 + 11. delete x (insert x t1) = delete x (delete x t1) + 12. insert x (insert x t1) = insert x (delete x t1) + 13. isIn x (delete x t1) = False + 14. isIn x (insert x t1) = True + 15. (x ==> False) ==> False = x + 16. x ==> (y ==> z) = y ==> (x ==> z) + 17. (x ==> y) ==> y = (y ==> x) ==> x + 18. delete y (delete x t1) = delete x (delete y t1) + 19. insert y (insert x t1) = insert x (insert y t1) + 20. isIn x (insert y Null) = isIn y (insert x Null) + 21. delete x (insert y (delete y t1)) = delete x (insert y t1) + 22. isIn x (insert y (delete x t1)) = isIn x (insert y Null) + 23. isIn x (insert y (delete y t1)) = isIn x (insert y t1) + 24. isIn x (insert y Null) ==> False = + isIn x (delete y (insert x t1)) + 25. insert x (delete x (delete y t1)) = insert x (delete y t1) + 26. isIn x (delete y (insert z Null)) = + isIn z (delete y (insert x Null)) + 27. x ==> (isIn y (delete x2 t1) ==> z) = x ==> (isIn y t1 ==> z) + 28. insert x (delete x (insert y (insert z t1))) = + insert x (insert y (insert z t1)) + 29. insert x (insert y (insert z (delete x t1))) = + insert x (delete x (insert y (insert z t1))) + diff --git a/bench/qs2/binarytree.out5 b/bench/qs2/binarytree.out5 new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.out5 @@ -0,0 +1,55 @@ +== Signature == + Null :: BT Int +insert :: Int -> BT Int -> BT Int +delete :: Int -> BT Int -> BT Int + isIn :: Int -> BT Int -> Bool + (==>) :: Bool -> Bool -> Bool + True :: Bool + False :: Bool + +== Laws == + 1. x ==> x = True + 2. x ==> True = True + 3. False ==> x = True + 4. True ==> x = x + 5. delete x Null = Null + 6. isIn x Null = False + 7. x ==> (x ==> y) = x ==> y + 8. x ==> (y ==> x) = True + 9. (x ==> y) ==> x = x + 10. delete x (delete x t1) = delete x t1 + 11. delete x (insert x t1) = delete x (delete x t1) + 12. insert x (delete x t1) = insert x t1 + 13. isIn x (delete x t1) = False + 14. isIn x (insert x t1) = True + 15. (x ==> False) ==> False = x + 16. x ==> (y ==> z) = y ==> (x ==> z) + 17. (x ==> y) ==> y = (y ==> x) ==> x + 18. delete y (delete x t1) = delete x (delete y t1) + 19. insert y (insert x t1) = insert x (insert y t1) + 20. isIn x (insert y Null) = isIn y (insert x Null) + 21. isIn x (insert y (delete x t1)) = isIn x (insert y Null) + 22. isIn x (insert y Null) ==> False = + isIn x (delete y (insert x t1)) + 23. isIn x (delete y (insert z Null)) = + isIn z (delete y (insert x Null)) + 24. (((x ==> y) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 25. isIn x t1 ==> isIn x (insert y t1) = True + 26. isIn x t1 ==> isIn y (insert x t1) = isIn x t1 ==> isIn y t1 + 27. isIn x (delete y t1) ==> isIn x t2 = + isIn x t1 ==> isIn x (insert y t2) + 28. isIn x (delete y t1) ==> isIn y t1 = isIn x t1 ==> isIn y t1 + 29. isIn x (delete y (insert z (delete x t1))) = + isIn x (delete y (insert z Null)) + 30. isIn x (insert y (insert z (delete x t1))) = + isIn x (insert y (insert z Null)) + 31. isIn x (delete y (insert z Null)) ==> False = + isIn x (insert y (delete z (insert x t1))) + 32. isIn x (insert y (insert z Null)) ==> False = + isIn x (delete y (delete z (insert x t1))) + 33. (((x ==> x2) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 34. isIn x t1 ==> isIn y (delete x t2) = + isIn x t1 ==> isIn y (delete z t2) + diff --git a/bench/qs2/binarytree.out6 b/bench/qs2/binarytree.out6 new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.out6 @@ -0,0 +1,55 @@ +== Signature == + Null :: BT Int +insert :: Int -> BT Int -> BT Int +delete :: Int -> BT Int -> BT Int + isIn :: Int -> BT Int -> Bool + (==>) :: Bool -> Bool -> Bool + True :: Bool + False :: Bool + +== Laws == + 1. x ==> x = True + 2. x ==> True = True + 3. False ==> x = True + 4. True ==> x = x + 5. delete x Null = Null + 6. isIn x Null = False + 7. x ==> (x ==> y) = x ==> y + 8. x ==> (y ==> x) = True + 9. (x ==> y) ==> x = x + 10. delete x (delete x t1) = delete x t1 + 11. delete x (insert x t1) = delete x (delete x t1) + 12. insert x (delete x t1) = insert x t1 + 13. isIn x (delete x t1) = False + 14. isIn x (insert x t1) = True + 15. (x ==> False) ==> False = x + 16. x ==> (y ==> z) = y ==> (x ==> z) + 17. (x ==> y) ==> y = (y ==> x) ==> x + 18. delete y (delete x t1) = delete x (delete y t1) + 19. insert y (insert x t1) = insert x (insert y t1) + 20. isIn x (insert y Null) = isIn y (insert x Null) + 21. isIn x (insert y (delete x t1)) = isIn x (insert y Null) + 22. isIn x (insert y Null) ==> False = + isIn x (delete y (insert x t1)) + 23. isIn x (delete y (insert z Null)) = + isIn z (delete y (insert x Null)) + 24. (((x ==> y) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 25. isIn x t1 ==> isIn x (insert y t1) = True + 26. isIn x t1 ==> isIn y (insert x t1) = isIn x t1 ==> isIn y t1 + 27. isIn x (delete y t1) ==> isIn x t2 = + isIn x t1 ==> isIn x (insert y t2) + 28. isIn x (delete y t1) ==> isIn y t1 = isIn x t1 ==> isIn y t1 + 29. isIn x (delete y (insert z (delete x t1))) = + isIn x (delete y (insert z Null)) + 30. isIn x (insert y (insert z (delete x t1))) = + isIn x (insert y (insert z Null)) + 31. isIn x (delete y (insert z Null)) ==> False = + isIn x (insert y (delete z (insert x t1))) + 32. isIn x (insert y (insert z Null)) ==> False = + isIn x (delete y (delete z (insert x t1))) + 33. (((x ==> x2) ==> z) ==> y) ==> x2 = + (x ==> y) ==> ((z ==> y) ==> x2) + 34. isIn x t1 ==> isIn y (delete x t2) = + isIn x t1 ==> isIn y (delete z t2) + diff --git a/bench/qs2/binarytree.runtime-zero b/bench/qs2/binarytree.runtime-zero new file mode 100644 --- /dev/null +++ b/bench/qs2/binarytree.runtime-zero @@ -0,0 +1,6 @@ +37.020 +37.130 +22.720 +23.000 +37.650 +36.530 diff --git a/bench/qs2/bool.hs b/bench/qs2/bool.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/bool.hs @@ -0,0 +1,12 @@ +import QuickSpec + +main = quickSpec signature + { maxTermSize = Just 5 + , constants = + [ constant "False" False + , constant "True" True + , constant "not" not + , constant "&&" (&&) + , constant "||" (||) + ] + } diff --git a/bench/qs2/bool.out b/bench/qs2/bool.out new file mode 100644 --- /dev/null +++ b/bench/qs2/bool.out @@ -0,0 +1,32 @@ +== Signature == +False :: Bool + True :: Bool + not :: Bool -> Bool + (&&) :: Bool -> Bool -> Bool + (||) :: Bool -> Bool -> Bool + +== Laws == + 1. not False = True + 2. not True = False + 3. x && x = x + 4. x || x = x + 5. x && False = False + 6. x && True = x + 7. False && x = False + 8. True && x = x + 9. x || False = x + 10. x || True = True + 11. False || x = x + 12. True || x = True + 13. not (not x) = x + 14. x && y = y && x + 15. x || y = y || x + 16. x && not x = False + 17. x || not x = True + 18. x && (x && y) = x && y + 19. x && (x || y) = x + 20. (x && y) && z = x && (y && z) + 21. x || (x && y) = x + 22. (x || y) || z = x || (y || z) + 23. not x && not y = not (x || y) + diff --git a/bench/qs2/insertsort.hs b/bench/qs2/insertsort.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/insertsort.hs @@ -0,0 +1,21 @@ +{-# LANGUAGE DataKinds #-} +import QuickSpec hiding (insert) +import Data.List (sort, insert) +import Test.QuickCheck +import Data.Dynamic +import Data.Proxy + +main = quickSpec signature + { maxTermSize = Just 5 -- 9 + , constants = + [ constant "[]" ([] :: [Int]) + , constant ":" ((:) :: Int -> [Int] -> [Int]) + , constant "++" ((++) :: [Int] -> [Int] -> [Int]) + , constant "insert" (insert :: Int -> [Int] -> [Int]) + , constant "sort" (sort :: [Int] -> [Int]) + ] + , predicates = + [ predicate (undefined :: Proxy "<=") ((<=) :: Int -> Int -> Bool) + , predicate (undefined :: Proxy "<") ((<) :: Int -> Int -> Bool) + ] + } diff --git a/bench/qs2/insertsort.out b/bench/qs2/insertsort.out new file mode 100644 --- /dev/null +++ b/bench/qs2/insertsort.out @@ -0,0 +1,37 @@ +== Signature == + [] :: [Int] + (:) :: Int -> [Int] -> [Int] + (++) :: [Int] -> [Int] -> [Int] + insert :: Int -> [Int] -> [Int] + sort :: [Int] -> [Int] + (prj_<=) :: TestCaseWrapped "<=" (Int -> Int -> Bool) -> Int +(prj_<=') :: TestCaseWrapped "<=" (Int -> Int -> Bool) -> Int + (prj_<) :: TestCaseWrapped "<" (Int -> Int -> Bool) -> Int + (prj_<') :: TestCaseWrapped "<" (Int -> Int -> Bool) -> Int + (<=) :: Int -> Int -> Bool + (<) :: Int -> Int -> Bool + True :: Bool + +== Laws == + 1. sort [] = [] + 2. x <= x = True + 3. xs ++ [] = xs + 4. [] ++ xs = xs + 5. insert x [] = x : [] + 6. sort (sort xs) = sort xs + 7. x < x = y < y + 8. sort (x : xs) = insert x (sort xs) + 9. sort (insert x xs) = insert x (sort xs) + 10. sort (xs ++ ys) = sort (ys ++ xs) + 11. (xs ++ ys) ++ zs = xs ++ (ys ++ zs) + 12. x : (xs ++ ys) = (x : xs) ++ ys + 13. insert x (x : xs) = x : (x : xs) + 14. x < y => x < y = True + 15. z < y => y < z = x < x + 16. z <= y => y < z = x < x + 17. x < y => x <= y = True + 18. z < y => y <= z = x < x + 19. x <= y => x <= y = True + 20. sort (xs ++ sort ys) = sort (xs ++ ys) + 21. insert y (insert x xs) = insert x (insert y xs) + diff --git a/bench/qs2/list-ineq.hs b/bench/qs2/list-ineq.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/list-ineq.hs @@ -0,0 +1,19 @@ +import QuickSpec +import Data.List (isSubsequenceOf) + +main = quickSpec signature + { maxTermSize = Just 7 + , maxTests = Just 500 + , constants = + [ constant "[]" ([] :: [Int]) + , constant ":" ((:) :: Int -> [Int] -> [Int]) + , constant "++" ((++) :: [Int] -> [Int] -> [Int]) +-- , constant "head" (head :: [Int] -> Int) +-- , constant "tail" (tail :: [Int] -> [Int]) + , constant "0" (0 :: Int) + , constant "length" (length :: [Int] -> Int) +-- , constant "<=" (isSubsequenceOf :: [Int] -> [Int] -> Bool) + , constant "<=" ((<=) :: Int -> Int -> Bool) + , constant "True" True + ] + } diff --git a/bench/qs2/list.hs b/bench/qs2/list.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/list.hs @@ -0,0 +1,14 @@ +import QuickSpec + +main = quickSpec signature + { maxTermSize = Just 5 + , maxTermDepth = Just 4 + , maxTests = Just 500 + , constants = + [ constant "[]" ([] :: [Int]) + , constant ":" ((:) :: Int -> [Int] -> [Int]) + , constant "++" ((++) :: [Int] -> [Int] -> [Int]) + , constant "head" (head :: [Int] -> Int) + , constant "tail" (tail :: [Int] -> [Int]) + ] + } diff --git a/bench/qs2/list.out b/bench/qs2/list.out new file mode 100644 --- /dev/null +++ b/bench/qs2/list.out @@ -0,0 +1,15 @@ +== Signature == + [] :: [Int] + (:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +head :: [Int] -> Int +tail :: [Int] -> [Int] + +== Laws == + 1. xs ++ [] = xs + 2. [] ++ xs = xs + 3. head (x : xs) = x + 4. tail (x : xs) = xs + 5. (xs ++ ys) ++ zs = xs ++ (ys ++ zs) + 6. x : (xs ++ ys) = (x : xs) ++ ys + diff --git a/bench/qs2/plus-abs-ineq.hs b/bench/qs2/plus-abs-ineq.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/plus-abs-ineq.hs @@ -0,0 +1,16 @@ +import QuickSpec + +main = quickSpec signature + { maxTermSize = Just 9 + , maxTermDepth = Nothing -- Just 5 + , maxTests = Just 500 + , constants = + [ constant "0" (0 :: Int) + , constant "1" (1 :: Int) + , constant "True" (True :: Bool) + , constant "+" ((+) :: Int -> Int -> Int) + , constant "id" (id :: Int -> Int) + , constant "abs" (abs :: Int -> Int) + , constant "<=" ((<=) :: Int -> Int -> Bool) + ] + } diff --git a/bench/qs2/plus-abs.hs b/bench/qs2/plus-abs.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/plus-abs.hs @@ -0,0 +1,14 @@ +import QuickSpec + +main = quickSpec signature + { maxTermSize = Just 7 + , maxTermDepth = Just 4 + , maxTests = Just 500 + , constants = + [ constant "0" (0 :: Int) + , constant "1" (1 :: Int) + , constant "+" ((+) :: Int -> Int -> Int) + , constant "id" (id :: Int -> Int) + , constant "abs" (abs :: Int -> Int) + ] + } diff --git a/bench/qs2/plus-abs.out b/bench/qs2/plus-abs.out new file mode 100644 --- /dev/null +++ b/bench/qs2/plus-abs.out @@ -0,0 +1,24 @@ +== Signature == + 0 :: Int + 1 :: Int +(+) :: Int -> Int -> Int + id :: Int -> Int +abs :: Int -> Int + +== Laws == + 1. id x = x + 2. abs 0 = 0 + 3. abs 1 = 1 + 4. x + 0 = x + 5. 0 + x = x + 6. abs (abs x) = abs x + 7. x + y = y + x + 8. abs (1 + 1) = 1 + 1 + 9. (x + y) + z = x + (y + z) + 10. abs x + abs x = abs (x + x) + 11. abs (x + abs x) = x + abs x + 12. abs (1 + abs x) = 1 + abs x + 13. abs (abs x + abs y) = abs x + abs y + 14. abs x + abs (x + x) = abs (x + (x + x)) + 15. abs x + abs (x + 1) = abs (x + (x + 1)) + diff --git a/bench/qs2/regexes.hs b/bench/qs2/regexes.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/regexes.hs @@ -0,0 +1,60 @@ +import Regex +import Test.QuickCheck +import Test.QuickCheck.Gen +import Test.QuickCheck.Random +import Control.Monad +import QuickSpec hiding (None) +import Data.Ord + +instance Arbitrary Symbol where + arbitrary = elements $ map Symbol ['a','b','c'] + +instance Arbitrary a => Arbitrary (RE a) where + arbitrary = sized re + where + re 0 = oneof + [ return Empty + , return None + , liftM Lit arbitrary + ] + re n = oneof + [ re 0 + , liftM Star (re (n - 1)) + , liftM2 (:.) re2 re2 + , liftM2 (:+) re2 re2 + ] where re2 = re (n `div` 2) + shrink Empty = [] + shrink None = [] + shrink (Lit _) = [Empty, None] + shrink (Star r) = [r] ++ [Star r' | r' <- shrink r] + shrink (r :+ s) = [r, s] ++ [r' :+ s' | (r',s') <- shrink (r,s)] + shrink (r :. s) = [r, s] ++ [r' :. s' | (r',s') <- shrink (r,s)] + +class Charable a where toChar :: a -> Char +instance Charable Char where toChar = id +instance Charable Symbol where toChar (Symbol c) = c + +instance (Arbitrary a, Charable a, Ord a, Eq a) => Eq (RE a) where + r1 == r2 = r1 `compare` r2 == EQ + +instance (Arbitrary a, Charable a, Ord a) => Ord (RE a) where + compare = comparing (\r -> map (\a -> match toChar a r) vals) + where + --vals :: Arbitrary a => [[a]] -- adapted from QuickSpec's own RE example + vals = unGen (vector 100) (mkQCGen 12345) 10 + +main = quickSpec signature + { maxTermSize = Just 2 -- TODO: fixme! + , instances = + [ baseType (undefined :: RE Symbol) + ] + , constants = + [ constant "Empty" (Empty :: RE Symbol) + , constant "None" (None :: RE Symbol) + , constant "Star" (Star :: RE Symbol -> RE Symbol) + , constant ":+" ((:+) :: RE Symbol -> RE Symbol -> RE Symbol) + , constant ":." ((:.) :: RE Symbol -> RE Symbol -> RE Symbol) + --, constant "=~" (=~) + --, constant "Lit" (Lit :: Symbol -> RE Symbol) + ] + } diff --git a/bench/qs2/regexes.out b/bench/qs2/regexes.out new file mode 100644 --- /dev/null +++ b/bench/qs2/regexes.out @@ -0,0 +1,11 @@ +== Signature == +Empty :: RE Symbol + None :: RE Symbol + Star :: RE Symbol -> RE Symbol + (:+) :: RE Symbol -> RE Symbol -> RE Symbol + (:.) :: RE Symbol -> RE Symbol -> RE Symbol + +== Laws == + 1. Star Empty = Empty + 2. Star None = Empty + diff --git a/bench/qs2/runtime-zero b/bench/qs2/runtime-zero new file mode 100644 --- /dev/null +++ b/bench/qs2/runtime-zero @@ -0,0 +1,10 @@ +arith 2.970 +arith-negate-abs 0.540 +bool 0.280 +list 0.120 +insertsort 0.670 +zip 1.980 +arithficial 0.360 +plus-abs 0.360 +regexes 12.110 +binarytree 37.100 diff --git a/bench/qs2/zip.hs b/bench/qs2/zip.hs new file mode 100644 --- /dev/null +++ b/bench/qs2/zip.hs @@ -0,0 +1,23 @@ +{-# LANGUAGE DataKinds #-} +import QuickSpec hiding (insert) +import Data.List (sort, insert) +import Test.QuickCheck +import Data.Dynamic +import Control.Monad +import Data.Proxy + +main = quickSpec signature + { maxTermSize = Just 7 + , maxTests = Just 500 + , constants = + [ constant "++" ((++) :: [Int] -> [Int] -> [Int]) + , constant "length" (length :: [Int] -> Int) + , constant "zip" (zip :: [Int] -> [Int] -> [(Int,Int)]) + ] + , predicates = + [ predicate (undefined :: Proxy "eqLen") eqLen + ] + } + +eqLen :: [Int] -> [Int] -> Bool +eqLen xs ys = length xs == length ys diff --git a/bench/qs2/zip.out b/bench/qs2/zip.out new file mode 100644 --- /dev/null +++ b/bench/qs2/zip.out @@ -0,0 +1,35 @@ +== Signature == + (++) :: [Int] -> [Int] -> [Int] + length :: [Int] -> Int + zip :: [Int] -> [Int] -> [(Int, Int)] + prj_eqLen :: + TestCaseWrapped "eqLen" ([Int] -> [Int] -> Bool) -> [Int] +prj_eqLen' :: + TestCaseWrapped "eqLen" ([Int] -> [Int] -> Bool) -> [Int] + eqLen :: [Int] -> [Int] -> Bool + True :: Bool + +== Laws == + 1. eqLen xs xs = True + 2. eqLen xs ys => length xs = length ys + 3. eqLen xs ys = eqLen ys xs + 4. eqLen ys zs => eqLen xs ys = eqLen xs zs + 5. length (xs ++ ys) = length (ys ++ xs) + 6. (xs ++ ys) ++ zs = xs ++ (ys ++ zs) + 7. zip xs (xs ++ ys) = zip xs xs + 8. zip (xs ++ ys) xs = zip xs xs + 9. eqLen ys zs => length (xs ++ ys) = length (xs ++ zs) + 10. eqLen xs (ys ++ zs) = eqLen xs (zs ++ ys) + 11. eqLen xs (xs ++ ys) = eqLen zs (zs ++ ys) + 12. eqLen zs xs2 => eqLen xs (ys ++ zs) = eqLen xs (ys ++ xs2) + 13. eqLen xs (xs ++ (ys ++ ys)) = eqLen xs (xs ++ ys) + 14. eqLen (xs ++ zs) (ys ++ zs) = eqLen xs ys + 15. eqLen (xs ++ xs) (ys ++ ys) = eqLen xs ys + 16. zip xs (ys ++ (xs ++ zs)) = zip xs (ys ++ xs) + 17. zip (xs ++ (ys ++ zs)) ys = zip (xs ++ ys) ys + 18. eqLen xs ys => zip (xs ++ zs) ys = zip xs ys + 19. eqLen xs ys => zip xs (ys ++ zs) = zip xs ys + 20. eqLen xs (ys ++ (zs ++ xs2)) = eqLen xs (ys ++ (xs2 ++ zs)) + 21. eqLen zs xs2 => + length (xs ++ (ys ++ zs)) = length (xs ++ (zs ++ ys)) + diff --git a/bench/runtime-zero b/bench/runtime-zero new file mode 100644 --- /dev/null +++ b/bench/runtime-zero @@ -0,0 +1,31 @@ +arith 0.456 +arith-c 0.983 +arithficial 3.313 +arith-negate-abs 2.736 +binarytree 4.053 +binarytree0 1.150 +bool 1.776 +bool-c 1.633 +colour 2.886 +digraphs 3.246 +insertsort 15.353 +insertsort0 2.273 +length 0.386 +list 10.986 +list-c 2.183 +minus 1.170 +minus-c 1.883 +monad 0.786 +nord 0.003 +oddeven 12.233 +plus-abs 6.070 +pretty 11.180 +ratio 15.060 +regexes 8.476 +sets 14.840 +speculate-reason 6.416 +string 4.633 +tauts 7.186 +tuples 2.186 +unit 0.003 +zip 3.683 diff --git a/bench/unit.hs b/bench/unit.hs new file mode 100644 --- /dev/null +++ b/bench/unit.hs @@ -0,0 +1,11 @@ +import Test.Speculate + +-- TODO: shouldn't this report the law x == y? +-- currently (2017-09-13) it reports no laws! +main :: IO () +main = speculate args + { constants = + [ constant "()" () + , constant "id" (id :: () -> ()) + ] + } diff --git a/bin/compare-arith b/bin/compare-arith new file mode 100644 --- /dev/null +++ b/bin/compare-arith @@ -0,0 +1,23 @@ +#!/bin/bash + +tempdir=`mktemp -d /tmp/speculate-XXXXXXXXXX` +speculate=$tempdir/speculate.out +qs2=$tempdir/quickspec2.out + +cat bench/qs2/arith.out | +grep " = " | +sed -e "s/^...\. //" | +sed -e "y/ijk/xyz/;s/=/==/" | +sed -e "s/xd/id/" | +sort > $qs2 + +cat tests/model/arith | +grep " == " | +sed -e "s/ *//" | +sed -e 's/\([^a-z]\) (\([a-z]* .\))/\1 \2/g' | +sed -e 's/^(\([a-z ]*\))/\1/' | +sort > $speculate + +diff -rud $qs2 $speculate + +rm -r $tempdir diff --git a/bin/compare-arithficial b/bin/compare-arithficial new file mode 100644 --- /dev/null +++ b/bin/compare-arithficial @@ -0,0 +1,30 @@ +#!/bin/bash + +tempdir=`mktemp -d /tmp/speculate-XXXXXXXXXX` +speculate=$tempdir/speculate.out +qs1=$tempdir/quickspec2.out +qs2=$tempdir/quickspec2.out + +cat bench/qs1/arithficial.out | +grep " == " | +sed -e 's/.*: //;s/+/ + /g' | +sort > $qs1 + +cat bench/qs2/arithficial.out | +grep " = " | +sed -e "s/^...\. //" | +sed -e "y/ijk/xyz/;s/=/==/" | +sed -e "s/xd/id/" | +sort > $qs2 + +cat tests/model/arithficial | +grep " == " | +sed -e "s/ *//" | +sed -e 's/\([^a-z]\) (\([a-z]* .\))/\1 \2/g' | +sed -e 's/^(\([a-z ]*\))/\1/' | +sort > $speculate + +diff -rud $qs1 $qs2 +diff -rud $qs2 $speculate + +rm -r $tempdir diff --git a/bin/compare-bool b/bin/compare-bool new file mode 100644 --- /dev/null +++ b/bin/compare-bool @@ -0,0 +1,23 @@ +#!/bin/bash + +tempdir=`mktemp -d /tmp/speculate-XXXXXXXXXX` +speculate=$tempdir/speculate.out +qs2=$tempdir/quickspec2.out + +cat bench/qs2/bool.out | +grep " = " | +sed -e "s/^...\. //" | +sed -e "y/xyz/pqr/;s/=/==/" | +sort > $qs2 + +cat tests/model/bool | +grep " == " | +sed -e "s/ *//" | +sed -e 's/\([^a-z]\) (\([a-z]* .\))/\1 \2/g' | +sed -e 's/^(\([a-z ]*\))/\1/' | +sort > $speculate + +diff -rud $qs2 $speculate +#dwdiff -c $qs2 $speculate + +rm -r $tempdir diff --git a/bin/compare-with-qs b/bin/compare-with-qs new file mode 100644 --- /dev/null +++ b/bin/compare-with-qs @@ -0,0 +1,22 @@ +#!/bin/bash + +SPL=bench/runtime-$HOSTNAME +QS1=bench/qs1/runtime-$HOSTNAME +QS2=bench/qs2/runtime-$HOSTNAME + +tym() { + /usr/bin/time -f%e0 "$@" 2>&1 > /dev/null +} + +printf "%-16s %10s %10s %10s\n" "" QuickSpec1 Speculate QuickSpec2 +cat $QS1 | +while read name qs1 +do + read nm qs2 <<< $(grep "^$name " $QS2) + case $name in + plus-abs) read spl <<< $(tym ./eg/plus-abs --exclude="<=,<" -SC -s7 -d4) ;; + arith) read spl <<< $(tym ./eg/arith -SC -s7 -d4) ;; + *) read nm spl <<< $(grep "^$name " $SPL) ;; + esac + printf "%-16s %9.3f %9.3f %9.3f\n" $name $qs1 $spl $qs2 +done diff --git a/bin/run-heavy-regexes-benchmark b/bin/run-heavy-regexes-benchmark new file mode 100644 --- /dev/null +++ b/bin/run-heavy-regexes-benchmark @@ -0,0 +1,13 @@ +#!/bin/bash +time ./eg/regexes -t200 -s4 -z4 -v2 | tee -a etc/regexes-20170223-0100-t200-s4-z4-v2; eject +time ./eg/regexes -t200 -s5 -z5 -v2 | tee -a etc/regexes-20170223-0100-t200-s5-z5-v2; eject +time ./eg/regexes -t200 -s6 -z6 -v2 | tee -a etc/regexes-20170223-0100-t200-s6-z6-v2; eject +time ./eg/regexes -t200 -s6 -z6 -v3 | tee -a etc/regexes-20170223-0100-t200-s6-z6-v3; eject +time ./eg/regexes -t200 -s7 -z7 -v2 | tee -a etc/regexes-20170223-0100-t200-s7-z7-v2; eject +time ./eg/regexes -t200 -s7 -z7 -v3 | tee -a etc/regexes-20170223-0100-t200-s7-z7-v3; eject +# runtimes: +# 442 7m 00s +# 552 38m 01s +# 662 233m 14s +# 663 1172m 26s (~ 19 hours -- user: 1079m 35s) +# 772 4230m 10s (~ 3 days) diff --git a/eg/Digraph.hs b/eg/Digraph.hs new file mode 100644 --- /dev/null +++ b/eg/Digraph.hs @@ -0,0 +1,214 @@ +-- A small library of functions on directed graphs +-- using a simple list-of-successors representation. +-- Colin Runciman, May 2015 + +module Digraph (Digraph(..), okDigraph, strictOrder, + sources, targets, nodes, edges, preds, succs, + isNode, isEdge, isPath, + empty, addNode, addEdge, assoc1toNdigraph, + transitiveClosure, topoSort, + insert, union, diff, cycles, subgraph, maxDagFrom) where + +import GHC.Exts (groupWith) +import Data.List (partition,(\\),sort) +import Data.Maybe (isJust,fromJust) +import Control.Monad (guard) + +data Digraph a = D {nodeSuccs :: [(a,[a])]} deriving (Eq, Show) +-- Data invariant: in a digraph pair-list [...(source,targets)...]: +-- (1) pairs are listed in strictly increasing source order +-- (2) each list of targets is in strictly increasing order +-- (3) every element in a list of targets must itself be +-- listed as a "source", though perhaps with [] targets + +okDigraph :: (Ord a, Eq a) => Digraph a -> Bool +okDigraph (D d) = + strictOrder ss && all goodTargetList tss + where + ss = map fst d + tss = map snd d + goodTargetList ts = strictOrder ts && + all (`elemOrd` ss) ts + +strictOrder :: (Ord a, Eq a) => [a] -> Bool +strictOrder (x:y:etc) = x < y && strictOrder (y:etc) +strictOrder _ = True + +nodes :: Digraph a -> [a] +nodes (D d) = [s | (s,_) <- d] + +edges :: Digraph a -> [(a,a)] +edges (D d) = [(s,t) | (s,ts) <- d, t <- ts] + +sources :: Digraph a -> [a] +sources (D d) = [s | (s,ts) <- d, not (null ts)] + +targets :: (Ord a, Eq a) => Digraph a -> [a] +targets (D d) = foldr union [] (map snd d) + +preds :: (Ord a, Eq a) => a -> Digraph a -> [a] +preds t (D d) = [s | (s,ts) <- d, t `elemOrd` ts] + +succs :: (Ord a, Eq a) => a -> Digraph a -> [a] +succs s (D d) = case lookup s d of + Just ns -> ns + Nothing -> [] + +isNode :: (Ord a, Eq a) => a -> Digraph a -> Bool +isNode n (D d) = isJust (lookup n d) + +isEdge :: (Ord a, Eq a) => a -> a -> Digraph a -> Bool +isEdge s t (D d) = case lookup s d of + Just ns -> t `elemOrd` ns + Nothing -> False + +isPath :: (Ord a, Eq a) => a -> a -> Digraph a -> Bool +isPath s t d = t `elemOrd` closeInto d [] [s] + +empty :: Digraph a +empty = D [] + +addNode :: (Ord a, Eq a) => a -> Digraph a -> Digraph a +addNode s (D d) = + let (these,those) = span ((< s) . fst) d in + D $ these ++ + case those of + [] -> [(s,[])] + (sd,tsd):etc -> if s == sd then error "addNode: already present" + else (s,[]) : those + +addEdge :: (Ord a, Eq a) => a -> a -> Digraph a -> Digraph a +addEdge s t (D d) = + let (these,those) = span ((< s) . fst) d in + D $ these ++ + case those of + [] -> [(s,[t])] + (sd,tsd):etc -> if s == sd then + if t `elemOrd` tsd then error "addEdge: already present" + else (s,insert t tsd) : etc + else (s,[t]) : those + +-- The function assoc1toNdigraph derives a digraph from an association list +-- pairing single sources with lists of targets. Sorting is applied to +-- outer and inner lists, so there is no ordering requirement on the argument. +-- If there is more than one pair with the same source, target lists are merged. +-- If the same value appears more than once in a target list, duplicates are removed. +-- If any target does not occur as a source, it is added, with an empty target list. +assoc1toNdigraph :: (Ord a, Eq a) => [(a,[a])] -> Digraph a +assoc1toNdigraph stss = D $ addMissingSources $ mergeAndSortTargets $ sort stss + where + mergeAndSortTargets [] = [] + mergeAndSortTargets [(s,ts)] = [(s, nubOrd $ sort ts)] + mergeAndSortTargets ((s0,ts0):(s1,ts1):etc) = + if s0 == s1 then mergeAndSortTargets ((s0,ts0++ts1):etc) + else (s0,nubOrd $ sort ts0) : mergeAndSortTargets ((s1,ts1):etc) + addMissingSources stss = + union [(s,[]) | s <- missingSources] stss + where + missingSources = allTargets `diff` map fst stss + allTargets = foldr union [] (map snd stss) + +transitiveClosure :: (Ord a, Eq a) => Digraph a -> Digraph a +transitiveClosure d = D $ map (close d) (nodeSuccs d) + +close :: (Ord a, Eq a) => Digraph a -> (a,[a]) -> (a,[a]) +close d (s,ts) = (s, closeInto d [] ts) + +closeInto :: (Ord a, Eq a) => Digraph a -> [a] -> [a] -> [a] +closeInto d clo [] = clo +closeInto d clo (t:ts) = + case lookup t (nodeSuccs d) of + Nothing -> closeInto d clo ts + Just tsuccs -> closeInto d clo' (union (diff tsuccs clo') ts) + where + clo' = insert t clo + +-- auxiliary functions for ordered list processing + +nubOrd :: (Ord a, Eq a) => [a] -> [a] +nubOrd [] = [] +nubOrd [x] = [x] +nubOrd (x:y:etc) = if x==y then nubOrd (y:etc) else x : nubOrd (y:etc) + +elemOrd :: Ord a => a -> [a] -> Bool +elemOrd x ys = null (diff [x] ys) + +insert :: Ord a => a -> [a] -> [a] +insert x ys = union [x] ys + +union :: Ord a => [a] -> [a] -> [a] +union [] ys = ys +union (x:xs) [] = x:xs +union (x:xs) (y:ys) = case compare x y of + LT -> x : union xs (y:ys) + EQ -> union xs (y:ys) + GT -> y : union (x:xs) ys + +diff :: Ord a => [a] -> [a] -> [a] +diff [] ys = [] +diff (x:xs) [] = x:xs +diff (x:xs) (y:ys) = case compare x y of + LT -> x : diff xs (y:ys) + EQ -> diff xs ys + GT -> diff (x:xs) ys + +-- The result of cycles lists disjoint maximal subsets of nodes in +-- each of which there is a cycle passing through all nodes. +cycles:: (Ord a, Eq a) => Digraph a -> [[a]] +cycles d = + let d' = transitiveClosure d + cycleNodes = filter (hasLoop d') (sources d') + in + map (sources . D) $ groupWith snd $ nodeSuccs $ subgraph cycleNodes d' + +hasLoop :: Eq a => Digraph a -> a -> Bool +hasLoop d s = + case lookup s (nodeSuccs d) of + Nothing -> False + Just ts -> elem s ts + +subgraph :: Eq a => [a] -> Digraph a -> Digraph a +subgraph ns d = D $ [(s,filter (`elem` ns) ts) | (s,ts) <- nodeSuccs d, elem s ns] + +-- The result of topoSort d, where d is an acyclic digraph, lists all nodes +-- in an order where each node precedes all its digraph successors; +-- the result is Nothing if d has a cycle. +topoSort :: (Ord a, Eq a) => Digraph a -> Maybe [a] +topoSort (D []) = Just [] +topoSort d = do + guard (not $ null maxima) + ns <- topoSort (D nodesuccs') + return $ ns ++ maxima + where + (these,those) = partition (null.snd) (nodeSuccs d) + maxima = nodes (D these) + nodesuccs' = [(s,ts \\ maxima) | (s,ts) <- those] + +-- The result of maxDAGfrom s d is a subgraph of d which is a maximal +-- DAG rooted at node s. +maxDagFrom :: (Ord a, Eq a) => a -> Digraph a -> Digraph a +maxDagFrom s d = md [] [s] (removeAllEdges d) (removeLoops d) + +-- In a call md done todo dag d, done is an ordered list of nodes already +-- visited, todo is a disjoint ordered list of nodes to be visited, dag is +-- the dag so far, and d is the full loop-free digraph. +md :: (Ord a, Eq a) => [a] -> [a] -> Digraph a -> Digraph a -> Digraph a +md _ [] dag d = dag +md done (s:ss) dag d = + case lookup s (nodeSuccs d) of + Nothing -> md done' ss dag d + Just ts -> md done' (union (diff ts done) ss) dag' d + where + dag' = foldr (uncurry addEdgeIfAcyclic) dag [(s,t) | t <- ts] + where + done' = insert s done + +addEdgeIfAcyclic :: (Ord a, Eq a) => a -> a -> Digraph a -> Digraph a +addEdgeIfAcyclic s t d = if isPath t s d then d else addEdge s t d + +removeLoops :: (Ord a, Eq a) => Digraph a -> Digraph a +removeLoops d = D $ [(s, diff ts [s]) | (s, ts) <- nodeSuccs d] + +removeAllEdges :: (Ord a, Eq a) => Digraph a -> Digraph a +removeAllEdges d = D $ [(s, []) | (s, _) <- nodeSuccs d] + diff --git a/eg/Regex.hs b/eg/Regex.hs new file mode 100644 --- /dev/null +++ b/eg/Regex.hs @@ -0,0 +1,52 @@ +module Regex + ( RE (..) + , (=~), (===) + , match + , Symbol (..) + , stringToSymbols + , compile + ) +where + +import qualified Text.Regex.TDFA as O +-- import qualified Text.Regex.Posix as O -- just as slow +-- import qualified Text.Regex.PCRE as O -- fails! + +-- | Abstract representation of a Regular Expression. This is a simple +-- abstraction supporting only the operations in a Kleene's algebra. +data RE a = Empty -- Empty/"": one + | None -- Unmatchable: zero + | Lit a -- Literals + | Star (RE a) -- Star/Asterisk: * + | (RE a) :+ (RE a) -- Choice/Plus: + + | (RE a) :. (RE a) -- Append/Concat: . + deriving Show + +-- | Compile an abstract regular expression to be used by Text.Regex +compile :: (a -> Char) -> RE a -> String +compile f r = "^" ++ c r ++ "$" + where + c Empty = "()" + c None = "$u^" -- unmatchable + c (Star r) = "(" ++ c r ++ ")*" + c (r :+ s) = "(" ++ c r ++ "|" ++ c s ++ ")" + c (r :. s) = c r ++ c s + c (Lit c) = [f c] + +match :: (a -> Char) -> [a] -> RE a -> Bool +match f xs r = map f xs O.=~ compile f r + + +-- Now with symbols +newtype Symbol = Symbol Char deriving (Eq, Ord, Show) + +(=~) :: [Symbol] -> RE Symbol -> Bool +(=~) = match symbolToChar + where + symbolToChar (Symbol c) = c + +(===) :: RE Symbol -> RE Symbol -> [Symbol] -> Bool +e1 === e2 = \s -> s =~ e1 == s =~ e1 + +stringToSymbols :: String -> [Symbol] +stringToSymbols = map Symbol diff --git a/eg/Set.hs b/eg/Set.hs new file mode 100644 --- /dev/null +++ b/eg/Set.hs @@ -0,0 +1,243 @@ +-- A list-based library for programming with sets. +-- Colin Runciman, June 2007 to April 2008. + +module Set (Set, elemList, set, emptyS, singleS, pairS, insertS, deleteS, + sizeS, sizeAtMostS, sizeExactlyS, sizeAtLeastS, + isEmptyS, nonEmptyS, minS, choiceS, (<~), + (\/), (/\), (\\), unionS, interS, subS, disjointS, + elemSubsetsOf, powerS, partitionsS, subsetPartitionsS, + (<|), allS, anyS, exactly, forAll, thereExists, forExactly, + minimalS, mapS, mapMonoS, unionMapS, regular) where + +import Data.List (nub, sort, intersperse) + +infixl 7 /\ +infixl 6 \/ +infixr 5 `elemSubsetsOf`, `subsetPartitionsS`, <| +infix 4 <~, `subS` + +data Set a = S {elemList :: [a]} + +instance (Ord a, Eq a) => Eq (Set a) + where + S xs == S ys = xs == ys + +instance Ord a => Ord (Set a) + where + compare (S xs) (S ys) = compare xs ys + +instance (Ord a, Show a) => Show (Set a) + where + show (S xs) = + "{"++concat (intersperse "," (map show xs))++"}" + +set :: Ord a => [a] -> Set a +set = S . nub . sort + +emptyS :: Ord a => Set a +emptyS = S [] + +singleS :: Ord a => a -> Set a +singleS e = S [e] + +pairS :: Ord a => a -> a -> Set a +pairS e1 e2 = set [e1,e2] + +insertS :: Ord a => a -> Set a -> Set a +insertS e = S . insertList e . elemList + where + insertList e [] = [e] + insertList e xs@(x:xs') = case compare e x of + LT -> e : xs + EQ -> xs + GT -> x : insertList e xs' + +deleteS :: Ord a => a -> Set a -> Set a +deleteS e = S . deleteList e . elemList + where + deleteList e [] = [] + deleteList e xs@(x:xs') = case compare e x of + LT -> xs + EQ -> xs' + GT -> x : deleteList e xs' + +sizeS :: Ord a => Set a -> Int +sizeS = length . elemList + +sizeExactlyS :: Ord a => Int -> Set a -> Bool +sizeExactlyS n = lengthExactly n . elemList + where + lengthExactly 0 xs = null xs + lengthExactly n [] = False + lengthExactly n (x:xs) = lengthExactly (n-1) xs + +sizeAtLeastS :: Ord a => Int -> Set a -> Bool +sizeAtLeastS n = lengthAtLeast n . elemList + where + lengthAtLeast 0 xs = True + lengthAtLeast n [] = False + lengthAtLeast n (x:xs) = lengthAtLeast (n-1) xs + +sizeAtMostS :: Ord a => Int -> Set a -> Bool +sizeAtMostS n = lengthAtMost n . elemList + where + lengthAtMost 0 xs = null xs + lengthAtMost n [] = True + lengthAtMost n (x:xs) = lengthAtMost (n-1) xs + +isEmptyS :: Ord a => Set a -> Bool +isEmptyS = null . elemList + +nonEmptyS :: Ord a => Set a -> Bool +nonEmptyS = not . isEmptyS + +minS :: Ord a => Set a -> a +minS = head . elemList + +choiceS :: Ord a => Set a -> Set (a, Set a) +choiceS = S . choice . elemList + where + choice xs = [(x, S (xs1++xs2)) | (xs1,x:xs2) <- splits xs] + +splits :: [a] -> [([a],[a])] +splits [] = [([],[])] +splits (x:xs) = ([],x:xs) : [(x:xs1, xs2) | (xs1,xs2) <- splits xs] + +(<~) :: Ord a => a -> Set a -> Bool +(<~) e = ordElem e . elemList + where + ordElem e [] = False + ordElem e (x:xs) = case compare e x of + LT -> False + EQ -> True + GT -> ordElem e xs + +(\/) :: Ord a => Set a -> Set a -> Set a +S xs \/ S ys = S (join xs ys) + where + join [] ys = ys + join xs [] = xs + join xs@(x:xs') ys@(y:ys') = + case compare x y of + LT -> x : join xs' ys + EQ -> x : join xs' ys' + GT -> y : join xs ys' + +(/\) :: Ord a => Set a -> Set a -> Set a +S xs /\ S ys = S (meet xs ys) + +meet [] _ = [] +meet _ [] = [] +meet xs@(x:xs') ys@(y:ys') = + case compare x y of + LT -> meet xs' ys + EQ -> x : meet xs' ys' + GT -> meet xs ys' + +(\\) :: Ord a => Set a -> Set a -> Set a +S xs \\ S ys = S (diff xs ys) + +diff [] _ = [] +diff xs [] = xs +diff xs@(x:xs') ys@(y:ys') = + case compare x y of + LT -> x : diff xs' ys + EQ -> diff xs' ys' + GT -> diff xs ys' + +unionS :: Ord a => Set (Set a) -> Set a +unionS = foldr (\/) emptyS . elemList + +interS :: Ord a => Set (Set a) -> Set a +interS = foldr1 (/\) . elemList + +disjointS :: Ord a => Set a -> Set a -> Bool +disjointS (S xs) (S ys) = null (meet xs ys) + +subS :: Ord a => Set a -> Set a -> Bool +subS (S xs) (S ys) = null (diff xs ys) + +elemSubsetsOf :: Ord a => Int -> Set a -> Set (Set a) +elemSubsetsOf n = + S . map S . sublistsOf n . elemList + where + sublistsOf 0 _ = [[]] + sublistsOf _ [] = [] + sublistsOf n (x:xs) = + map (x:) (sublistsOf (n-1) xs) ++ sublistsOf n xs + +powerS :: Ord a => Set a -> Set (Set a) +powerS = + S . map S . ([]:) . nonEmptySublists . elemList + where + nonEmptySublists [] = [] + nonEmptySublists (x:xs) = + [x] : map (x:) ss ++ ss + where + ss = nonEmptySublists xs + +-- outer 'set' used to be 'S' but then ordering between +-- partitions can be wrong +-- TO DO: instead reorder partitionsList computation? +partitionsS :: Ord a => Set a -> Set (Set (Set a)) +partitionsS = set . map (S . map S) . partitionsList . elemList + where + partitionsList [] = [[]] + partitionsList (x:xs) = + [[x] : p | p <- ps] ++ + [(x:xs') : xss ++ xss' | p <- ps, (xss,xs':xss') <- splits p] + where + ps = partitionsList xs + +subsetPartitionsS :: Ord a => Int -> Set a -> Set (Set (Set a)) +subsetPartitionsS n = S . map (S . map S) . sublistPartitionsList n . elemList + where + sublistPartitionsList n [] = [[] | n == 0] + sublistPartitionsList n (x:xs) = + [ [x] : p + | n > 0, p <- sublistPartitionsList (n-1) xs ] ++ + [ (x:xs') : xss ++ xss' + | n > 0, p <- sublistPartitionsList n xs, (xss,xs':xss') <- splits p ] + +(<|) :: Ord a => (a -> Bool) -> Set a -> Set a +(<|) p = S . filter p . elemList + +allS, anyS :: Ord a => (a -> Bool) -> Set a -> Bool +allS p = all p . elemList +anyS p = any p . elemList + +exactly :: + Ord a => Int -> (a->Bool) -> Set a -> Bool +exactly n p = + exactlyList n p . elemList + where + exactlyList 0 p xs = not (any p xs) + exactlyList n p [] = False + exactlyList n p (x:xs) = exactlyList + (if p x then n-1 else n) p xs + +forAll, thereExists :: Ord a => Set a -> (a->Bool) -> Bool +forAll s p = allS p s +thereExists s p = anyS p s + +forExactly :: Ord a => Int -> Set a -> (a->Bool) -> Bool +forExactly n s p = exactly n p s + +mapS :: (Ord a, Ord b) => (a -> b) -> Set a -> Set b +mapS f = set . map f . elemList + +-- more efficient variant when f is monotonic +mapMonoS :: (Ord a, Ord b) => (a -> b) -> Set a -> Set b +mapMonoS f = S . map f . elemList + +unionMapS :: (Ord a, Ord b) => (a -> Set b) -> Set a -> Set b +unionMapS f = foldr (\/) emptyS . map f . elemList + +minimalS :: Ord a => (Set a -> Bool) -> Set a -> Bool +minimalS p s = (p <| powerS s) == set [s] + +regular :: Ord a => Int -> Set (Set a) -> Bool +regular d ss = + -- every element occurs in exactly d sets + forAll (unionS ss) $ \e -> + forExactly d ss $ \s -> e <~ s diff --git a/eg/Taut.hs b/eg/Taut.hs new file mode 100644 --- /dev/null +++ b/eg/Taut.hs @@ -0,0 +1,47 @@ +-- Tautology testing by partial evaluation and case analysis. +-- Colin Runciman, 2003. + +module Taut where + +data Prop = Lit Bool + | Var Name + | Not Prop + | Prop :=> Prop + deriving (Eq, Ord, Show) -- TODO: actually write semantic equality + +data Name = P | Q | R deriving (Eq, Ord, Show) + +infixr :=> + +eval :: Prop -> Prop +eval (Lit b) = Lit b +eval (Var v) = Var v +eval (Not p) = case eval p of + Lit b -> Lit (not b) + p' -> Not p' +eval (p :=> q) = case (eval p, eval q) of + (Lit b, q') -> if b then q' else Lit True + (p', Lit b) -> if b then Lit True else Not p' + (p', q') -> p' :=> q' + +varOf :: Prop -> Name +varOf (Var v) = v +varOf (Not p) = varOf p +varOf (p :=> _) = varOf p + +subst :: Name -> Bool -> Prop -> Prop +subst _ _ (Lit b) = Lit b +subst v b (Var w) = if v==w then Lit b else Var w +subst v b (Not p) = Not (subst v b p) +subst v b (p :=> q) = subst v b p :=> subst v b q + +taut :: Prop -> Bool +taut p = case eval p of + Lit b -> b + p' -> let v = varOf p' in + taut (subst v True p') && + taut (subst v False p') + +main :: Prop -> IO () +main p = print (taut p) +-- eg. (Var 'p' :=> (Var 'p' :=> Var 'q') :=> Var 'q')) diff --git a/eg/algebraic-graphs.hs b/eg/algebraic-graphs.hs new file mode 100644 --- /dev/null +++ b/eg/algebraic-graphs.hs @@ -0,0 +1,79 @@ +{-# LANGUAGE TemplateHaskell #-} +import Test.Speculate +import Test.Speculate.Expr.Instance (name) +import Data.Function (on) +import Control.Monad (unless) + +import Algebra.Graph + +instance Ord a => Ord (Graph a) where + (<=) = isSubgraphOf + +-- deriveListable ''Graph {- +instance (Ord a, Listable a) => Listable (Graph a) where + tiers = concatMapT graphs $ setsOf tiers + where + graphs ns = mapT (fromAdjList . zip ns) + $ listsOfLength (length ns) (setsOf $ toTiers ns) + fromAdjList :: [(a,[a])] -> Graph a + fromAdjList ness = graph [n | (n,_) <- ness] + [(n1,n2) | (n1,n2s) <- ness, n2 <- n2s] +-- -} + +main :: IO () +main = do + unless (listableGraphOK 180 a) $ + error "incorrect Listable (Graph a), see source" + speculate args + { instances = [ins "x" (gr a), ins "i" a] + , maxTests = 1080 + , constants = + [ background + , showConstant $ 0 -: a + , showConstant $ 0 -: int + , showConstant True + + , foreground + , constant "empty" (empty -: gr a) + , constant "vertex" (vertex -:> a) + , constant "+" ((+) -:> gr a) + , constant "*" ((*) -:> gr a) + , constant "overlay" (overlay -:> gr a) + , constant "connect" (connect -:> gr a) + , constant "edge" (edge -:> a) + , constant "length" (length -:> gr a) + , constant "size" (size -:> gr a) + ] + , showConditions = False + , maxSemiSize = 4 + , maxCondSize = 4 + } + where + a :: Nat3 + a = undefined + +gr :: a -> Graph a +gr _ = undefined + + +-- tests for the Listable (Graph a) implementation: +listableGraphOK :: (Listable a, Ord a) => Int -> a -> Bool +listableGraphOK n x = and + [ take n list `subset` take m (listGraphsInnefficient -: [gr x]) -- sound + , take n (listGraphsInnefficient -: [gr x]) `subset` take m list -- complete + ] + where + m = 60*n + +-- innefficient reference implementation: +listGraphsInnefficient :: (Ord a, Listable a) => [Graph a] +listGraphsInnefficient = concat tiersGraphsInnefficient + +tiersGraphsInnefficient :: (Ord a, Listable a) => [[Graph a]] +tiersGraphsInnefficient = cons0 empty + \/ cons1 vertex + \/ cons2 overlay + \/ cons2 connect + +subset :: Eq a => [a] -> [a] -> Bool +subset xs ys = all (`elem` ys) xs diff --git a/eg/arith-negate-abs.hs b/eg/arith-negate-abs.hs new file mode 100644 --- /dev/null +++ b/eg/arith-negate-abs.hs @@ -0,0 +1,18 @@ +import Test.Speculate + +main :: IO () +main = speculate args + { constants = + [ showConstant (0::Int) + , showConstant (1::Int) + , constant "id" (id :: Int -> Int) + , constant "abs" (abs :: Int -> Int) + , constant "negate" (negate :: Int -> Int) + , constant "+" ((+) :: Int -> Int -> Int) + , constant "*" ((*) :: Int -> Int -> Int) + ] +--, backgroundConstants = +-- [ constant "<=" ((<=) :: Int -> Int -> Bool) +-- , constant "<" ((<) :: Int -> Int -> Bool) +-- ] + } diff --git a/eg/arith.hs b/eg/arith.hs new file mode 100644 --- /dev/null +++ b/eg/arith.hs @@ -0,0 +1,11 @@ +import Test.Speculate + +main :: IO () +main = speculate args + { constants = + [ showConstant (0::Int) + , showConstant (1::Int) + , constant "+" ((+) :: Int -> Int -> Int) + , constant "*" ((*) :: Int -> Int -> Int) + ] + } diff --git a/eg/binarytree.hs b/eg/binarytree.hs new file mode 100644 --- /dev/null +++ b/eg/binarytree.hs @@ -0,0 +1,121 @@ +{-# LANGUAGE CPP #-} +{-# Language DeriveDataTypeable, StandaloneDeriving #-} -- for GHC <= 7.8 +-- Colin Runciman, December 2016 +import Test.Speculate +import Test.LeanCheck +import Data.Function (on) + + +data BT a = Null | Fork (BT a) a (BT a) + deriving Show + +#if __GLASGOW_HASKELL__ < 708 +deriving instance Typeable1 BT +#else +deriving instance Typeable BT +#endif + +instance (Eq a, Ord a) => Eq (BT a) where + (==) = (==) `on` toList + +instance (Eq a, Ord a) => Ord (BT a) where + (<=) = isSubsequenceOf `on` toList + +isSubsequenceOf :: Eq a => [a] -> [a] -> Bool +isSubsequenceOf [] _ = True +isSubsequenceOf (_:_) [] = False +isSubsequenceOf (x:xs) (y:ys) + | x == y = xs `isSubsequenceOf` ys + | otherwise = (x:xs) `isSubsequenceOf` ys + +insert :: Ord a => a -> BT a -> BT a +insert x Null = Fork Null x Null +insert x t@(Fork t1 y t2) = case compare x y of + LT -> Fork (insert x t1) y t2 + EQ -> t + GT -> Fork t1 y (insert x t2) + +delete :: Ord a => a -> BT a -> BT a +delete x Null = Null +delete x t@(Fork t1 y t2) = case compare x y of + LT -> Fork (delete x t1) y t2 + EQ -> graft t1 t2 + GT -> Fork t1 y (delete x t2) + +isIn :: Ord a => a -> BT a -> Bool +isIn x t = x `elem` toList t + +graft :: Ord a => BT a -> BT a -> BT a +graft Null t = t +graft (Fork t1 x t2) t = Fork t1 x (graft t2 t) + +toList :: Ord a => BT a -> [a] +toList Null = [] +toList (Fork t1 x t2) = toList t1 ++ [x] ++ toList t2 + +fromList :: Ord a => [a] -> BT a +fromList = foldr insert Null + +{- +fromList :: Ord a => [a] -> BT a +fromList [] = Null +fromList xs = Fork (fromList ys) x (fromList zs) + where + (x:ys,zs) = deal xs + +deal :: [a] -> ([a],[a]) +deal [] = ([],[]) +deal (x:xs) = (x:ys,zs) + where + (zs,ys) = deal xs +-} + +isSearch :: Ord a => BT a -> Bool +isSearch = strictlyOrdered . toList + +ordered :: Ord a => [a] -> Bool +ordered [] = True +ordered xs = and (zipWith (<=) xs $ tail xs) + +strictlyOrdered :: Ord a => [a] -> Bool +strictlyOrdered [] = True +strictlyOrdered xs = and (zipWith (<) xs $ tail xs) + +-- | truncate tiers of values in the presence of one empty size +-- +-- truncateT [[x,y],[z,w],[],[],[],...] == [[x,y],[z,w]] +truncateT :: [[a]] -> [[a]] +truncateT ([]:xss) = [] +truncateT (xs:xss) = xs:truncateT xss +truncateT xss = xss + +instance (Ord a, Listable a) => Listable (BT a) where + tiers = truncateT + $ cons0 Null \/ cons3 Fork `suchThat` isSearch + +type Item = Word2 + +main :: IO () +main = speculate args + { instances = + [ ins "t" (undefined :: BT Item) + ] + , constants = + [ showConstant (Null :: BT Item) + , constant "insert" (insert :: Item -> BT Item -> BT Item) + , constant "delete" (delete :: Item -> BT Item -> BT Item) + , constant "isIn" (isIn :: Item -> BT Item -> Bool) + , background + , constant "<=" ((<=) :: Item -> Item -> Bool) + , constant "/=" ((/=) :: Item -> Item -> Bool) + , constant "ordered" (ordered :: [Item] -> Bool) + , constant "strictlyOrdered" (strictlyOrdered :: [Item] -> Bool) + , constant "toList" (toList :: BT Item -> [Item]) + , constant "fromList" (fromList :: [Item] -> BT Item) + , constant "isSearch" (isSearch :: BT Item -> Bool) + , showConstant ([]::[Item]) +-- TODO: when the following is added speculate "breaks" and prints a lot +-- of junk laws. Prune those away in speculate. Then re-add not. +-- , constant "not" (not :: Bool -> Bool) + ] + } diff --git a/eg/binarytree0.hs b/eg/binarytree0.hs new file mode 100644 --- /dev/null +++ b/eg/binarytree0.hs @@ -0,0 +1,111 @@ +{-# LANGUAGE CPP #-} +{-# Language DeriveDataTypeable, StandaloneDeriving #-} -- for GHC <= 7.8 +-- Colin Runciman, December 2016 +import Test.Speculate +import Test.LeanCheck +import Data.Function (on) + + +data BT a = Null | Fork (BT a) a (BT a) + deriving Show + +#if __GLASGOW_HASKELL__ < 708 +deriving instance Typeable1 BT +#else +deriving instance Typeable BT +#endif + +instance (Eq a, Ord a) => Eq (BT a) where + (==) = (==) `on` toList + +instance (Eq a, Ord a) => Ord (BT a) where + (<=) = isSubsequenceOf `on` toList + +isSubsequenceOf :: Eq a => [a] -> [a] -> Bool +isSubsequenceOf [] _ = True +isSubsequenceOf (_:_) [] = False +isSubsequenceOf (x:xs) (y:ys) + | x == y = xs `isSubsequenceOf` ys + | otherwise = (x:xs) `isSubsequenceOf` ys + +insert :: Ord a => a -> BT a -> BT a +insert x Null = Fork Null x Null +insert x t@(Fork t1 y t2) = case compare x y of + LT -> Fork (insert x t1) y t2 + EQ -> t + GT -> Fork t1 y (insert x t2) + +delete :: Ord a => a -> BT a -> BT a +delete x Null = Null +delete x t@(Fork t1 y t2) = case compare x y of + LT -> Fork (delete x t1) y t2 + EQ -> graft t1 t2 + GT -> Fork t1 y (delete x t2) + +isIn :: Ord a => a -> BT a -> Bool +isIn x t = x `elem` toList t + +graft :: Ord a => BT a -> BT a -> BT a +graft Null t = t +graft (Fork t1 x t2) t = Fork t1 x (graft t2 t) + +toList :: Ord a => BT a -> [a] +toList Null = [] +toList (Fork t1 x t2) = toList t1 ++ [x] ++ toList t2 + +fromList :: Ord a => [a] -> BT a +fromList = foldr insert Null + +{- +fromList :: Ord a => [a] -> BT a +fromList [] = Null +fromList xs = Fork (fromList ys) x (fromList zs) + where + (x:ys,zs) = deal xs + +deal :: [a] -> ([a],[a]) +deal [] = ([],[]) +deal (x:xs) = (x:ys,zs) + where + (zs,ys) = deal xs +-} + +isSearch :: Ord a => BT a -> Bool +isSearch = strictlyOrdered . toList + +ordered :: Ord a => [a] -> Bool +ordered [] = True +ordered xs = and (zipWith (<=) xs $ tail xs) + +strictlyOrdered :: Ord a => [a] -> Bool +strictlyOrdered [] = True +strictlyOrdered xs = and (zipWith (<) xs $ tail xs) + +-- | truncate tiers of values in the presence of one empty size +-- +-- truncateT [[x,y],[z,w],[],[],[],...] == [[x,y],[z,w]] +truncateT :: [[a]] -> [[a]] +truncateT ([]:xss) = [] +truncateT (xs:xss) = xs:truncateT xss +truncateT xss = xss + +instance (Ord a, Listable a) => Listable (BT a) where + tiers = truncateT + $ cons0 Null \/ cons3 Fork `suchThat` isSearch + +type Item = Word2 + +main :: IO () +main = speculate args + { instances = + [ ins "t" (undefined :: BT Item) + ] + , constants = + [ showConstant (Null :: BT Item) + , constant "insert" (insert :: Item -> BT Item -> BT Item) + , constant "delete" (delete :: Item -> BT Item -> BT Item) + , constant "isIn" (isIn :: Item -> BT Item -> Bool) + , background + , constant "/=" ((/=) :: Item -> Item -> Bool) + ] + } diff --git a/eg/bool.hs b/eg/bool.hs new file mode 100644 --- /dev/null +++ b/eg/bool.hs @@ -0,0 +1,14 @@ +import Test.Speculate +import Test.LeanCheck ((==>)) + +main :: IO () +main = speculate args + { constants = + [ showConstant False + , showConstant True + , constant "not" not + , constant "&&" (&&) + , constant "||" (||) +-- , constant "==>" (==>) + ] + } diff --git a/eg/colour.hs b/eg/colour.hs new file mode 100644 --- /dev/null +++ b/eg/colour.hs @@ -0,0 +1,90 @@ +{-# LANGUAGE CPP #-} +{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-} -- for GHC < 7.10 +#if __GLASGOW_HASKELL__ == 704 +import Test.Speculate -- go figure... +#else +import Test.Speculate hiding (value) +#endif +import Test.Speculate.Utils.Colour +import Test.LeanCheck +import Data.Ratio +import Data.Function (on) +import Test.Speculate.Sanity + +deriving instance Typeable Colour -- for GHC < 7.10 + +-- Just for Listable.tiers enumeration +data ColourComponent = ColourComponent Rational + +instance Listable ColourComponent where + tiers = mapT (ColourComponent . uncurry (%)) + $ tiers `suchThat` (\(n,d) -> n >= 0 && d > 0 && n <= d && n `gcd` d == 1) + `ofWeight` 0 + +instance Listable Colour where + tiers = cons3 (\(ColourComponent r) (ColourComponent g) (ColourComponent b) -> RGB r g b) + +colour :: Colour +colour = undefined + +main :: IO () +main = speculate args + { instances = + [ ordWith ((<=) `on` lightness) + , ins "c" colour + ] + , maxSize = 4 + , maxSemiSize = 2 + , force = True + , constants = + [ constant "+" $ (+) -:> colour + , constant "-" $ (-) -:> colour +-- , constant "*" $ (*) -:> colour +-- , constant "negate" $ negate -:> colour +-- , constant ".+." $ (.+.) -:> colour +-- , constant ".-." $ (.-.) -:> colour +-- , constant ".*." $ (.*.) -:> colour + , constant "chroma" chroma + , constant "hue" hue + , constant "saturation" saturation +-- , constant "intensity" intensity + , constant "value" value + , constant "lightness" lightness + , constant "fromHSV" fromHSV + , constant "fromHSL" fromHSL + , constant "mix" mix +-- , constant "mixHSV" mixHSV + + , background + , constant "black" black + , constant "white" white + , constant "red" red + , constant "grey" grey + , constant "green" green + , constant "blue" blue +-- , constant "cyan" cyan +-- , constant "magenta" magenta +-- , constant "yellow" yellow +-- , constant "orange" orange + , constant "Just" $ Just -:> rational + , constant "Nothing" (Nothing :: Maybe Rational) + + , showConstant (0 % 1 :: Rational) + , showConstant (1 % 1 :: Rational) + , showConstant (1 % 2 :: Rational) + +-- , constant "%" $ (%) -:> integer + +-- , constant "<=" $ (<=) -:> rational +-- , constant "<" $ (<) -:> rational + +-- , constant "==" $ (==) -:> colour +-- , constant "/=" $ (/=) -:> colour +-- , constant "isGrey" isGrey +-- , constant "notGrey" notGrey +-- , constant "primary" primary +-- , constant "secondary" secondary +-- , constant "tertiary" tertiary +-- , constant "`isOppositeTo`" isOppositeTo + ] + } diff --git a/eg/digraphs.hs b/eg/digraphs.hs new file mode 100644 --- /dev/null +++ b/eg/digraphs.hs @@ -0,0 +1,68 @@ +{-# LANGUAGE CPP, DeriveDataTypeable, StandaloneDeriving #-} -- for GHC < 7.10 +import Test.Speculate +import Test.LeanCheck hiding ((\/)) +import Test.LeanCheck.Utils +import Data.Function (on) + +import Digraph + +#if __GLASGOW_HASKELL__ < 710 +#if __GLASGOW_HASKELL__ < 708 +import Data.Typeable (Typeable1) +deriving instance Typeable1 Digraph +#else +deriving instance Typeable Digraph +#endif +deriving instance Typeable Nat +#endif + +instance Ord a => Ord (Digraph a) where + g1 <= g2 = all (`elem` nodes g2) (nodes g1) + && all (`elem` edges g2) (edges g1) + +instance (Ord a, Listable a) => Listable (Digraph a) where + tiers = concatMapT graphs $ setsOf tiers + where + graphs ns = mapT (D . zip ns) + $ listsOfLength (length ns) (setsOf $ toTiers ns) + +digraph :: a -> Digraph a +digraph = undefined + +main :: IO () +main = speculate args + { instances = + [ ins "x" nat + , ins "a" (digraph nat) + ] + , maxTests = 500 + , maxVars = 2 + , showConditions = True + , constants = + let + -- totalize functions for nicer output + -- (but also works without totalized functions) + addNode' n g | isNode n g = g + | otherwise = addNode n g + addEdge' n1 n2 g | isEdge n1 n2 g = g + | otherwise = addEdge n1 n2 g + in + [ background + + , showConstant ([]::[Nat]) + , constant "elem" $ elem ->:> [nat] + + + , foreground + + , constant "empty" $ empty -: digraph nat + , constant "addNode" $ addNode' -:> nat + , constant "addEdge" $ addEdge' -:> nat + + , constant "isNode" $ isNode -:> nat + , constant "isEdge" $ isEdge -:> nat + + , constant "isPath" $ isPath -:> nat + , constant "subgraph" $ subgraph -:> [nat] + ] + } diff --git a/eg/fun.hs b/eg/fun.hs new file mode 100644 --- /dev/null +++ b/eg/fun.hs @@ -0,0 +1,14 @@ +import Test.Speculate +import Test.Speculate.Function.A100 + +main :: IO () +main = speculate args + { maxTests = 1000 + , instances = [ins "f" (undefined :: Int -> Int)] + , constants = + [ hole (undefined :: Int -> Int) + , constant "map" (map :: (Int -> Int) -> [Int] -> [Int]) + , constant "id" (id :: Int -> Int) + , constant "." ((.) :: (Int -> Int) -> (Int -> Int) -> (Int -> Int)) + ] + } diff --git a/eg/insertsort.hs b/eg/insertsort.hs new file mode 100644 --- /dev/null +++ b/eg/insertsort.hs @@ -0,0 +1,32 @@ +import Test.Speculate +import Data.List (sort,insert) + +ordered :: Ord a => [a] -> Bool +ordered (x:y:xs) = x <= y && ordered (y:xs) +ordered _ = True + +main :: IO () +main = speculate args + { constants = + [ background + , constant "False" False + , constant "True" True + , showConstant ([] :: [Int]) + , constant ":" $ (:) -:> int + , constant "++" $ (++) -:> [int] + , constant "elem" $ elem ->:> [int] + , constant "ordered" $ ordered -:> [int] + , constant "all" $ all ->:> [int] + + , foreground + , constant "insert" $ insert -:> int + , constant "sort" $ sort -:> [int] + + , background + , constant "==" $ (==) -:> int + , constant "<=" $ (<=) -:> int + , constant "<" $ (<) -:> int + ] + , maxVars = 2 + , showConditions = True + } diff --git a/eg/insertsort0.hs b/eg/insertsort0.hs new file mode 100644 --- /dev/null +++ b/eg/insertsort0.hs @@ -0,0 +1,21 @@ +import Test.Speculate +import Data.List (sort,insert) + +main :: IO () +main = speculate args + { constants = + [ background + , showConstant ([] :: [Int]) + , constant ":" $ (:) -:> int + , foreground + , constant "insert" $ insert -:> int + , constant "sort" $ sort -:> [int] + + , background + , constant "<=" $ (<=) -:> int + , constant "<" $ (<) -:> int + ] + , maxVars = 2 + , showSemiequations = False + , showConstantLaws = True + } diff --git a/eg/length.hs b/eg/length.hs new file mode 100644 --- /dev/null +++ b/eg/length.hs @@ -0,0 +1,24 @@ +import Test.Speculate + +-- needed for GHC <= 7.8, exported by Data.List on GHC >= 7.10. +isSubsequenceOf :: Eq a => [a] -> [a] -> Bool +isSubsequenceOf [] _ = True +isSubsequenceOf (_:_) [] = False +isSubsequenceOf (x:xs) (y:ys) + | x == y = xs `isSubsequenceOf` ys + | otherwise = (x:xs) `isSubsequenceOf` ys + +main :: IO () +main = speculate args + { constants = + [ background + , showConstant ([] :: [Int]) + , constant ":" $ (:) -:> int + , constant "++" $ (++) -:> [int] + , showConstant (0 :: Int) +-- , showConstant (1 :: Int) + , foreground + , constant "length" $ length -:> [int] + ] + , instances = [ ordWith (isSubsequenceOf :: [Int] -> [Int] -> Bool) ] + } diff --git a/eg/list.hs b/eg/list.hs new file mode 100644 --- /dev/null +++ b/eg/list.hs @@ -0,0 +1,25 @@ +import Test.Speculate + +isSubsequenceOf :: Eq a => [a] -> [a] -> Bool +isSubsequenceOf [] _ = True +isSubsequenceOf (_:_) [] = False +isSubsequenceOf (x:xs) (y:ys) + | x == y = xs `isSubsequenceOf` ys + | otherwise = (x:xs) `isSubsequenceOf` ys + +main :: IO () +main = speculate args + { maxSemiSize = 0 + , maxVars = 3 +--, instances = [ ordWith (isPrefixOf :: [Int] -> [Int] -> Bool) ] +--, instances = [ ordWith (isInfixOf :: [Int] -> [Int] -> Bool) ] + , instances = [ ordWith (isSubsequenceOf :: [Int] -> [Int] -> Bool) ] + , constants = + [ showConstant ([] :: [Int]) + , constant ":" ((:) :: Int -> [Int] -> [Int]) + , constant "++" ((++) :: [Int] -> [Int] -> [Int]) + , constant "head" (head :: [Int] -> Int) + , constant "tail" (tail :: [Int] -> [Int]) +-- , constant "null" (null :: [Int] -> Bool) + ] + } diff --git a/eg/minus.hs b/eg/minus.hs new file mode 100644 --- /dev/null +++ b/eg/minus.hs @@ -0,0 +1,15 @@ +import Test.Speculate + +main :: IO () +main = speculate args + { constants = + [ showConstant (0::Int) + , showConstant (1::Int) + , constant "id" $ id -:> int + -- Add abs for 30 seconds runtime in "old" KBC, about 10 without. + --, constant "abs" $ abs -:> int + , constant "+" $ (+) -:> int + , constant "negate" $ negate -:> int + , constant "-" $ (-) -:> int + ] + } diff --git a/eg/monad.hs b/eg/monad.hs new file mode 100644 --- /dev/null +++ b/eg/monad.hs @@ -0,0 +1,19 @@ +import Test.Speculate +import Test.Speculate.Function.A100 + +import Control.Monad ((>=>)) + +type A = Int +type B = Int +type C = Int + +main :: IO () +main = speculate args + { instances = [ins "f" (int >- [int])] + , constants = + [ hole (int >- [int]) + , constant "return" (return :: A -> [A]) + , constant ">>=" ((>>=) :: [A] -> (A -> [B]) -> [B]) + , constant ">=>" ((>=>) :: (A -> [B]) -> (B -> [C]) -> (A -> [C])) + ] + } diff --git a/eg/oddeven.hs b/eg/oddeven.hs new file mode 100644 --- /dev/null +++ b/eg/oddeven.hs @@ -0,0 +1,33 @@ +import Test.Speculate + +main :: IO () +main = speculate args + { showConditions = True + , constants = + [ showConstant (0::Int) + , showConstant (1::Int) + , showConstant (2::Int) + , showConstant False + , showConstant True + , constant "odd" $ odd -:> int + , constant "even" $ even -:> int + , constant "`mod`" $ mod -:> int + , constant "==" $ (==) -:> int + ] +{- after adding the following, conditions do not appear but in a way should: + , conditionAtoms = + [ constant "`mod`" $ mod -:> int + , constant "==" $ (==) -:> int + ] + , equationAtoms = + [ constant "odd" $ odd -:> int + , constant "even" $ even -:> int + ] +-- the problem is that "odd" and "even" are actually smaller versions of the +-- preconditions we "want": +-- > (x `mod` 2 == 0) == even x +-- conditionAtoms and equationAtoms should be used with care! +-- TODO: add that somewhere in the docs +-- TODO: make this not happen? would be really hard: theorize twice! +-} + } diff --git a/eg/pretty-compact.hs b/eg/pretty-compact.hs new file mode 100644 --- /dev/null +++ b/eg/pretty-compact.hs @@ -0,0 +1,55 @@ +{-# LANGUAGE TypeSynonymInstances, TemplateHaskell #-} +import Test.Speculate hiding (string, char) +import Test.LeanCheck +import Data.Function (on) +import Data.List (isPrefixOf) + +import Text.PrettyPrint.Compact + +renderWidth :: Monoid a => Int -> Doc a -> String +renderWidth n = renderWith defaultOptions{optsPageWidth = n} + +renders :: Monoid a => Doc a -> [String] +renders d = [renderWidth n d | n <- [1..8] ++ [10,20..80]] + +instance Monoid a => Eq (Doc a) where + (==) = (==) `on` renders + +instance Monoid a => Ord (Doc a) where + (<=) = and .: (zipWith isPrefixOf `on` renders) + where (.:) = (.) . (.) + +instance Monoid a => Listable (Doc a) where + tiers = cons1 text + \/ cons2 (<>) + \/ cons2 (<+>) + \/ cons2 ($$) + \/ cons2 () + \/ cons2 () + \/ cons2 (<$$>) + +instance Monoid a => Show (Doc a) where + show = render + +da :: Doc Any +da = undefined + +main :: IO () +main = speculate args + { instances = [ins "d1" da] + , showConditions = False + , maxSize = 4 + , maxTests = 360 + , constants = + [ constant "text" $ text ->: da + , constant "char" $ char ->: da + , constant "flush" $ flush -:> da + , constant "hang" $ hang ->:> da + , constant "<>" $ (<>) -:> da + , constant "<+>" $ (<+>) -:> da + , constant "$$" $ ($$) -:> da + , constant "" $ () -:> da + , constant "" $ () -:> da + , constant "<$$>" $ (<$$>) -:> da + ] + } diff --git a/eg/pretty.hs b/eg/pretty.hs new file mode 100644 --- /dev/null +++ b/eg/pretty.hs @@ -0,0 +1,41 @@ +{-# LANGUAGE CPP #-} +{-# Language DeriveDataTypeable, StandaloneDeriving #-} -- for GHC < 7.10 +import Test.Speculate +import Test.LeanCheck +import Data.Function (on) +import Data.List (isPrefixOf) + +import Text.PrettyPrint as P + +deriving instance Typeable Doc -- for GHC < 7.10 + +#if __GLASGOW_HASKELL__ < 710 +-- pretty <= 1.1.1.1 (bundled with GHC <= 7.8) does not provide this instance +-- pretty >= 1.1.2.0 (bundled with GHC >= 7.10) does provide this instance +instance Eq Doc where + d == d' = show d == show d' +#endif + +instance Ord Doc where + (<=) = isPrefixOf `on` show + +instance Listable Doc where + tiers = cons1 text + \/ cons2 ($$) + \/ cons2 (P.<>) + \/ cons2 nest + +main :: IO () +main = speculate args + { instances = [ins "d1" (undefined :: Doc)] + , maxSize = 7 + , maxVars = 3 + , constants = + [ constant "$$" ($$) + , constant "<>" (P.<>) + , constant "nest" nest + , background + , constant "++" $ (++) -:> string + , constant "length" $ length -:> string + ] + } diff --git a/eg/ratio.hs b/eg/ratio.hs new file mode 100644 --- /dev/null +++ b/eg/ratio.hs @@ -0,0 +1,24 @@ +import Test.Speculate + +import Data.Ratio + +main :: IO () +main = speculate args + { constants = + [ constant "id" $ id -:> rational + , constant "abs" $ abs -:> rational + , constant "negate" $ negate -:> rational + , constant "+" $ (+) -:> rational + , constant "*" $ (*) -:> rational + , constant "/" $ (/) -:> rational + , constant "%" $ (%) ->>: rational + , constant "recip" $ recip -:> rational + , constant "numerator" $ numerator -:> rational + , constant "denominator" $ denominator -:> rational + , background + , showConstant (0 :: Rational) + , showConstant (1 :: Rational) + , showConstant (0 :: Integer) + , showConstant (1 :: Integer) + ] + } diff --git a/eg/regexes.hs b/eg/regexes.hs new file mode 100644 --- /dev/null +++ b/eg/regexes.hs @@ -0,0 +1,124 @@ +{-# Language CPP #-} +{-# Language DeriveDataTypeable, StandaloneDeriving #-} +import Test.Speculate +import Test.Speculate.Utils.Memoize +import Data.Function (on) +import Regex +import Data.Maybe (fromJust) + +instance Listable Symbol where + list = [Symbol 'a', Symbol 'b', Symbol 'c'] + +instance Listable a => Listable (RE a) where + tiers = cons0 Empty + \/ cons0 None + \/ cons1 Lit + \/ cons1 Star + \/ cons2 (:+) + \/ cons2 (:.) + +deriving instance Typeable Symbol +#if __GLASGOW_HASKELL__ < 708 +deriving instance Typeable1 RE +#else +deriving instance Typeable RE +#endif + +canonicalRE :: (Eq a, Ord a) => RE a -> Bool +-- by laws of size 3 +canonicalRE (Star (Star r)) = False -- == Star r +canonicalRE (r :+ s) | r >= s = False -- == r or == s :+ r +canonicalRE (r :+ None) = False -- == r +canonicalRE (None :+ r) = False -- == r +canonicalRE (r :. Empty) = False -- == r +canonicalRE (Empty :. r) = False -- == r +canonicalRE (r :. None) = False -- == None +canonicalRE (None :. r) = False -- == None +-- by laws of size 4 +canonicalRE (r :+ Star s) | r == s = False -- == Star r +canonicalRE (Star r :+ s) | r == s = False -- == Star r +canonicalRE (Star r :. s) | r == s = False -- == r :. Star r +canonicalRE (Star (r :+ Empty)) = False -- == Star r +canonicalRE (Star (Empty :+ r)) = False -- == Star r +canonicalRE (Empty :+ Star r) = False -- == Star r +canonicalRE (Star r :+ Empty) = False -- == Star r +-- by laws of size 5 +canonicalRE ((r :+ s) :+ t) = False -- == r :+ (s :+ t) +canonicalRE ((r :. s) :. t) = False -- == r :. (s :. t) +canonicalRE (Star (r :+ Star s)) = False -- == Star (r :+ s) +canonicalRE (Star (Star r :+ s)) = False -- == Star (r :+ s) +canonicalRE (r :. (s :+ Empty)) = False -- == r :+ (r :. s) +canonicalRE ((r :+ Empty) :. s) = False -- == s :+ (r :. s) +canonicalRE (Star (r :. Star s)) | r == s = False -- == Star r +canonicalRE (Star (Star r :. s)) | r == s = False -- == Star r +canonicalRE (Star r :. Star s) | r == s = False -- == Star r +-- by laws of size 6 +canonicalRE (r :+ Star (r' :+ s)) | r == r' = False -- == Star (r :+ s) +canonicalRE (r :+ Star (s :+ r')) | r == r' = False -- == Star (r :+ s) +canonicalRE (Star (r' :+ s) :+ r) | r == r' = False -- == Star (r :+ s) +canonicalRE (Star (s :+ r') :+ r) | r == r' = False -- == Star (r :+ s) +canonicalRE (Star r :. (r' :. s)) | r == r' = False -- == r :. (Star r :. s) +canonicalRE (Star (r :. s) :. r') | r == r' = False -- == r :. Star (s :. r) +canonicalRE (r :+ (r' :. Star s)) | r == r' = False -- == r :. Star s +canonicalRE (r :+ (Star s :. r')) | r == r' = False -- == Star s :. r +canonicalRE (Star (Star r :. Star s)) = False -- == Star (r :+ s) +canonicalRE (Star (r :+ (r' :. r''))) | r == r' && r == r'' = False -- == Star r +canonicalRE (Star r :+ (r' :. r'')) | r == r' && r == r'' = False -- == Star r +canonicalRE (Empty :+ (r :. Star r')) | r == r' = False -- == Star r +-- default +canonicalRE _ = True + + + +deriving instance Eq a => Eq (RE a) +deriving instance Ord a => Ord (RE a) + +class Charable a where toChar :: a -> Char +instance Charable Char where toChar = id +instance Charable Symbol where toChar (Symbol c) = c + +testMatches :: (Listable a, Show a, Charable a, Ord a) => RE a -> [Bool] +testMatches = tm `withMemory` mem + where + tm r = map (\e -> match toChar e r) $ take 120 list +--mem = memoryFor 10000000 tm -- use when -t360 + mem = memoryFor 1000000 tm -- induces "Ord a" constraint + +observingList :: (a -> a -> Bool) -> (b -> [a]) -> b -> b -> Bool +observingList g f = and .: (zipWith g `on` f) where (.:) = (.) . (.) + +(/==/) :: RE Symbol -> RE Symbol -> Bool +(/==/) = (==) `on` testMatches + +(/<=/) :: RE Symbol -> RE Symbol -> Bool +(/<=/) = (<=) `observingList` testMatches + +-- wrong laws appear when setting maxSize to 5, even when tests are increased +-- to 500 (or more) +main :: IO () +main = speculate args + { maxTests = 30 + , maxSize = 4 + , instances = + [ eqWith (/==/) + , ordWith (/<=/) + , ins "c" (undefined :: Symbol) + , ins "r" (undefined :: RE Symbol) + ] + , constants = + [ constant "Empty" (Empty :: RE Symbol) + , constant "None" (None :: RE Symbol) + , constant "Star" (Star :: RE Symbol -> RE Symbol) + , constant ":+" ((:+) :: RE Symbol -> RE Symbol -> RE Symbol) + , constant ":." ((:.) :: RE Symbol -> RE Symbol -> RE Symbol) +-- , constant "=~" (=~) +-- , constant "Lit" (Lit :: Symbol -> RE Symbol) + , background + , constant "<=" (/<=/) + , constant "==" (/==/) + , showConstant False + , showConstant True + ] + , showConditions = False + , force = True + } diff --git a/eg/sets.hs b/eg/sets.hs new file mode 100644 --- /dev/null +++ b/eg/sets.hs @@ -0,0 +1,42 @@ +{-# Language CPP #-} +{-# Language DeriveDataTypeable, StandaloneDeriving #-} -- for GHC < 7.10 +import Test.Speculate hiding ((\/)) + +import Set hiding (set) +import qualified Set as S + +#if __GLASGOW_HASKELL__ < 708 +deriving instance Typeable1 S.Set +#else +deriving instance Typeable S.Set -- for GHC < 7.10 +#endif + +instance (Ord a, Listable a) => Listable (S.Set a) where + tiers = setCons S.set + +set :: a -> S.Set a +set = undefined + +main :: IO () +main = speculate args + { instances = [ins "s" (set int)] + , constants = + [ constant "emptyS" $ emptyS -: set int + , constant "singleS" $ singleS -:> int + --, constant "pairS" $ pairS -:> int + , constant "insertS" $ insertS -:> int + , constant "deleteS" $ deleteS -:> int + , constant "sizeS" $ sizeS -:> set int + , constant "<~" $ (<~) -:> int + , constant "\\/" $ (\/) -:> set int + , constant "/\\" $ (/\) -:> set int + --, constant "\\\\" $ (\\) -:> set int + --, constant "<~" $ (<~) -:> set int + --, constant "subS" $ subS -:> set int + --, constant "powerS" $ powerS -:> set int + --, constant "partitionsS" $ partitionsS -:> set int + , background + , showConstant False + , showConstant True + ] + } diff --git a/eg/speculate-reason.hs b/eg/speculate-reason.hs new file mode 100644 --- /dev/null +++ b/eg/speculate-reason.hs @@ -0,0 +1,67 @@ +{-# Language DeriveDataTypeable, StandaloneDeriving #-} -- for GHC <= 7.8 +import Test.Speculate +import Test.Speculate.Expr +import Test.Speculate.Reason +import Test.Speculate.Utils.Timeout (timeoutToError) +import Test + +import Data.Function (on) +import Data.Monoid ((<>)) + +-- for GHC <= 7.8 +deriving instance Typeable Thyght +deriving instance Typeable Equation + +instance Ord Thy where + compare = (compare `on` rules) + <> (compare `on` equations) + <> (compare `on` closureLimit) + +instance Eq Thyght where + (==) = (==) `on` unThyght + +instance Ord Thyght where + compare = compare `on` unThyght + +-- NOTE: we get wrong laws for size 5, but no wrong laws for size 4. +-- increasing the number of tests can get rid of those laws + +main :: IO () +main = speculate args + { maxTests = 6000 -- one of the datatypes is too wide! + , maxSize = 4 + , showConditions = False + , showSemiequations = False + , instances = + [ ins "t" (undefined :: Thyght) + , ins "eq" (undefined :: Equation) + , ins "e" (undefined :: Expr) + ] + , constants = + [ constant "okThy" $ \(Thyght t) -> okThy t + + , constant "insert" $ \eq (Thyght t) -> Thyght $ insert (unEquation eq) t + , constant "complete" $ \(Thyght t) -> Thyght $ complete t -- $ timeoutToError 0.2 $ complete t + + , constant "normalize" $ \(Thyght t) e -> normalize t e + , constant "equivalent" $ \(Thyght t) e1 e2 -> equivalent t e1 e2 + + , constant "append" $ \(Thyght t) eqs -> Thyght $ append t $ map unEquation eqs +-- , constant "isNormal" isNormal + +-- , constant "initialize" initialize +-- , constant "theorize" theorize +-- , constant "finalize" finalize + +-- , constant "criticalPairs" criticalPairs +-- , constant "normalizedCriticalPairs" normalizedCriticalPairs +-- , constant "difference" difference +-- , constant "showThy" showThy + + , background + , constant "emptyThy" $ Thyght emptyThy + , constant "True" True + , constant "False" False + , constant "Equation" $ Equation + ] + } diff --git a/eg/string.hs b/eg/string.hs new file mode 100644 --- /dev/null +++ b/eg/string.hs @@ -0,0 +1,18 @@ +import Test.Speculate +import Data.List (sort,insert) + +main :: IO () +main = speculate args + { constants = + [ showConstant "" + , showConstant " " + , showConstant "\n" + + , constant "lines" lines + , constant "words" words + , constant "unlines" unlines + , constant "unwords" unwords + + , constant "++" $ (++) -:> [char] + ] + } diff --git a/eg/tauts.hs b/eg/tauts.hs new file mode 100644 --- /dev/null +++ b/eg/tauts.hs @@ -0,0 +1,38 @@ +{-# LANGUAGE TemplateHaskell #-} +{-# Language DeriveDataTypeable, StandaloneDeriving #-} -- for GHC < 7.10 +import Test.Speculate +import Taut hiding (main) +import Test.LeanCheck + +deriveListable ''Prop +deriveListable ''Name + +deriving instance Typeable Prop +deriving instance Typeable Name + +prop :: Prop +prop = undefined + +name :: Name +name = undefined + +main :: IO () +main = speculate args + { instances = + [ ins "p" prop + , ins "n" name + ] + , showConditions = True + , maxVars = 2 + , maxTests = 4000 + , constants = + [ showConstant False + , showConstant True + , constant "==" ((==) -:> prop) + + , constant "eval" eval + , constant "varOf" varOf + , constant "subst" subst + , constant "taut" taut + ] + } diff --git a/eg/tuples.hs b/eg/tuples.hs new file mode 100644 --- /dev/null +++ b/eg/tuples.hs @@ -0,0 +1,28 @@ +import Test.Speculate +import Data.Tuple + +right :: (a,b,c) -> (c,a,b) +right (x,y,z) = (z,x,y) + +left :: (a,b,c) -> (b,c,a) +left (x,y,z) = (y,z,x) + +main :: IO () +main = speculate args + { maxSemiSize = 0 + , maxVars = 3 + , constants = + [ showConstant (() :: ()) + , constant "id" (id :: () -> ()) + , constant "id" (id :: Int -> Int) + , constant "id" (id :: (Int,Int) -> (Int,Int)) + , constant "id" (id :: (Int,Int,Int) -> (Int,Int,Int)) + , constant "," ((,) :: Int -> Int -> (Int,Int)) + , constant ",," ((,,) :: Int -> Int -> Int -> (Int,Int,Int)) + , constant "fst" (fst :: (Int,Int) -> Int) + , constant "snd" (snd :: (Int,Int) -> Int) + , constant "swap" (swap :: (Int,Int) -> (Int,Int)) + , constant "right" (right :: (Int,Int,Int) -> (Int,Int,Int)) + , constant "left" (left :: (Int,Int,Int) -> (Int,Int,Int)) + ] + } diff --git a/eg/zip.hs b/eg/zip.hs new file mode 100644 --- /dev/null +++ b/eg/zip.hs @@ -0,0 +1,17 @@ +import Test.Speculate + +main :: IO () +main = speculate args + { constants = + [ background + , constant "++" $ (++) -:> [int] + , constant "==" $ (==) -:> int + , constant "length" $ length -:> [int] + , foreground + , constant "zip" $ zip -:> [int] ->:> [int] + ] + , showSemiequations = False + , maxSemiSize = 5 + , maxCondSize = 5 + , maxVars = 3 + } diff --git a/mk/depend.mk b/mk/depend.mk new file mode 100644 --- /dev/null +++ b/mk/depend.mk @@ -0,0 +1,2030 @@ +bench/arithficial: \ + bench/arithficial.hs \ + mk/toplibs +bench/arithficial.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + bench/arithficial.hs +bench/nord: \ + bench/nord.hs \ + mk/toplibs +bench/nord.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + bench/nord.hs +bench/unit: \ + bench/unit.hs \ + mk/toplibs +bench/unit.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + bench/unit.hs +eg/algebraic-graphs: \ + eg/algebraic-graphs.hs \ + mk/toplibs +eg/algebraic-graphs.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/algebraic-graphs.hs +eg/arith: \ + eg/arith.hs \ + mk/toplibs +eg/arith-negate-abs: \ + eg/arith-negate-abs.hs \ + mk/toplibs +eg/arith-negate-abs.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/arith-negate-abs.hs +eg/arith.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/arith.hs +eg/binarytree0: \ + eg/binarytree0.hs \ + mk/toplibs +eg/binarytree0.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/binarytree0.hs +eg/binarytree: \ + eg/binarytree.hs \ + mk/toplibs +eg/binarytree.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/binarytree.hs +eg/bool: \ + eg/bool.hs \ + mk/toplibs +eg/bool.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/bool.hs +eg/colour: \ + eg/colour.hs \ + mk/toplibs +eg/colour.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/colour.hs +eg/Digraph.o: \ + eg/Digraph.hs +eg/digraphs: \ + eg/digraphs.hs \ + eg/Digraph.hs \ + mk/toplibs +eg/digraphs.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Function.hs \ + src/Test/Speculate/Function/A100.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/digraphs.hs \ + eg/Digraph.hs +eg/fun: \ + eg/fun.hs \ + mk/toplibs +eg/fun.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/fun.hs +eg/insertsort0: \ + eg/insertsort0.hs \ + mk/toplibs +eg/insertsort0.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/insertsort0.hs +eg/insertsort: \ + eg/insertsort.hs \ + mk/toplibs +eg/insertsort.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/insertsort.hs +eg/length: \ + eg/length.hs \ + mk/toplibs +eg/length.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/length.hs +eg/list: \ + eg/list.hs \ + mk/toplibs +eg/list.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/list.hs +eg/minus: \ + eg/minus.hs \ + mk/toplibs +eg/minus.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Function.hs \ + src/Test/Speculate/Function/A100.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/minus.hs +eg/monad: \ + eg/monad.hs \ + mk/toplibs +eg/monad.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/monad.hs +eg/oddeven: \ + eg/oddeven.hs \ + mk/toplibs +eg/oddeven.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/oddeven.hs +eg/plus-abs: \ + eg/plus-abs.hs \ + mk/toplibs +eg/plus-abs.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/plus-abs.hs +eg/pretty: \ + eg/pretty.hs \ + mk/toplibs +eg/pretty.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/pretty.hs +eg/ratio: \ + eg/ratio.hs \ + mk/toplibs +eg/ratio.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/ratio.hs +eg/regexes: \ + eg/Regex.hs \ + eg/regexes.hs \ + mk/toplibs +eg/regexes.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/Regex.hs \ + eg/regexes.hs +eg/Regex.o: \ + eg/Regex.hs +eg/Set.o: \ + eg/Set.hs +eg/sets: \ + eg/sets.hs \ + eg/Set.hs \ + mk/toplibs +eg/sets.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/sets.hs \ + eg/Set.hs +eg/speculate-reason.o: \ + tests/Test.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/speculate-reason.hs +eg/speculate-reason: \ + tests/Test.hs \ + eg/speculate-reason.hs \ + mk/toplibs +eg/string: \ + eg/string.hs \ + mk/toplibs +eg/string.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/string.hs +eg/Taut: \ + eg/Taut.hs \ + mk/toplibs +eg/Taut.o: \ + eg/Taut.hs +eg/tauts: \ + eg/tauts.hs \ + eg/Taut.hs \ + mk/toplibs +eg/tauts.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/tauts.hs \ + eg/Taut.hs +eg/tuples: \ + eg/tuples.hs \ + mk/toplibs +eg/tuples.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/tuples.hs +eg/zip: \ + eg/zip.hs \ + mk/toplibs +eg/zip.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs \ + eg/zip.hs +src/Test/Speculate/Args.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Args.hs +src/Test/Speculate/CondReason.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/CondReason.hs +src/Test/Speculate/Engine: \ + mk/toplibs +src/Test/Speculate/Engine.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs +src/Test/Speculate/Expr/Canon.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs +src/Test/Speculate/Expr/Core.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr/Core.hs +src/Test/Speculate/Expr/Equate.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs +src/Test/Speculate/Expr/Ground.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs +src/Test/Speculate/Expr/Instance.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Core.hs +src/Test/Speculate/Expr/Match: \ + mk/toplibs +src/Test/Speculate/Expr/Match.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Core.hs +src/Test/Speculate/Expr.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs +src/Test/Speculate/Function/A1000.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Function.hs \ + src/Test/Speculate/Function/A1000.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +src/Test/Speculate/Function/A100.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Function.hs \ + src/Test/Speculate/Function/A100.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +src/Test/Speculate/Function.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Function.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +src/Test/Speculate/Misc.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Misc.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +src/Test/Speculate: \ + mk/toplibs +src/Test/Speculate.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +src/Test/Speculate/Pretty.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/CondReason.hs +src/Test/Speculate/Reason/Order.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs +src/Test/Speculate/Reason.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs +src/Test/Speculate/Report.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +src/Test/Speculate/Sanity.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs +src/Test/Speculate/SemiReason.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs +src/Test/Speculate/Utils/Class.o: \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Class.hs +src/Test/Speculate/Utils/Colour.o: \ + src/Test/Speculate/Utils/Colour.hs +src/Test/Speculate/Utils/Digraph.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs +src/Test/Speculate/Utils/List.o: \ + src/Test/Speculate/Utils/List.hs +src/Test/Speculate/Utils/Memoize.o: \ + src/Test/Speculate/Utils/Memoize.hs +src/Test/Speculate/Utils/Misc.o: \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/List.hs +src/Test/Speculate/Utils/Ord.o: \ + src/Test/Speculate/Utils/Ord.hs +src/Test/Speculate/Utils.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs +src/Test/Speculate/Utils/PrettyPrint.o: \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils/List.hs +src/Test/Speculate/Utils/String.o: \ + src/Test/Speculate/Utils/String.hs +src/Test/Speculate/Utils/Tiers.o: \ + src/Test/Speculate/Utils/Tiers.hs +src/Test/Speculate/Utils/Timeout.o: \ + src/Test/Speculate/Utils/Timeout.hs +src/Test/Speculate/Utils/Tuple.o: \ + src/Test/Speculate/Utils/Tuple.hs +src/Test/Speculate/Utils/Typeable.o: \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/List.hs +tests/test-creason.o: \ + tests/Test.hs \ + tests/test-creason.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-creason: \ + tests/Test.hs \ + tests/test-creason.hs \ + mk/toplibs +tests/test-engine.o: \ + tests/Test.hs \ + tests/test-engine.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-engine: \ + tests/Test.hs \ + tests/test-engine.hs \ + mk/toplibs +tests/test-eval.o: \ + tests/Test.hs \ + tests/test-eval.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-eval: \ + tests/Test.hs \ + tests/test-eval.hs \ + mk/toplibs +tests/test-expr.o: \ + tests/Test.hs \ + tests/test-expr.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-expr: \ + tests/Test.hs \ + tests/test-expr.hs \ + mk/toplibs +tests/test-match.o: \ + tests/Test.hs \ + tests/test-match.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-match: \ + tests/Test.hs \ + tests/test-match.hs \ + mk/toplibs +tests/test-misc.o: \ + tests/Test.hs \ + tests/test-misc.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Misc.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-misc: \ + tests/Test.hs \ + tests/test-misc.hs \ + mk/toplibs +tests/test-order.o: \ + tests/Test.hs \ + tests/test-order.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-order: \ + tests/Test.hs \ + tests/test-order.hs \ + mk/toplibs +tests/Test.o: \ + tests/Test.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-reason.o: \ + tests/test-reason.hs \ + tests/Test.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-reason: \ + tests/test-reason.hs \ + tests/Test.hs \ + mk/toplibs +tests/test-stats.o: \ + tests/test-stats.hs \ + tests/Test.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-stats: \ + tests/test-stats.hs \ + tests/Test.hs \ + mk/toplibs +tests/Test: \ + tests/Test.hs \ + mk/toplibs +tests/test-utils.o: \ + tests/test-utils.hs \ + tests/Test.hs \ + src/Test/Speculate/Utils/Typeable.hs \ + src/Test/Speculate/Utils/Tuple.hs \ + src/Test/Speculate/Utils/Timeout.hs \ + src/Test/Speculate/Utils/Tiers.hs \ + src/Test/Speculate/Utils/String.hs \ + src/Test/Speculate/Utils/PrettyPrint.hs \ + src/Test/Speculate/Utils.hs \ + src/Test/Speculate/Utils/Ord.hs \ + src/Test/Speculate/Utils/Misc.hs \ + src/Test/Speculate/Utils/Memoize.hs \ + src/Test/Speculate/Utils/List.hs \ + src/Test/Speculate/Utils/Digraph.hs \ + src/Test/Speculate/Utils/Colour.hs \ + src/Test/Speculate/Utils/Class.hs \ + src/Test/Speculate/SemiReason.hs \ + src/Test/Speculate/Sanity.hs \ + src/Test/Speculate/Report.hs \ + src/Test/Speculate/Reason.hs \ + src/Test/Speculate/Reason/Order.hs \ + src/Test/Speculate/Pretty.hs \ + src/Test/Speculate.hs \ + src/Test/Speculate/Expr.hs \ + src/Test/Speculate/Expr/Match.hs \ + src/Test/Speculate/Expr/Instance.hs \ + src/Test/Speculate/Expr/Ground.hs \ + src/Test/Speculate/Expr/Equate.hs \ + src/Test/Speculate/Expr/Core.hs \ + src/Test/Speculate/Expr/Canon.hs \ + src/Test/Speculate/Engine.hs \ + src/Test/Speculate/CondReason.hs \ + src/Test/Speculate/Args.hs +tests/test-utils: \ + tests/test-utils.hs \ + tests/Test.hs \ + mk/toplibs diff --git a/mk/ghcdeps b/mk/ghcdeps new file mode 100644 --- /dev/null +++ b/mk/ghcdeps @@ -0,0 +1,49 @@ +#!/bin/bash +# +# ghcdeps: generate Haskell make dependencies for compiling with GHC. +# +# Copyright (c) 2015-2017 Rudy Matela. +# Distributed under the 3-Clause BSD licence. +# +# From a list of files provided on standard input, +# generate flat make dependencies. +# +# Transitive relations are repeated. +# +# Usage: +# $ ghcdeps -isomedir:someother < ... +# +# will print -i parameters necessary for haddock to link to Haddock +# documentation installed on your system, so you can: +# +# $ haddock-i base template-haskell | xargs haddock +errxit() { + echo "$@" > /dev/stderr + exit 1 +} + +for pkg in "$@"; do + ghc-pkg field $pkg haddock-html,haddock-interfaces || + errxit "error: haddock-i: cannot find package $pkg (ghc-pkg)" +done | +sed "s/.*: //" | +sed "N;s/\n/,/;s/^/-i/" diff --git a/mk/haskell.mk b/mk/haskell.mk new file mode 100644 --- /dev/null +++ b/mk/haskell.mk @@ -0,0 +1,110 @@ +# Implicit rules for compiling Haskell code. +# +# Copyright (c) 2015-2018 Rudy Matela. +# Distributed under the 3-Clause BSD licence. +# +# You can optionally configure the "Configuration variables" below in your main +# makefile, e.g.: +# +# GHCIMPORTDIRS = path/to/dir:path/to/another/dir +# GHCFLAGS = -O2 -dynamic +# GHC = ghc-7.6 +# include haskell.mk + + + +# Configuration variables + +# GHC Parameters +GHCIMPORTDIRS ?= +GHCFLAGS ?= +GHC ?= ghc +GHCCMD = $(GHC) -i$(GHCIMPORTDIRS) $(GHCFLAGS) + +# Hugs Parameters +HUGSIMPORTDIRS ?= "/usr/lib/hugs/packages/*" +HUGSFLAGS ?= +CPPHS_HUGS ?= cpphs-hugs --noline -D__HUGS__ +HUGS ?= hugs +RUNHUGS ?= runhugs +HUGSCMD = $(HUGS) -F"$(CPPHS_HUGS)" -P$(HUGSIMPORTDIRS) $(HUGSFLAGS) +RUNHUGSCMD = $(RUNHUGS) -F"$(CPPHS_HUGS)" -P$(HUGSIMPORTDIRS) $(HUGSFLAGS) + + +# Makefile where to keep the dependencies +DEPMK ?= mk/depend.mk + +# LIB_HSS: all library Haskell files +# ALL_HSS: all Haskell files +# You can override ALL/LIB_HSS in your main Makefile +LIST_LIB_HSS ?= find src -name "*.hs" +LIST_ALL_HSS ?= find \( -path "./dist" -o -path "./.stack-work" \) -prune \ + -o -name "*.*hs" -print +LIB_HSS ?= $(shell $(LIST_LIB_HSS)) +ALL_HSS ?= $(shell $(LIST_ALL_HSS)) + +PKGNAME = $(shell cat *.cabal | grep "^name:" | sed -e "s/name: *//") + + +# Implicit rules +%.hi %.o: %.hs + $(GHCCMD) $< && touch $@ + +%: %.hs + $(GHCCMD) $< && touch $@ + +.PHONY: %.ghci +%.ghci: %.hs + $(GHCCMD) -O0 --interactive $< + +.PHONY: %.hugs +%.hugs: %.hs + $(HUGSCMD) $< + +.PHONY: %.runhugs +%.runhugs: %.hs + $(RUNHUGSCMD) $< + + +# Cleaning rule (add as a clean dependency) +.PHONY: clean-hi-o +clean-hi-o: + find $(ALL_HSS) | sed -e 's/hs$$/o/' | xargs rm -f + find $(ALL_HSS) | sed -e 's/hs$$/hi/' | xargs rm -f + find $(ALL_HSS) | sed -e 's/hs$$/dyn_o/' | xargs rm -f + find $(ALL_HSS) | sed -e 's/hs$$/dyn_hi/' | xargs rm -f + + +# Update dependency file +.PHONY: depend +depend: + find $(ALL_HSS) | ./mk/ghcdeps -i$(GHCIMPORTDIRS) $(GHCFLAGS) > $(DEPMK) + +# haddock rules +haddock: doc/index.html + +clean-haddock: + rm -f doc/*.{html,css,js,png,gif,json} README.html + +upload-haddock: + @echo "use \`cabal upload -d' instead" + @echo "(but 1st: cabal install --only-dependencies --enable-documentation)" + @echo "(to just compile docs: cabal haddock --for-hackage)" + @echo "(on Arch Linux, use: cabal haddock --for-hackage --haddock-options=--optghc=-dynamic)" + +doc/index.html: $(LIB_HSS) + ./mk/haddock-i base template-haskell | xargs \ + haddock --html -odoc $(LIB_HSS) $(HADDOCKFLAGS) --title=$(PKGNAME) + +# lists all Haskell source files +list-all-hss: + @find $(ALL_HSS) + +# lists library Haskell source files +list-lib-hss: + @find $(LIB_HSS) + +show-pkgname: + @echo $(PKGNAME) + +include $(DEPMK) diff --git a/speculate.cabal b/speculate.cabal --- a/speculate.cabal +++ b/speculate.cabal @@ -1,5 +1,5 @@ name: speculate -version: 0.3.4 +version: 0.3.5 synopsis: discovery of properties about Haskell functions description: Speculate automatically discovers laws about Haskell functions. @@ -22,6 +22,50 @@ extra-doc-files: README.md , TODO.md +extra-source-files: .gitignore + , .travis.yml + , Makefile + , bench/*.hs + , bench/arith-c + , bench/bool-c + , bench/list-c + , bench/minus-c + , bench/qs1/*.hs + , bench/qs1/*.out + , bench/qs1/Makefile + , bench/qs1/runtime-zero + , bench/qs2/*.hs + , bench/qs2/*.out + , bench/qs2/Makefile + , bench/qs2/binarytree.out1 + , bench/qs2/binarytree.out2 + , bench/qs2/binarytree.out3 + , bench/qs2/binarytree.out4 + , bench/qs2/binarytree.out5 + , bench/qs2/binarytree.out6 + , bench/qs2/binarytree.runtime-zero + , bench/qs2/runtime-zero + , bench/runtime-zero + , bin/compare-arith + , bin/compare-arithficial + , bin/compare-bool + , bin/compare-with-qs + , bin/run-heavy-regexes-benchmark + , eg/*.hs + , mk/depend.mk + , mk/ghcdeps + , mk/haddock-i + , mk/haskell.mk + , stack.yaml + , tests/benchmark + , tests/benchmark-cmp + , tests/benchmark-save + , tests/memory-benchmark + , tests/model/*.out + , tests/test-model + , tests/test-sdist + , tests/update-test-model + tested-with: GHC==8.2, GHC==8.0, GHC==7.10, GHC==7.8, GHC==7.6, GHC==7.4 source-repository head @@ -31,7 +75,7 @@ source-repository this type: git location: https://github.com/rudymatela/speculate - tag: v0.3.4 + tag: v0.3.5 library diff --git a/stack.yaml b/stack.yaml new file mode 100644 --- /dev/null +++ b/stack.yaml @@ -0,0 +1,16 @@ +# stack.yaml docs: +# https://docs.haskellstack.org/en/stable/yaml_configuration/ + +# resolver: nightly-2015-09-21 +# resolver: ghc-7.10.2 +resolver: lts-12.7 + +packages: +- . + +extra-deps: +- leancheck-0.7.2 + +flags: {} + +extra-package-dbs: [] diff --git a/tests/benchmark b/tests/benchmark new file mode 100644 --- /dev/null +++ b/tests/benchmark @@ -0,0 +1,74 @@ +#!/bin/bash +top=`dirname $0`/.. +eg=$top/eg +model=$top/tests/model + +case "$1" in + -*) sz="$1" + shift + ;; +esac + +test-model() { + $1 $sz | diff -rud $model/$2$sz.out - || exit 1 +} + +update-test-model() { + $1 $sz > $model/$2$sz.out +} + +tym() { + /usr/bin/time -f%e "$@" +} + +spc() { + /usr/bin/time -f%M "$@" +} + +mean() { + sum="`echo -n $* | sed -e "s/ / + /g"`" + mean="`echo "scale = 3; ($sum) / $#" | bc`" + printf "%3.3f\n" $mean +} +export -f mean + +div1024() { + printf "%3.0f\n" "`echo "$1 / 1024" | bc`" +} +export -f div1024 + +benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +memory-benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + spc $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean | + xargs bash -c 'div1024 "$@"' div1024 +} + +benchmark-cmp() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + grep "^ *$2$sz " bench/runtime-$HOSTNAME | tr '\n' ' ' + echo -n ' ' + for run in {1..1} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +find $* | sed -e "s/^bench/ /;s/^eg/ /" | +sort -b | sed -e "s/^ /bench/;s/^ /eg/" | +while read e +do + `basename $0` $top/$e `basename $e` +done diff --git a/tests/benchmark-cmp b/tests/benchmark-cmp new file mode 100644 --- /dev/null +++ b/tests/benchmark-cmp @@ -0,0 +1,74 @@ +#!/bin/bash +top=`dirname $0`/.. +eg=$top/eg +model=$top/tests/model + +case "$1" in + -*) sz="$1" + shift + ;; +esac + +test-model() { + $1 $sz | diff -rud $model/$2$sz.out - || exit 1 +} + +update-test-model() { + $1 $sz > $model/$2$sz.out +} + +tym() { + /usr/bin/time -f%e "$@" +} + +spc() { + /usr/bin/time -f%M "$@" +} + +mean() { + sum="`echo -n $* | sed -e "s/ / + /g"`" + mean="`echo "scale = 3; ($sum) / $#" | bc`" + printf "%3.3f\n" $mean +} +export -f mean + +div1024() { + printf "%3.0f\n" "`echo "$1 / 1024" | bc`" +} +export -f div1024 + +benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +memory-benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + spc $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean | + xargs bash -c 'div1024 "$@"' div1024 +} + +benchmark-cmp() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + grep "^ *$2$sz " bench/runtime-$HOSTNAME | tr '\n' ' ' + echo -n ' ' + for run in {1..1} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +find $* | sed -e "s/^bench/ /;s/^eg/ /" | +sort -b | sed -e "s/^ /bench/;s/^ /eg/" | +while read e +do + `basename $0` $top/$e `basename $e` +done diff --git a/tests/benchmark-save b/tests/benchmark-save new file mode 100644 --- /dev/null +++ b/tests/benchmark-save @@ -0,0 +1,3 @@ +#!/bin/bash +top=`dirname $0` +$top/benchmark "$@" | tee bench/runtime-$HOSTNAME diff --git a/tests/memory-benchmark b/tests/memory-benchmark new file mode 100644 --- /dev/null +++ b/tests/memory-benchmark @@ -0,0 +1,74 @@ +#!/bin/bash +top=`dirname $0`/.. +eg=$top/eg +model=$top/tests/model + +case "$1" in + -*) sz="$1" + shift + ;; +esac + +test-model() { + $1 $sz | diff -rud $model/$2$sz.out - || exit 1 +} + +update-test-model() { + $1 $sz > $model/$2$sz.out +} + +tym() { + /usr/bin/time -f%e "$@" +} + +spc() { + /usr/bin/time -f%M "$@" +} + +mean() { + sum="`echo -n $* | sed -e "s/ / + /g"`" + mean="`echo "scale = 3; ($sum) / $#" | bc`" + printf "%3.3f\n" $mean +} +export -f mean + +div1024() { + printf "%3.0f\n" "`echo "$1 / 1024" | bc`" +} +export -f div1024 + +benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +memory-benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + spc $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean | + xargs bash -c 'div1024 "$@"' div1024 +} + +benchmark-cmp() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + grep "^ *$2$sz " bench/runtime-$HOSTNAME | tr '\n' ' ' + echo -n ' ' + for run in {1..1} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +find $* | sed -e "s/^bench/ /;s/^eg/ /" | +sort -b | sed -e "s/^ /bench/;s/^ /eg/" | +while read e +do + `basename $0` $top/$e `basename $e` +done diff --git a/tests/model/algebraic-graphs-s4.out b/tests/model/algebraic-graphs-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/algebraic-graphs-s4.out @@ -0,0 +1,51 @@ +max expr size = 4 +max #-tests = 1080 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: Nat3 (holes: Nat3) +_ :: Graph Nat3 (holes: Graph Nat3) +0 :: Nat3 +0 :: Int +True :: Bool +empty :: Graph Nat3 +vertex :: Nat3 -> Graph Nat3 +(+) :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +(*) :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +overlay :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +connect :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +edge :: Nat3 -> Nat3 -> Graph Nat3 +length :: Graph Nat3 -> Int +size :: Graph Nat3 -> Int + +length (vertex i) == length (vertex j) + size (vertex i) == length (vertex 0) +length (edge i j) == length (edge k i') +length (edge i j) == size (edge k i') + length (x * y) == length (x + y) + size (x * y) == size (x + y) + x + x == x + x + empty == x + x * empty == x + empty * x == x + x + y == y + x + overlay x y == x + y + connect x y == x * y + + 0 <= length x + 0 <= size x + length x <= size x + size empty <= size x + length x <= length (x + y) + size x <= size (x + y) + length x <= size (y + x) +length (edge i i) <= size x + empty <= x + x <= x + y + x <= x * y + x <= y * x + vertex i <= edge i j + vertex i <= edge j i + x + y <= x * y + diff --git a/tests/model/algebraic-graphs-s7.out b/tests/model/algebraic-graphs-s7.out new file mode 100644 --- /dev/null +++ b/tests/model/algebraic-graphs-s7.out @@ -0,0 +1,64 @@ +max expr size = 7 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 1080 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: Nat3 (holes: Nat3) +_ :: Graph Nat3 (holes: Graph Nat3) +0 :: Nat3 +0 :: Int +True :: Bool +empty :: Graph Nat3 +vertex :: Nat3 -> Graph Nat3 +(+) :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +(*) :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +overlay :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +connect :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +edge :: Nat3 -> Nat3 -> Graph Nat3 +length :: Graph Nat3 -> Int +size :: Graph Nat3 -> Int + + length (vertex i) == length (vertex j) + size (vertex i) == length (vertex 0) + length (x * y) == length (x + y) + size (x * y) == size (x + y) +length (x + vertex i) == length (x + vertex j) + size (x + vertex i) == size (x + vertex j) + length (x * y + z) == length (x + (y + z)) + size (x * y + z) == size (x + (y + z)) + x + x == x + x + empty == x + x * empty == x + empty * x == x + x + y == y + x + overlay x y == x + y + connect x y == x * y + x + x * y == x * y + x + y * x == y * x + edge i j == vertex i * vertex j + (x + y) + z == x + (y + z) + (x * y) * z == x * (y * z) + x + y * (x * z) == y * (x * z) + x + y * (z * x) == y * (z * x) + x * (y + z) == x * y + x * z + (x + y) * z == x * z + y * z + x * (x * y) == x * x + x * y + x * (y * y) == x * y + y * y + x * (y * (x * z)) == x * (y * x) + x * (y * z) + + 0 <= length x + 0 <= size x + length x <= size x +size empty <= size x + x <= size (y + z) + length x <= length (edge i i) + length x <= length (x + y) + empty <= x + x <= x + y + x <= x * y + x <= y * x + x + y <= x * y + diff --git a/tests/model/algebraic-graphs.out b/tests/model/algebraic-graphs.out new file mode 100644 --- /dev/null +++ b/tests/model/algebraic-graphs.out @@ -0,0 +1,58 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 1080 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: Nat3 (holes: Nat3) +_ :: Graph Nat3 (holes: Graph Nat3) +0 :: Nat3 +0 :: Int +True :: Bool +empty :: Graph Nat3 +vertex :: Nat3 -> Graph Nat3 +(+) :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +(*) :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +overlay :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +connect :: Graph Nat3 -> Graph Nat3 -> Graph Nat3 +edge :: Nat3 -> Nat3 -> Graph Nat3 +length :: Graph Nat3 -> Int +size :: Graph Nat3 -> Int + + length (vertex i) == length (vertex j) + size (vertex i) == length (vertex 0) + length (x * y) == length (x + y) + size (x * y) == size (x + y) +length (x + vertex i) == length (x + vertex j) + size (x + vertex i) == size (x + vertex j) + x + x == x + x + empty == x + x * empty == x + empty * x == x + x + y == y + x + overlay x y == x + y + connect x y == x * y + x + x * y == x * y + x + y * x == y * x + edge i j == vertex i * vertex j + (x + y) + z == x + (y + z) + (x * y) * z == x * (y * z) + x * (x * y) == x * (x + y) + (x + y) * x == y * (x * x) + + 0 <= length x + 0 <= size x + length x <= size x +size empty <= size x + length x <= length (x + y) + size x <= size (x + y) + length x <= size (y + x) +size empty <= length (edge i i) + empty <= x + x <= x + y + x <= x * y + x <= y * x + x + y <= x * y + diff --git a/tests/model/arith-c-s4.out b/tests/model/arith-c-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/arith-c-s4.out @@ -0,0 +1,183 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +(+) :: Int -> Int -> Int +(*) :: Int -> Int -> Int + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +_ + _ :: Int (holes: Int, Int) +_ + 1 :: Int (holes: Int) +1 + 1 :: Int +_ * _ :: Int (holes: Int, Int) +_ + (_ + _) :: Int (holes: Int, Int, Int) +_ + (_ + 1) :: Int (holes: Int, Int) +_ + (1 + 1) :: Int (holes: Int) +_ + _ * _ :: Int (holes: Int, Int, Int) +1 + (1 + 1) :: Int +1 + _ * _ :: Int (holes: Int, Int) +_ * (_ + _) :: Int (holes: Int, Int, Int) +_ * (_ + 1) :: Int (holes: Int, Int) +_ * (_ * _) :: Int (holes: Int, Int, Int) + +x :: Int +0 :: Int +1 :: Int +x + x :: Int +x + 1 :: Int +1 + 1 :: Int +x * x :: Int +x + (x + x) :: Int +x + (x + 1) :: Int +x + (1 + 1) :: Int +x + x * x :: Int +1 + (1 + 1) :: Int +1 + x * x :: Int +x * (x + x) :: Int +x * (x * x) :: Int + +x :: Int +y :: Int +0 :: Int +1 :: Int +x + x :: Int +x + y :: Int +y + y :: Int +x + 1 :: Int +y + 1 :: Int +1 + 1 :: Int +x * x :: Int +x * y :: Int +y * y :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (y + y) :: Int +y + (y + y) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +y + (y + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +x + x * x :: Int +x + x * y :: Int +x + y * y :: Int +y + x * x :: Int +y + x * y :: Int +y + y * y :: Int +1 + (1 + 1) :: Int +1 + x * x :: Int +1 + x * y :: Int +1 + y * y :: Int +x * (x + x) :: Int +x * (x + y) :: Int +x * (y + y) :: Int +y * (x + y) :: Int +y * (y + y) :: Int +x * (x * x) :: Int +x * (x * y) :: Int +x * (y * y) :: Int +y * (y * y) :: Int + +x :: Int +y :: Int +z :: Int +0 :: Int +1 :: Int +x + x :: Int +x + y :: Int +x + z :: Int +y + y :: Int +y + z :: Int +z + z :: Int +x + 1 :: Int +y + 1 :: Int +z + 1 :: Int +1 + 1 :: Int +x * x :: Int +x * y :: Int +x * z :: Int +y * y :: Int +y * z :: Int +z * z :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (x + z) :: Int +x + (y + y) :: Int +x + (y + z) :: Int +x + (z + z) :: Int +y + (y + y) :: Int +y + (y + z) :: Int +y + (z + z) :: Int +z + (z + z) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +x + (z + 1) :: Int +y + (y + 1) :: Int +y + (z + 1) :: Int +z + (z + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +z + (1 + 1) :: Int +x + x * x :: Int +x + x * y :: Int +x + x * z :: Int +x + y * y :: Int +x + y * z :: Int +x + z * z :: Int +y + x * x :: Int +y + x * y :: Int +y + x * z :: Int +y + y * y :: Int +y + y * z :: Int +y + z * z :: Int +z + x * x :: Int +z + x * y :: Int +z + x * z :: Int +z + y * y :: Int +z + y * z :: Int +z + z * z :: Int +1 + (1 + 1) :: Int +1 + x * x :: Int +1 + x * y :: Int +1 + x * z :: Int +1 + y * y :: Int +1 + y * z :: Int +1 + z * z :: Int +x * (x + x) :: Int +x * (x + y) :: Int +x * (x + z) :: Int +x * (y + y) :: Int +x * (y + z) :: Int +x * (z + z) :: Int +y * (x + y) :: Int +y * (x + z) :: Int +y * (y + y) :: Int +y * (y + z) :: Int +y * (z + z) :: Int +z * (x + y) :: Int +z * (x + z) :: Int +z * (y + z) :: Int +z * (z + z) :: Int +x * (x * x) :: Int +x * (x * y) :: Int +x * (x * z) :: Int +x * (y * y) :: Int +x * (y * z) :: Int +x * (z * z) :: Int +y * (y * y) :: Int +y * (y * z) :: Int +y * (z * z) :: Int +z * (z * z) :: Int + +Number of Eq schema classes: 16 +Number of Eq 1-var classes: 15 +Number of Eq 2-var classes: 41 +Number of Eq 3-var classes: 90 diff --git a/tests/model/arith-c.out b/tests/model/arith-c.out new file mode 100644 --- /dev/null +++ b/tests/model/arith-c.out @@ -0,0 +1,183 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +(+) :: Int -> Int -> Int +(*) :: Int -> Int -> Int + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +_ + _ :: Int (holes: Int, Int) +_ + 1 :: Int (holes: Int) +1 + 1 :: Int +_ * _ :: Int (holes: Int, Int) +_ + (_ + _) :: Int (holes: Int, Int, Int) +_ + (_ + 1) :: Int (holes: Int, Int) +_ + (1 + 1) :: Int (holes: Int) +_ + _ * _ :: Int (holes: Int, Int, Int) +1 + (1 + 1) :: Int +1 + _ * _ :: Int (holes: Int, Int) +_ * (_ + _) :: Int (holes: Int, Int, Int) +_ * (_ + 1) :: Int (holes: Int, Int) +_ * (_ * _) :: Int (holes: Int, Int, Int) + +x :: Int +0 :: Int +1 :: Int +x + x :: Int +x + 1 :: Int +1 + 1 :: Int +x * x :: Int +x + (x + x) :: Int +x + (x + 1) :: Int +x + (1 + 1) :: Int +x + x * x :: Int +1 + (1 + 1) :: Int +1 + x * x :: Int +x * (x + x) :: Int +x * (x * x) :: Int + +x :: Int +y :: Int +0 :: Int +1 :: Int +x + x :: Int +x + y :: Int +y + y :: Int +x + 1 :: Int +y + 1 :: Int +1 + 1 :: Int +x * x :: Int +x * y :: Int +y * y :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (y + y) :: Int +y + (y + y) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +y + (y + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +x + x * x :: Int +x + x * y :: Int +x + y * y :: Int +y + x * x :: Int +y + x * y :: Int +y + y * y :: Int +1 + (1 + 1) :: Int +1 + x * x :: Int +1 + x * y :: Int +1 + y * y :: Int +x * (x + x) :: Int +x * (x + y) :: Int +x * (y + y) :: Int +y * (x + y) :: Int +y * (y + y) :: Int +x * (x * x) :: Int +x * (x * y) :: Int +x * (y * y) :: Int +y * (y * y) :: Int + +x :: Int +y :: Int +z :: Int +0 :: Int +1 :: Int +x + x :: Int +x + y :: Int +x + z :: Int +y + y :: Int +y + z :: Int +z + z :: Int +x + 1 :: Int +y + 1 :: Int +z + 1 :: Int +1 + 1 :: Int +x * x :: Int +x * y :: Int +x * z :: Int +y * y :: Int +y * z :: Int +z * z :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (x + z) :: Int +x + (y + y) :: Int +x + (y + z) :: Int +x + (z + z) :: Int +y + (y + y) :: Int +y + (y + z) :: Int +y + (z + z) :: Int +z + (z + z) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +x + (z + 1) :: Int +y + (y + 1) :: Int +y + (z + 1) :: Int +z + (z + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +z + (1 + 1) :: Int +x + x * x :: Int +x + x * y :: Int +x + x * z :: Int +x + y * y :: Int +x + y * z :: Int +x + z * z :: Int +y + x * x :: Int +y + x * y :: Int +y + x * z :: Int +y + y * y :: Int +y + y * z :: Int +y + z * z :: Int +z + x * x :: Int +z + x * y :: Int +z + x * z :: Int +z + y * y :: Int +z + y * z :: Int +z + z * z :: Int +1 + (1 + 1) :: Int +1 + x * x :: Int +1 + x * y :: Int +1 + x * z :: Int +1 + y * y :: Int +1 + y * z :: Int +1 + z * z :: Int +x * (x + x) :: Int +x * (x + y) :: Int +x * (x + z) :: Int +x * (y + y) :: Int +x * (y + z) :: Int +x * (z + z) :: Int +y * (x + y) :: Int +y * (x + z) :: Int +y * (y + y) :: Int +y * (y + z) :: Int +y * (z + z) :: Int +z * (x + y) :: Int +z * (x + z) :: Int +z * (y + z) :: Int +z * (z + z) :: Int +x * (x * x) :: Int +x * (x * y) :: Int +x * (x * z) :: Int +x * (y * y) :: Int +x * (y * z) :: Int +x * (z * z) :: Int +y * (y * y) :: Int +y * (y * z) :: Int +y * (z * z) :: Int +z * (z * z) :: Int + +Number of Eq schema classes: 16 +Number of Eq 1-var classes: 15 +Number of Eq 2-var classes: 41 +Number of Eq 3-var classes: 90 diff --git a/tests/model/arith-negate-abs-s4.out b/tests/model/arith-negate-abs-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/arith-negate-abs-s4.out @@ -0,0 +1,40 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +id :: Int -> Int +abs :: Int -> Int +negate :: Int -> Int +(+) :: Int -> Int -> Int +(*) :: Int -> Int -> Int + + id x == x +negate (negate x) == x + x + 0 == x + x * 1 == x + x * 0 == 0 + abs (abs x) == abs x + abs (negate x) == abs x + x + negate x == 0 + x + y == y + x + x * y == y * x + abs (x * x) == x * x + x * negate y == negate (x * y) + + x <= abs x + 0 <= abs x + x <= x * x + x <= x + 1 + 0 <= x * x + negate x <= abs x +negate (abs x) <= x +negate (abs x) <= 0 + abs x <= x * x +negate (abs x) <= negate x + diff --git a/tests/model/arith-negate-abs.out b/tests/model/arith-negate-abs.out new file mode 100644 --- /dev/null +++ b/tests/model/arith-negate-abs.out @@ -0,0 +1,68 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +id :: Int -> Int +abs :: Int -> Int +negate :: Int -> Int +(+) :: Int -> Int -> Int +(*) :: Int -> Int -> Int + + id x == x +negate (negate x) == x + x + 0 == x + x * 1 == x + x * 0 == 0 + abs (abs x) == abs x + abs (negate x) == abs x + x + negate x == 0 + x + y == y + x + x * y == y * x + abs (x * x) == x * x + x * negate y == negate (x * y) + abs (x * abs y) == abs (x * y) + negate x + y == negate (x + negate y) + abs x * abs y == abs (x * y) + abs (x + abs x) == x + abs x + abs x + abs x == abs (x + x) + abs (1 + abs x) == 1 + abs x + (x + y) + z == x + (y + z) + (x * y) * z == x * (y * z) + (x + x) * y == x * (y + y) + x * (y + 1) == x + x * y + + x <= abs x + 0 <= abs x + x <= x * x + x <= x + 1 + 0 <= x * x + negate x <= abs x +negate (abs x) <= x +negate (abs x) <= 0 + x <= x + abs y + x <= abs (x + x) + abs x <= x * x +negate (x * x) <= x +negate (abs x) <= negate x + x <= 1 + abs x + 0 <= x + abs x +negate (x * x) <= 0 + x + negate 1 <= x + abs x <= abs (x + x) +negate (x * x) <= negate x +negate (x + 1) <= negate x + x + y <= x + abs y + x * abs x <= x * x +negate (x * x) <= negate (abs x) + x * abs y <= abs (x * y) + x + negate y <= x + abs y + x + abs x <= abs (x + x) +negate (x * x) <= x * abs x + abs (x + 1) <= 1 + abs x + diff --git a/tests/model/arith-s4.out b/tests/model/arith-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/arith-s4.out @@ -0,0 +1,23 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +(+) :: Int -> Int -> Int +(*) :: Int -> Int -> Int + +x + 0 == x +x * 1 == x +x * 0 == 0 +x + y == y + x +x * y == y * x + +x <= x * x +x <= x + 1 +0 <= x * x + diff --git a/tests/model/arith.out b/tests/model/arith.out new file mode 100644 --- /dev/null +++ b/tests/model/arith.out @@ -0,0 +1,27 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +(+) :: Int -> Int -> Int +(*) :: Int -> Int -> Int + + x + 0 == x + x * 1 == x + x * 0 == 0 + x + y == y + x + x * y == y * x +(x + y) + z == x + (y + z) +(x * y) * z == x * (y * z) +(x + x) * y == x * (y + y) +x * (y + 1) == x + x * y + +x <= x * x +x <= x + 1 +0 <= x * x + diff --git a/tests/model/arithficial-s4.out b/tests/model/arithficial-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/arithficial-s4.out @@ -0,0 +1,26 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +id :: Int -> Int +(+) :: Int -> Int -> Int +f :: Int -> Int -> Int +g :: Int -> Int -> Int +h :: Int -> Int -> Int + + id x == x +x + 0 == x +g x y == g z x' +f x y == f x z +h x y == h z y +x + y == y + x + +x <= g y y +x <= f 0 y +x <= h y 0 + diff --git a/tests/model/arithficial.out b/tests/model/arithficial.out new file mode 100644 --- /dev/null +++ b/tests/model/arithficial.out @@ -0,0 +1,27 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +id :: Int -> Int +(+) :: Int -> Int -> Int +f :: Int -> Int -> Int +g :: Int -> Int -> Int +h :: Int -> Int -> Int + + id x == x + x + 0 == x + g x y == g z x' + f x y == f x z + h x y == h z y + x + y == y + x +(x + y) + z == x + (y + z) + +x <= g y y +x <= f 0 y +x <= h y 0 + diff --git a/tests/model/binarytree-s4.out b/tests/model/binarytree-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/binarytree-s4.out @@ -0,0 +1,41 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Word2 (holes: Word2) +_ :: BT Word2 (holes: BT Word2) +_ :: [Word2] (holes: [Word2]) +Null :: BT Word2 +insert :: Word2 -> BT Word2 -> BT Word2 +delete :: Word2 -> BT Word2 -> BT Word2 +isIn :: Word2 -> BT Word2 -> Bool +(<=) :: Word2 -> Word2 -> Bool +(/=) :: Word2 -> Word2 -> Bool +ordered :: [Word2] -> Bool +strictlyOrdered :: [Word2] -> Bool +toList :: BT Word2 -> [Word2] +fromList :: [Word2] -> BT Word2 +isSearch :: BT Word2 -> Bool +[] :: [Word2] +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Word2 -> Word2 -> Bool +(==) :: BT Word2 -> BT Word2 -> Bool +(==) :: [Word2] -> [Word2] -> Bool + + isIn x Null == False + (xs == []) == (Null == fromList xs) +delete x Null == Null + + Null <= t + t <= insert x t + delete x t <= t +insert x Null <= insert x t + +isIn x t ==> insert x t == t + diff --git a/tests/model/binarytree.out b/tests/model/binarytree.out new file mode 100644 --- /dev/null +++ b/tests/model/binarytree.out @@ -0,0 +1,55 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Word2 (holes: Word2) +_ :: BT Word2 (holes: BT Word2) +_ :: [Word2] (holes: [Word2]) +Null :: BT Word2 +insert :: Word2 -> BT Word2 -> BT Word2 +delete :: Word2 -> BT Word2 -> BT Word2 +isIn :: Word2 -> BT Word2 -> Bool +(<=) :: Word2 -> Word2 -> Bool +(/=) :: Word2 -> Word2 -> Bool +ordered :: [Word2] -> Bool +strictlyOrdered :: [Word2] -> Bool +toList :: BT Word2 -> [Word2] +fromList :: [Word2] -> BT Word2 +isSearch :: BT Word2 -> Bool +[] :: [Word2] +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Word2 -> Word2 -> Bool +(==) :: BT Word2 -> BT Word2 -> Bool +(==) :: [Word2] -> [Word2] -> Bool + + isIn x Null == False + isIn x (insert x t) == True + isIn x (delete x t) == False + (Null == insert x t) == False + (xs == []) == (Null == fromList xs) + (t == insert x t) == isIn x t + (x == y) == isIn x (insert y Null) + (t == delete x t) == (False == isIn x t) +isIn x (insert y Null) == isIn y (insert x Null) + (False == (x /= y)) == isIn x (insert y Null) + delete x Null == Null + insert x (insert x t) == insert x t + delete x (delete x t) == delete x t + insert x (delete x t) == insert x t + delete x (insert x t) == delete x t + insert x (insert y t) == insert y (insert x t) + delete x (delete y t) == delete y (delete x t) + + Null <= t + t <= insert x t + delete x t <= t +insert x Null <= insert x t + +x /= y ==> delete y (insert x t) == insert x (delete y t) + diff --git a/tests/model/binarytree0-s4.out b/tests/model/binarytree0-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/binarytree0-s4.out @@ -0,0 +1,31 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Word2 (holes: Word2) +_ :: BT Word2 (holes: BT Word2) +Null :: BT Word2 +insert :: Word2 -> BT Word2 -> BT Word2 +delete :: Word2 -> BT Word2 -> BT Word2 +isIn :: Word2 -> BT Word2 -> Bool +(/=) :: Word2 -> Word2 -> Bool +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Word2 -> Word2 -> Bool +(==) :: BT Word2 -> BT Word2 -> Bool + + isIn x Null == False +delete x Null == Null + + Null <= t + t <= insert x t + delete x t <= t +insert x Null <= insert x t + +isIn x t ==> insert x t == t + diff --git a/tests/model/binarytree0.out b/tests/model/binarytree0.out new file mode 100644 --- /dev/null +++ b/tests/model/binarytree0.out @@ -0,0 +1,45 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Word2 (holes: Word2) +_ :: BT Word2 (holes: BT Word2) +Null :: BT Word2 +insert :: Word2 -> BT Word2 -> BT Word2 +delete :: Word2 -> BT Word2 -> BT Word2 +isIn :: Word2 -> BT Word2 -> Bool +(/=) :: Word2 -> Word2 -> Bool +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Word2 -> Word2 -> Bool +(==) :: BT Word2 -> BT Word2 -> Bool + + isIn x Null == False + isIn x (insert x t) == True + isIn x (delete x t) == False + (Null == insert x t) == False + (t == insert x t) == isIn x t + (x == y) == isIn x (insert y Null) + (t == delete x t) == (False == isIn x t) +isIn x (insert y Null) == isIn y (insert x Null) + (False == (x /= y)) == isIn x (insert y Null) + delete x Null == Null + insert x (insert x t) == insert x t + delete x (delete x t) == delete x t + insert x (delete x t) == insert x t + delete x (insert x t) == delete x t + insert x (insert y t) == insert y (insert x t) + delete x (delete y t) == delete y (delete x t) + + Null <= t + t <= insert x t + delete x t <= t +insert x Null <= insert x t + +x /= y ==> delete y (insert x t) == insert x (delete y t) + diff --git a/tests/model/bool-c-s4.out b/tests/model/bool-c-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/bool-c-s4.out @@ -0,0 +1,124 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +False :: Bool +True :: Bool +not :: Bool -> Bool +(&&) :: Bool -> Bool -> Bool +(||) :: Bool -> Bool -> Bool +(==) :: Bool -> Bool -> Bool + + +_ :: Bool (holes: Bool) +False :: Bool +True :: Bool +not _ :: Bool (holes: Bool) +_ && _ :: Bool (holes: Bool, Bool) +_ || _ :: Bool (holes: Bool, Bool) +_ == _ :: Bool (holes: Bool, Bool) +not (_ && _) :: Bool (holes: Bool, Bool) +not (_ || _) :: Bool (holes: Bool, Bool) +not (_ == _) :: Bool (holes: Bool, Bool) +_ && not _ :: Bool (holes: Bool, Bool) +_ || not _ :: Bool (holes: Bool, Bool) +_ && (_ && _) :: Bool (holes: Bool, Bool, Bool) +_ && (_ || _) :: Bool (holes: Bool, Bool, Bool) +_ && _ == _ :: Bool (holes: Bool, Bool, Bool) +_ || _ && _ :: Bool (holes: Bool, Bool, Bool) +_ || (_ || _) :: Bool (holes: Bool, Bool, Bool) +_ || _ == _ :: Bool (holes: Bool, Bool, Bool) +_ == (_ && _) :: Bool (holes: Bool, Bool, Bool) +_ == (_ || _) :: Bool (holes: Bool, Bool, Bool) +_ == (_ == _) :: Bool (holes: Bool, Bool, Bool) + +p :: Bool +False :: Bool +True :: Bool +not p :: Bool + +p :: Bool +q :: Bool +False :: Bool +True :: Bool +not p :: Bool +not q :: Bool +p && q :: Bool +p || q :: Bool +p == q :: Bool +not (p && q) :: Bool +not (p || q) :: Bool +not (p == q) :: Bool +p && not q :: Bool +q && not p :: Bool +p || not q :: Bool +q || not p :: Bool + +p :: Bool +q :: Bool +r :: Bool +False :: Bool +True :: Bool +not p :: Bool +not q :: Bool +not r :: Bool +p && q :: Bool +p && r :: Bool +q && r :: Bool +p || q :: Bool +p || r :: Bool +q || r :: Bool +p == q :: Bool +p == r :: Bool +q == r :: Bool +not (p && q) :: Bool +not (p && r) :: Bool +not (q && r) :: Bool +not (p || q) :: Bool +not (p || r) :: Bool +not (q || r) :: Bool +not (p == q) :: Bool +not (p == r) :: Bool +not (q == r) :: Bool +p && not q :: Bool +p && not r :: Bool +q && not p :: Bool +q && not r :: Bool +r && not p :: Bool +r && not q :: Bool +p || not q :: Bool +p || not r :: Bool +q || not p :: Bool +q || not r :: Bool +r || not p :: Bool +r || not q :: Bool +p && (q && r) :: Bool +p && (q || r) :: Bool +q && (p || r) :: Bool +r && (p || q) :: Bool +p && q == r :: Bool +q && p == r :: Bool +r && p == q :: Bool +p || q && r :: Bool +q || p && r :: Bool +r || p && q :: Bool +p || (q || r) :: Bool +p || q == r :: Bool +q || p == r :: Bool +r || p == q :: Bool +p == (q && r) :: Bool +q == (p && r) :: Bool +r == (p && q) :: Bool +p == (q || r) :: Bool +q == (p || r) :: Bool +r == (p || q) :: Bool +p == (q == r) :: Bool + +Number of Eq schema classes: 21 +Number of Eq 1-var classes: 4 +Number of Eq 2-var classes: 16 +Number of Eq 3-var classes: 59 diff --git a/tests/model/bool-c.out b/tests/model/bool-c.out new file mode 100644 --- /dev/null +++ b/tests/model/bool-c.out @@ -0,0 +1,124 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +False :: Bool +True :: Bool +not :: Bool -> Bool +(&&) :: Bool -> Bool -> Bool +(||) :: Bool -> Bool -> Bool +(==) :: Bool -> Bool -> Bool + + +_ :: Bool (holes: Bool) +False :: Bool +True :: Bool +not _ :: Bool (holes: Bool) +_ && _ :: Bool (holes: Bool, Bool) +_ || _ :: Bool (holes: Bool, Bool) +_ == _ :: Bool (holes: Bool, Bool) +not (_ && _) :: Bool (holes: Bool, Bool) +not (_ || _) :: Bool (holes: Bool, Bool) +not (_ == _) :: Bool (holes: Bool, Bool) +_ && not _ :: Bool (holes: Bool, Bool) +_ || not _ :: Bool (holes: Bool, Bool) +_ && (_ && _) :: Bool (holes: Bool, Bool, Bool) +_ && (_ || _) :: Bool (holes: Bool, Bool, Bool) +_ && _ == _ :: Bool (holes: Bool, Bool, Bool) +_ || _ && _ :: Bool (holes: Bool, Bool, Bool) +_ || (_ || _) :: Bool (holes: Bool, Bool, Bool) +_ || _ == _ :: Bool (holes: Bool, Bool, Bool) +_ == (_ && _) :: Bool (holes: Bool, Bool, Bool) +_ == (_ || _) :: Bool (holes: Bool, Bool, Bool) +_ == (_ == _) :: Bool (holes: Bool, Bool, Bool) + +p :: Bool +False :: Bool +True :: Bool +not p :: Bool + +p :: Bool +q :: Bool +False :: Bool +True :: Bool +not p :: Bool +not q :: Bool +p && q :: Bool +p || q :: Bool +p == q :: Bool +not (p && q) :: Bool +not (p || q) :: Bool +not (p == q) :: Bool +p && not q :: Bool +q && not p :: Bool +p || not q :: Bool +q || not p :: Bool + +p :: Bool +q :: Bool +r :: Bool +False :: Bool +True :: Bool +not p :: Bool +not q :: Bool +not r :: Bool +p && q :: Bool +p && r :: Bool +q && r :: Bool +p || q :: Bool +p || r :: Bool +q || r :: Bool +p == q :: Bool +p == r :: Bool +q == r :: Bool +not (p && q) :: Bool +not (p && r) :: Bool +not (q && r) :: Bool +not (p || q) :: Bool +not (p || r) :: Bool +not (q || r) :: Bool +not (p == q) :: Bool +not (p == r) :: Bool +not (q == r) :: Bool +p && not q :: Bool +p && not r :: Bool +q && not p :: Bool +q && not r :: Bool +r && not p :: Bool +r && not q :: Bool +p || not q :: Bool +p || not r :: Bool +q || not p :: Bool +q || not r :: Bool +r || not p :: Bool +r || not q :: Bool +p && (q && r) :: Bool +p && (q || r) :: Bool +q && (p || r) :: Bool +r && (p || q) :: Bool +p && q == r :: Bool +q && p == r :: Bool +r && p == q :: Bool +p || q && r :: Bool +q || p && r :: Bool +r || p && q :: Bool +p || (q || r) :: Bool +p || q == r :: Bool +q || p == r :: Bool +r || p == q :: Bool +p == (q && r) :: Bool +q == (p && r) :: Bool +r == (p && q) :: Bool +p == (q || r) :: Bool +q == (p || r) :: Bool +r == (p || q) :: Bool +p == (q == r) :: Bool + +Number of Eq schema classes: 21 +Number of Eq 1-var classes: 4 +Number of Eq 2-var classes: 16 +Number of Eq 3-var classes: 59 diff --git a/tests/model/bool-s4.out b/tests/model/bool-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/bool-s4.out @@ -0,0 +1,38 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +False :: Bool +True :: Bool +not :: Bool -> Bool +(&&) :: Bool -> Bool -> Bool +(||) :: Bool -> Bool -> Bool +(==) :: Bool -> Bool -> Bool + + (p && p) == p + (p || p) == p + not (not p) == p + (p && True) == p +(p || False) == p + (p == p) == True + (p == True) == p +(p && False) == False + (p || True) == True +(p && not p) == False +(p || not p) == True +(p == False) == not p + (p && q) == (q && p) + (p || q) == (q || p) +(p == not q) == not (p == q) + + p ==> True + False ==> p + p ==> p || q +p && q ==> p +p && q ==> p == q + + diff --git a/tests/model/bool.out b/tests/model/bool.out new file mode 100644 --- /dev/null +++ b/tests/model/bool.out @@ -0,0 +1,55 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +False :: Bool +True :: Bool +not :: Bool -> Bool +(&&) :: Bool -> Bool -> Bool +(||) :: Bool -> Bool -> Bool +(==) :: Bool -> Bool -> Bool + + (p && p) == p + (p || p) == p + not (not p) == p + (p && True) == p + (p || False) == p + (p == p) == True + (p == True) == p + (p && False) == False + (p || True) == True + (p && not p) == False + (p == False) == not p + (p && q) == (q && p) + (p || q) == (q || p) +(p && (p || q)) == p + (p || p && q) == p + (p && p == q) == (p && q) + (p == not q) == not (p == q) + not (p || q) == (not p && not q) + (p || not q) == not (q && not p) +((p && q) && r) == (p && (q && r)) +((p || q) || r) == (p || (q || r)) +(p == (p && q)) == not (p && not q) + (p || p == q) == not (q && not p) +(p == (p || q)) == not (q && not p) + + p ==> True + False ==> p + p ==> p || q + p && q ==> p + p && q ==> p == q + not p ==> not (p && q) +not (p || q) ==> p == q +not (p == q) ==> p || q + p && not q ==> q || p + p == q ==> p || not q + p && not q ==> not (q && p) +not (p == q) ==> not (p && q) + p && not q ==> not (p == q) + + diff --git a/tests/model/colour-s4.out b/tests/model/colour-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/colour-s4.out @@ -0,0 +1,88 @@ +max expr size = 4 + |- on ineqs = 2 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Colour (holes: Colour) +_ :: Maybe (Ratio Integer) (holes: Maybe (Ratio Integer)) +_ :: Ratio Integer (holes: Ratio Integer) +(+) :: Colour -> Colour -> Colour +(-) :: Colour -> Colour -> Colour +chroma :: Colour -> Ratio Integer +hue :: Colour -> Maybe (Ratio Integer) +saturation :: Colour -> Ratio Integer +value :: Colour -> Ratio Integer +lightness :: Colour -> Ratio Integer +fromHSV :: Ratio Integer -> Ratio Integer -> Ratio Integer -> Colour +fromHSL :: Ratio Integer -> Ratio Integer -> Ratio Integer -> Colour +mix :: Colour -> Colour -> Colour +black :: Colour +white :: Colour +red :: Colour +grey :: Colour +green :: Colour +blue :: Colour +Just :: Ratio Integer -> Maybe (Ratio Integer) +Nothing :: Maybe (Ratio Integer) +0 % 1 :: Ratio Integer +1 % 1 :: Ratio Integer +1 % 2 :: Ratio Integer + +Warning: (<=) :: Colour -> Colour -> Bool is not an ordering (not antisymmetric) +Warning: (==) and (<=) :: Colour -> Colour -> Bool are inconsistent: (x == y) /= (x <= y && y <= x) + + mix c c == c + c + black == c + c - c == black + c - black == c + c + white == white + black - c == black + c - white == black + fromHSV q r (0 % 1) == black + fromHSL q r (0 % 1) == black + fromHSL q r (1 % 1) == white +fromHSL q (0 % 1) (1 % 2) == grey + c + d == d + c + mix c d == mix d c + fromHSL q (0 % 1) r == fromHSL s (0 % 1) r + fromHSV q (0 % 1) r == fromHSL s (0 % 1) r + fromHSV (1 % 1) q r == fromHSV (0 % 1) q r + fromHSL (1 % 1) q r == fromHSL (0 % 1) q r +fromHSL q (1 % 1) (1 % 2) == fromHSV q (1 % 1) (1 % 1) + hue (mix c black) == hue c + hue (mix c white) == hue c + hue (mix c grey) == hue c + hue (c + c) == hue (c + grey) + value (c + red) == 1 % 1 + value (c + green) == 1 % 1 + value (c + blue) == 1 % 1 + chroma (white - c) == chroma c + saturation (mix c black) == saturation c + chroma (grey - c) == chroma (c + grey) + chroma (mix c white) == chroma (mix c black) + chroma (mix c grey) == chroma (mix c black) + saturation (c + red) == chroma (c + red) + saturation (c + green) == chroma (c + green) + saturation (c + blue) == chroma (c + blue) + value (c - red) == chroma (c - red) + value (c - green) == chroma (c - green) + value (c - blue) == chroma (c - blue) + value (red - c) == chroma (red - c) + value (green - c) == chroma (green - c) + value (blue - c) == chroma (blue - c) + + hue c <= Just (1 % 1) + 0 % 1 <= chroma c + 0 % 1 <= saturation c + 0 % 1 <= value c + 0 % 1 <= lightness c + chroma c <= 1 % 1 +saturation c <= 1 % 1 + value c <= 1 % 1 + lightness c <= 1 % 1 + chroma c <= saturation c + chroma c <= value c + lightness c <= value c + diff --git a/tests/model/colour.out b/tests/model/colour.out new file mode 100644 --- /dev/null +++ b/tests/model/colour.out @@ -0,0 +1,88 @@ +max expr size = 4 + |- on ineqs = 2 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Colour (holes: Colour) +_ :: Maybe (Ratio Integer) (holes: Maybe (Ratio Integer)) +_ :: Ratio Integer (holes: Ratio Integer) +(+) :: Colour -> Colour -> Colour +(-) :: Colour -> Colour -> Colour +chroma :: Colour -> Ratio Integer +hue :: Colour -> Maybe (Ratio Integer) +saturation :: Colour -> Ratio Integer +value :: Colour -> Ratio Integer +lightness :: Colour -> Ratio Integer +fromHSV :: Ratio Integer -> Ratio Integer -> Ratio Integer -> Colour +fromHSL :: Ratio Integer -> Ratio Integer -> Ratio Integer -> Colour +mix :: Colour -> Colour -> Colour +black :: Colour +white :: Colour +red :: Colour +grey :: Colour +green :: Colour +blue :: Colour +Just :: Ratio Integer -> Maybe (Ratio Integer) +Nothing :: Maybe (Ratio Integer) +0 % 1 :: Ratio Integer +1 % 1 :: Ratio Integer +1 % 2 :: Ratio Integer + +Warning: (<=) :: Colour -> Colour -> Bool is not an ordering (not antisymmetric) +Warning: (==) and (<=) :: Colour -> Colour -> Bool are inconsistent: (x == y) /= (x <= y && y <= x) + + mix c c == c + c + black == c + c - c == black + c - black == c + c + white == white + black - c == black + c - white == black + fromHSV q r (0 % 1) == black + fromHSL q r (0 % 1) == black + fromHSL q r (1 % 1) == white +fromHSL q (0 % 1) (1 % 2) == grey + c + d == d + c + mix c d == mix d c + fromHSL q (0 % 1) r == fromHSL s (0 % 1) r + fromHSV q (0 % 1) r == fromHSL s (0 % 1) r + fromHSV (1 % 1) q r == fromHSV (0 % 1) q r + fromHSL (1 % 1) q r == fromHSL (0 % 1) q r +fromHSL q (1 % 1) (1 % 2) == fromHSV q (1 % 1) (1 % 1) + hue (mix c black) == hue c + hue (mix c white) == hue c + hue (mix c grey) == hue c + hue (c + c) == hue (c + grey) + value (c + red) == 1 % 1 + value (c + green) == 1 % 1 + value (c + blue) == 1 % 1 + chroma (white - c) == chroma c + saturation (mix c black) == saturation c + chroma (grey - c) == chroma (c + grey) + chroma (mix c white) == chroma (mix c black) + chroma (mix c grey) == chroma (mix c black) + saturation (c + red) == chroma (c + red) + saturation (c + green) == chroma (c + green) + saturation (c + blue) == chroma (c + blue) + value (c - red) == chroma (c - red) + value (c - green) == chroma (c - green) + value (c - blue) == chroma (c - blue) + value (red - c) == chroma (red - c) + value (green - c) == chroma (green - c) + value (blue - c) == chroma (blue - c) + + hue c <= Just (1 % 1) + 0 % 1 <= chroma c + 0 % 1 <= saturation c + 0 % 1 <= value c + 0 % 1 <= lightness c + chroma c <= 1 % 1 +saturation c <= 1 % 1 + value c <= 1 % 1 + lightness c <= 1 % 1 + chroma c <= saturation c + chroma c <= value c + lightness c <= value c + diff --git a/tests/model/digraphs-s4.out b/tests/model/digraphs-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/digraphs-s4.out @@ -0,0 +1,41 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Nat (holes: Nat) +_ :: Digraph Nat (holes: Digraph Nat) +_ :: [Nat] (holes: [Nat]) +[] :: [Nat] +elem :: Nat -> [Nat] -> Bool +empty :: Digraph Nat +addNode :: Nat -> Digraph Nat -> Digraph Nat +addEdge :: Nat -> Nat -> Digraph Nat -> Digraph Nat +isNode :: Nat -> Digraph Nat -> Bool +isEdge :: Nat -> Nat -> Digraph Nat -> Bool +isPath :: Nat -> Nat -> Digraph Nat -> Bool +subgraph :: [Nat] -> Digraph Nat -> Digraph Nat +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Nat -> Nat -> Bool +(==) :: Digraph Nat -> Digraph Nat -> Bool +(==) :: [Nat] -> [Nat] -> Bool + + isNode x empty == False + isEdge x y empty == False + isPath x y empty == False + isPath x x a == isNode x a +subgraph xs empty == empty + subgraph [] a == empty + + empty <= a + a <= addNode x a + subgraph xs a <= a +addNode x empty <= addNode x a + +isNode x a ==> addNode x a == a + diff --git a/tests/model/digraphs.out b/tests/model/digraphs.out new file mode 100644 --- /dev/null +++ b/tests/model/digraphs.out @@ -0,0 +1,59 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Nat (holes: Nat) +_ :: Digraph Nat (holes: Digraph Nat) +_ :: [Nat] (holes: [Nat]) +[] :: [Nat] +elem :: Nat -> [Nat] -> Bool +empty :: Digraph Nat +addNode :: Nat -> Digraph Nat -> Digraph Nat +addEdge :: Nat -> Nat -> Digraph Nat -> Digraph Nat +isNode :: Nat -> Digraph Nat -> Bool +isEdge :: Nat -> Nat -> Digraph Nat -> Bool +isPath :: Nat -> Nat -> Digraph Nat -> Bool +subgraph :: [Nat] -> Digraph Nat -> Digraph Nat +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Nat -> Nat -> Bool +(==) :: Digraph Nat -> Digraph Nat -> Bool +(==) :: [Nat] -> [Nat] -> Bool + + isNode x empty == False + isEdge x y empty == False + isPath x y empty == False + isNode x (addNode x a) == True + (empty == addNode x a) == False + isPath x x a == isNode x a + (a == addNode x a) == isNode x a + (x == y) == isNode x (addNode y empty) + isNode x (addNode y empty) == isNode y (addNode x empty) + subgraph xs empty == empty + subgraph [] a == empty + addNode x (addNode x a) == addNode x a +subgraph xs (subgraph xs a) == subgraph xs a + addNode x (addNode y a) == addNode y (addNode x a) +subgraph xs (subgraph ys a) == subgraph ys (subgraph xs a) + + isEdge x y a ==> isNode x a + isEdge x y a ==> isNode y a + isPath x y a ==> isNode x a + isPath x y a ==> isNode y a + isEdge x y a ==> isPath x y a + empty <= a + a <= addNode x a + subgraph xs a <= a + a <= addEdge x y a + addNode x empty <= addNode x a + addNode x a <= addEdge x y a +addEdge x y empty <= addEdge x y a + + elem x xs ==> subgraph xs (addNode x a) == addNode x (subgraph xs a) +isEdge x y a ==> addEdge x y a == a + diff --git a/tests/model/fun-s4.out b/tests/model/fun-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/fun-s4.out @@ -0,0 +1,21 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 1000 +min #-tests = 50 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +_ :: Int -> Int (holes: Int -> Int) +map :: (Int -> Int) -> [Int] -> [Int] +id :: Int -> Int +(.) :: (Int -> Int) -> (Int -> Int) -> Int -> Int + + id x == x + f (g x) == (f . g) x +map id xs == xs + f . id == f + id . f == f + + diff --git a/tests/model/fun.out b/tests/model/fun.out new file mode 100644 --- /dev/null +++ b/tests/model/fun.out @@ -0,0 +1,23 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 1000 +min #-tests = 50 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +_ :: Int -> Int (holes: Int -> Int) +map :: (Int -> Int) -> [Int] -> [Int] +id :: Int -> Int +(.) :: (Int -> Int) -> (Int -> Int) -> Int -> Int + + id x == x + f (g x) == (f . g) x + map id xs == xs +map (f . g) xs == map f (map g xs) + f . id == f + id . f == f + (f . g) . h == f . (g . h) + + diff --git a/tests/model/insertsort-s4.out b/tests/model/insertsort-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/insertsort-s4.out @@ -0,0 +1,41 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +False :: Bool +True :: Bool +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +elem :: Int -> [Int] -> Bool +ordered :: [Int] -> Bool +all :: (Int -> Bool) -> [Int] -> Bool +insert :: Int -> [Int] -> [Int] +sort :: [Int] -> [Int] +(==) :: Int -> Int -> Bool +(<=) :: Int -> Int -> Bool +(<) :: Int -> Int -> Bool +(==) :: Bool -> Bool -> Bool +(==) :: [Int] -> [Int] -> Bool + + ordered (sort xs) == True +ordered (insert x xs) == ordered xs + (xs == sort xs) == ordered xs + elem x (sort xs) == elem x xs + (sort xs == []) == (xs == []) + sort (sort xs) == sort xs + insert x [] == [x] + sort (xs ++ ys) == sort (ys ++ xs) + sort (insert x xs) == insert x (sort xs) + sort (x:xs) == insert x (sort xs) + + sort xs <= xs +insert x xs <= x:xs + + diff --git a/tests/model/insertsort.out b/tests/model/insertsort.out new file mode 100644 --- /dev/null +++ b/tests/model/insertsort.out @@ -0,0 +1,71 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +False :: Bool +True :: Bool +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +elem :: Int -> [Int] -> Bool +ordered :: [Int] -> Bool +all :: (Int -> Bool) -> [Int] -> Bool +insert :: Int -> [Int] -> [Int] +sort :: [Int] -> [Int] +(==) :: Int -> Int -> Bool +(<=) :: Int -> Int -> Bool +(<) :: Int -> Int -> Bool +(==) :: Bool -> Bool -> Bool +(==) :: [Int] -> [Int] -> Bool + + ordered (sort xs) == True + ordered (insert x xs) == ordered xs + (xs == insert x xs) == False + ([] == insert x xs) == False + (xs == sort xs) == ordered xs + elem x (sort xs) == elem x xs + (sort xs == []) == (xs == []) + all (x ==) (sort xs) == all (x ==) xs + all (x <) (sort xs) == all (x <) xs + all (x <=) xs == ordered (x:sort xs) +ordered (xs ++ sort xs) == ordered (xs ++ xs) +ordered (sort xs ++ xs) == ordered (xs ++ xs) + elem x (insert y xs) == elem x (y:xs) + sort (sort xs) == sort xs + insert x [] == [x] + sort (xs ++ ys) == sort (ys ++ xs) + sort (insert x xs) == insert x (sort xs) + sort (x:xs) == insert x (sort xs) + sort (xs ++ sort ys) == sort (xs ++ ys) + insert x (insert y xs) == insert y (insert x xs) + insert x (x:xs) == x:x:xs + insert x [y] == insert y [x] + + xs == sort ys ==> ordered xs + sort xs <= xs + insert x xs <= x:xs + x:sort xs <= x:xs + xs ++ sort ys <= xs ++ ys + sort xs ++ ys <= xs ++ ys + sort (x:xs) <= insert x xs +sort (xs ++ ys) <= xs ++ sort ys +sort (xs ++ ys) <= sort xs ++ ys + sort xs ++ xs <= xs ++ sort xs + + x <= y ==> insert x (y:xs) == x:y:xs + x < y ==> insert y (x:xs) == x:insert y xs + elem x xs ==> insert x (xs ++ ys) == insert x xs ++ ys +ordered (ys ++ xs) ==> ys ++ sort xs == sort (xs ++ ys) +ordered (ys ++ xs) ==> sort ys ++ xs == sort (xs ++ ys) +ordered (ys ++ xs) ==> sort ys ++ sort xs == sort (xs ++ ys) + all (x <=) xs ==> insert x xs == x:xs + all (x <=) xs ==> x:sort xs == sort (x:xs) + all (x <=) xs ==> insert y (x:xs) == insert x (insert y xs) + all (x <=) ys ==> insert x (xs ++ ys) == insert x xs ++ ys + diff --git a/tests/model/insertsort0-s4.out b/tests/model/insertsort0-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/insertsort0-s4.out @@ -0,0 +1,30 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +insert :: Int -> [Int] -> [Int] +sort :: [Int] -> [Int] +(<=) :: Int -> Int -> Bool +(<) :: Int -> Int -> Bool +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Int -> Int -> Bool +(==) :: [Int] -> [Int] -> Bool + + (sort xs == []) == (xs == []) + sort [] == [] + sort (sort xs) == sort xs + insert x [] == [x] +sort (insert x xs) == insert x (sort xs) + sort (x:xs) == insert x (sort xs) + + diff --git a/tests/model/insertsort0.out b/tests/model/insertsort0.out new file mode 100644 --- /dev/null +++ b/tests/model/insertsort0.out @@ -0,0 +1,37 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +insert :: Int -> [Int] -> [Int] +sort :: [Int] -> [Int] +(<=) :: Int -> Int -> Bool +(<) :: Int -> Int -> Bool +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Int -> Int -> Bool +(==) :: [Int] -> [Int] -> Bool + + (xs == insert x xs) == False + ([] == insert x xs) == False + (sort xs == []) == (xs == []) + sort [] == [] + sort (sort xs) == sort xs + insert x [] == [x] + sort (insert x xs) == insert x (sort xs) + sort (x:xs) == insert x (sort xs) +insert x (insert y xs) == insert y (insert x xs) + insert x (x:xs) == x:x:xs + insert x [y] == insert y [x] + +x <= y ==> insert x (y:xs) == x:y:xs + x < y ==> insert y (x:xs) == x:insert y xs + diff --git a/tests/model/length-s4.out b/tests/model/length-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/length-s4.out @@ -0,0 +1,20 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +0 :: Int +length :: [Int] -> Int + + length (x:xs) == length (y:xs) +length (xs ++ ys) == length (ys ++ xs) + +0 <= length xs + diff --git a/tests/model/length.out b/tests/model/length.out new file mode 100644 --- /dev/null +++ b/tests/model/length.out @@ -0,0 +1,23 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +0 :: Int +length :: [Int] -> Int + + length (x:xs) == length (y:xs) +length (xs ++ ys) == length (ys ++ xs) + + 0 <= length xs + length xs <= length (x:xs) + length xs <= length (xs ++ ys) +length [x] <= length (x:xs) + diff --git a/tests/model/list-c-s4.out b/tests/model/list-c-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/list-c-s4.out @@ -0,0 +1,777 @@ +max expr size = 5 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +head :: [Int] -> Int +tail :: [Int] -> [Int] + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +head _ :: Int (holes: [Int]) +head [] :: Int +tail _ :: [Int] (holes: [Int]) +tail [] :: [Int] +head (tail _) :: Int (holes: [Int]) +head (tail []) :: Int +tail (tail _) :: [Int] (holes: [Int]) +tail (tail []) :: [Int] +_:_ :: [Int] (holes: Int, [Int]) +[_] :: [Int] (holes: Int) +_ ++ _ :: [Int] (holes: [Int], [Int]) +head (tail (tail _)) :: Int (holes: [Int]) +head (tail (tail [])) :: Int +head (_ ++ _) :: Int (holes: [Int], [Int]) +tail (tail (tail _)) :: [Int] (holes: [Int]) +tail (tail (tail [])) :: [Int] +tail (_ ++ _) :: [Int] (holes: [Int], [Int]) +_:tail _ :: [Int] (holes: Int, [Int]) +_:tail [] :: [Int] (holes: Int) +_ ++ tail _ :: [Int] (holes: [Int], [Int]) +_ ++ tail [] :: [Int] (holes: [Int]) +[] ++ tail _ :: [Int] (holes: [Int]) +[] ++ tail [] :: [Int] +head _:_ :: [Int] (holes: [Int], [Int]) +[head _] :: [Int] (holes: [Int]) +head []:_ :: [Int] (holes: [Int]) +[head []] :: [Int] +tail _ ++ _ :: [Int] (holes: [Int], [Int]) +tail _ ++ [] :: [Int] (holes: [Int]) +tail [] ++ _ :: [Int] (holes: [Int]) +tail [] ++ [] :: [Int] +head (tail (tail (tail _))) :: Int (holes: [Int]) +head (tail (tail (tail []))) :: Int +head (tail (_ ++ _)) :: Int (holes: [Int], [Int]) +head (_ ++ tail _) :: Int (holes: [Int], [Int]) +head (_ ++ tail []) :: Int (holes: [Int]) +head ([] ++ tail _) :: Int (holes: [Int]) +head ([] ++ tail []) :: Int +head (head _:_) :: Int (holes: [Int], [Int]) +head [head _] :: Int (holes: [Int]) +head (head []:_) :: Int (holes: [Int]) +head [head []] :: Int +head (tail _ ++ _) :: Int (holes: [Int], [Int]) +head (tail _ ++ []) :: Int (holes: [Int]) +head (tail [] ++ _) :: Int (holes: [Int]) +head (tail [] ++ []) :: Int +tail (tail (tail (tail _))) :: [Int] (holes: [Int]) +tail (tail (tail (tail []))) :: [Int] +tail (tail (_ ++ _)) :: [Int] (holes: [Int], [Int]) +tail (_:tail _) :: [Int] (holes: Int, [Int]) +tail (_:tail []) :: [Int] (holes: Int) +tail (_ ++ tail _) :: [Int] (holes: [Int], [Int]) +tail (_ ++ tail []) :: [Int] (holes: [Int]) +tail ([] ++ tail _) :: [Int] (holes: [Int]) +tail ([] ++ tail []) :: [Int] +tail (tail _ ++ _) :: [Int] (holes: [Int], [Int]) +tail (tail _ ++ []) :: [Int] (holes: [Int]) +tail (tail [] ++ _) :: [Int] (holes: [Int]) +tail (tail [] ++ []) :: [Int] +_:tail (tail _) :: [Int] (holes: Int, [Int]) +_:tail (tail []) :: [Int] (holes: Int) +_:_:_ :: [Int] (holes: Int, Int, [Int]) +[_,_] :: [Int] (holes: Int, Int) +_:(_ ++ _) :: [Int] (holes: Int, [Int], [Int]) +_ ++ tail (tail _) :: [Int] (holes: [Int], [Int]) +_ ++ tail (tail []) :: [Int] (holes: [Int]) +_ ++ (_:_) :: [Int] (holes: [Int], Int, [Int]) +_ ++ [_] :: [Int] (holes: [Int], Int) +_ ++ (_ ++ _) :: [Int] (holes: [Int], [Int], [Int]) +[] ++ tail (tail _) :: [Int] (holes: [Int]) +[] ++ tail (tail []) :: [Int] +head _:tail _ :: [Int] (holes: [Int], [Int]) +head _:tail [] :: [Int] (holes: [Int]) +head []:tail _ :: [Int] (holes: [Int]) +head []:tail [] :: [Int] +tail _ ++ tail _ :: [Int] (holes: [Int], [Int]) +tail _ ++ tail [] :: [Int] (holes: [Int]) +tail [] ++ tail _ :: [Int] (holes: [Int]) +tail [] ++ tail [] :: [Int] +head (tail _):_ :: [Int] (holes: [Int], [Int]) +[head (tail _)] :: [Int] (holes: [Int]) +head (tail []):_ :: [Int] (holes: [Int]) +[head (tail [])] :: [Int] +tail (tail _) ++ _ :: [Int] (holes: [Int], [Int]) +tail (tail _) ++ [] :: [Int] (holes: [Int]) +tail (tail []) ++ _ :: [Int] (holes: [Int]) +tail (tail []) ++ [] :: [Int] + +x :: Int +xs :: [Int] +[] :: [Int] +head xs :: Int +head [] :: Int +tail xs :: [Int] +tail [] :: [Int] +head (tail xs) :: Int +head (tail []) :: Int +tail (tail xs) :: [Int] +tail (tail []) :: [Int] +x:xs :: [Int] +[x] :: [Int] +xs ++ xs :: [Int] +head (tail (tail xs)) :: Int +head (tail (tail [])) :: Int +head (xs ++ xs) :: Int +tail (tail (tail xs)) :: [Int] +tail (tail (tail [])) :: [Int] +tail (xs ++ xs) :: [Int] +x:tail xs :: [Int] +x:tail [] :: [Int] +xs ++ tail xs :: [Int] +xs ++ tail [] :: [Int] +head xs:xs :: [Int] +[head xs] :: [Int] +head []:xs :: [Int] +[head []] :: [Int] +tail xs ++ xs :: [Int] +tail [] ++ xs :: [Int] +head (tail (tail (tail xs))) :: Int +head (tail (tail (tail []))) :: Int +head (tail (xs ++ xs)) :: Int +head (xs ++ tail xs) :: Int +head (xs ++ tail []) :: Int +head (tail xs ++ xs) :: Int +head (tail [] ++ xs) :: Int +tail (tail (tail (tail xs))) :: [Int] +tail (tail (tail (tail []))) :: [Int] +tail (tail (xs ++ xs)) :: [Int] +tail (xs ++ tail xs) :: [Int] +tail (xs ++ tail []) :: [Int] +tail (tail xs ++ xs) :: [Int] +tail (tail [] ++ xs) :: [Int] +x:tail (tail xs) :: [Int] +x:tail (tail []) :: [Int] +x:x:xs :: [Int] +[x,x] :: [Int] +x:(xs ++ xs) :: [Int] +xs ++ tail (tail xs) :: [Int] +xs ++ tail (tail []) :: [Int] +xs ++ (x:xs) :: [Int] +xs ++ [x] :: [Int] +xs ++ (xs ++ xs) :: [Int] +head xs:tail xs :: [Int] +head xs:tail [] :: [Int] +head []:tail xs :: [Int] +head []:tail [] :: [Int] +tail xs ++ tail xs :: [Int] +tail xs ++ tail [] :: [Int] +tail [] ++ tail xs :: [Int] +tail [] ++ tail [] :: [Int] +head (tail xs):xs :: [Int] +[head (tail xs)] :: [Int] +head (tail []):xs :: [Int] +[head (tail [])] :: [Int] +tail (tail xs) ++ xs :: [Int] +tail (tail []) ++ xs :: [Int] + +x :: Int +y :: Int +xs :: [Int] +ys :: [Int] +[] :: [Int] +head xs :: Int +head ys :: Int +head [] :: Int +tail xs :: [Int] +tail ys :: [Int] +tail [] :: [Int] +head (tail xs) :: Int +head (tail ys) :: Int +head (tail []) :: Int +tail (tail xs) :: [Int] +tail (tail ys) :: [Int] +tail (tail []) :: [Int] +x:xs :: [Int] +x:ys :: [Int] +y:xs :: [Int] +y:ys :: [Int] +[x] :: [Int] +[y] :: [Int] +xs ++ xs :: [Int] +xs ++ ys :: [Int] +ys ++ xs :: [Int] +ys ++ ys :: [Int] +head (tail (tail xs)) :: Int +head (tail (tail ys)) :: Int +head (tail (tail [])) :: Int +head (xs ++ xs) :: Int +head (xs ++ ys) :: Int +head (ys ++ xs) :: Int +head (ys ++ ys) :: Int +tail (tail (tail xs)) :: [Int] +tail (tail (tail ys)) :: [Int] +tail (tail (tail [])) :: [Int] +tail (xs ++ xs) :: [Int] +tail (xs ++ ys) :: [Int] +tail (ys ++ xs) :: [Int] +tail (ys ++ ys) :: [Int] +x:tail xs :: [Int] +x:tail ys :: [Int] +y:tail xs :: [Int] +y:tail ys :: [Int] +x:tail [] :: [Int] +y:tail [] :: [Int] +xs ++ tail xs :: [Int] +xs ++ tail ys :: [Int] +ys ++ tail xs :: [Int] +ys ++ tail ys :: [Int] +xs ++ tail [] :: [Int] +ys ++ tail [] :: [Int] +head xs:xs :: [Int] +head xs:ys :: [Int] +head ys:xs :: [Int] +head ys:ys :: [Int] +[head xs] :: [Int] +[head ys] :: [Int] +head []:xs :: [Int] +head []:ys :: [Int] +[head []] :: [Int] +tail xs ++ xs :: [Int] +tail xs ++ ys :: [Int] +tail ys ++ xs :: [Int] +tail ys ++ ys :: [Int] +tail [] ++ xs :: [Int] +tail [] ++ ys :: [Int] +head (tail (tail (tail xs))) :: Int +head (tail (tail (tail ys))) :: Int +head (tail (tail (tail []))) :: Int +head (tail (xs ++ xs)) :: Int +head (tail (xs ++ ys)) :: Int +head (tail (ys ++ xs)) :: Int +head (tail (ys ++ ys)) :: Int +head (xs ++ tail xs) :: Int +head (xs ++ tail ys) :: Int +head (ys ++ tail xs) :: Int +head (ys ++ tail ys) :: Int +head (xs ++ tail []) :: Int +head (ys ++ tail []) :: Int +head (tail xs ++ xs) :: Int +head (tail xs ++ ys) :: Int +head (tail ys ++ xs) :: Int +head (tail ys ++ ys) :: Int +head (tail [] ++ xs) :: Int +head (tail [] ++ ys) :: Int +tail (tail (tail (tail xs))) :: [Int] +tail (tail (tail (tail ys))) :: [Int] +tail (tail (tail (tail []))) :: [Int] +tail (tail (xs ++ xs)) :: [Int] +tail (tail (xs ++ ys)) :: [Int] +tail (tail (ys ++ xs)) :: [Int] +tail (tail (ys ++ ys)) :: [Int] +tail (xs ++ tail xs) :: [Int] +tail (xs ++ tail ys) :: [Int] +tail (ys ++ tail xs) :: [Int] +tail (ys ++ tail ys) :: [Int] +tail (xs ++ tail []) :: [Int] +tail (ys ++ tail []) :: [Int] +tail (tail xs ++ xs) :: [Int] +tail (tail xs ++ ys) :: [Int] +tail (tail ys ++ xs) :: [Int] +tail (tail ys ++ ys) :: [Int] +tail (tail [] ++ xs) :: [Int] +tail (tail [] ++ ys) :: [Int] +x:tail (tail xs) :: [Int] +x:tail (tail ys) :: [Int] +y:tail (tail xs) :: [Int] +y:tail (tail ys) :: [Int] +x:tail (tail []) :: [Int] +y:tail (tail []) :: [Int] +x:x:xs :: [Int] +x:x:ys :: [Int] +x:y:xs :: [Int] +x:y:ys :: [Int] +y:x:xs :: [Int] +y:x:ys :: [Int] +y:y:xs :: [Int] +y:y:ys :: [Int] +[x,x] :: [Int] +[x,y] :: [Int] +[y,x] :: [Int] +[y,y] :: [Int] +x:(xs ++ xs) :: [Int] +x:(xs ++ ys) :: [Int] +x:(ys ++ xs) :: [Int] +x:(ys ++ ys) :: [Int] +y:(xs ++ xs) :: [Int] +y:(xs ++ ys) :: [Int] +y:(ys ++ xs) :: [Int] +y:(ys ++ ys) :: [Int] +xs ++ tail (tail xs) :: [Int] +xs ++ tail (tail ys) :: [Int] +ys ++ tail (tail xs) :: [Int] +ys ++ tail (tail ys) :: [Int] +xs ++ tail (tail []) :: [Int] +ys ++ tail (tail []) :: [Int] +xs ++ (x:xs) :: [Int] +xs ++ (y:xs) :: [Int] +xs ++ (x:ys) :: [Int] +xs ++ (y:ys) :: [Int] +ys ++ (x:xs) :: [Int] +ys ++ (y:xs) :: [Int] +ys ++ (x:ys) :: [Int] +ys ++ (y:ys) :: [Int] +xs ++ [x] :: [Int] +xs ++ [y] :: [Int] +ys ++ [x] :: [Int] +ys ++ [y] :: [Int] +xs ++ (xs ++ xs) :: [Int] +xs ++ (xs ++ ys) :: [Int] +xs ++ (ys ++ xs) :: [Int] +xs ++ (ys ++ ys) :: [Int] +ys ++ (xs ++ xs) :: [Int] +ys ++ (xs ++ ys) :: [Int] +ys ++ (ys ++ xs) :: [Int] +ys ++ (ys ++ ys) :: [Int] +head xs:tail xs :: [Int] +head xs:tail ys :: [Int] +head ys:tail xs :: [Int] +head ys:tail ys :: [Int] +head xs:tail [] :: [Int] +head ys:tail [] :: [Int] +head []:tail xs :: [Int] +head []:tail ys :: [Int] +head []:tail [] :: [Int] +tail xs ++ tail xs :: [Int] +tail xs ++ tail ys :: [Int] +tail ys ++ tail xs :: [Int] +tail ys ++ tail ys :: [Int] +tail xs ++ tail [] :: [Int] +tail ys ++ tail [] :: [Int] +tail [] ++ tail xs :: [Int] +tail [] ++ tail ys :: [Int] +tail [] ++ tail [] :: [Int] +head (tail xs):xs :: [Int] +head (tail xs):ys :: [Int] +head (tail ys):xs :: [Int] +head (tail ys):ys :: [Int] +[head (tail xs)] :: [Int] +[head (tail ys)] :: [Int] +head (tail []):xs :: [Int] +head (tail []):ys :: [Int] +[head (tail [])] :: [Int] +tail (tail xs) ++ xs :: [Int] +tail (tail xs) ++ ys :: [Int] +tail (tail ys) ++ xs :: [Int] +tail (tail ys) ++ ys :: [Int] +tail (tail []) ++ xs :: [Int] +tail (tail []) ++ ys :: [Int] + +x :: Int +y :: Int +z :: Int +xs :: [Int] +ys :: [Int] +zs :: [Int] +[] :: [Int] +head xs :: Int +head ys :: Int +head zs :: Int +head [] :: Int +tail xs :: [Int] +tail ys :: [Int] +tail zs :: [Int] +tail [] :: [Int] +head (tail xs) :: Int +head (tail ys) :: Int +head (tail zs) :: Int +head (tail []) :: Int +tail (tail xs) :: [Int] +tail (tail ys) :: [Int] +tail (tail zs) :: [Int] +tail (tail []) :: [Int] +x:xs :: [Int] +x:ys :: [Int] +x:zs :: [Int] +y:xs :: [Int] +y:ys :: [Int] +y:zs :: [Int] +z:xs :: [Int] +z:ys :: [Int] +z:zs :: [Int] +[x] :: [Int] +[y] :: [Int] +[z] :: [Int] +xs ++ xs :: [Int] +xs ++ ys :: [Int] +xs ++ zs :: [Int] +ys ++ xs :: [Int] +ys ++ ys :: [Int] +ys ++ zs :: [Int] +zs ++ xs :: [Int] +zs ++ ys :: [Int] +zs ++ zs :: [Int] +head (tail (tail xs)) :: Int +head (tail (tail ys)) :: Int +head (tail (tail zs)) :: Int +head (tail (tail [])) :: Int +head (xs ++ xs) :: Int +head (xs ++ ys) :: Int +head (xs ++ zs) :: Int +head (ys ++ xs) :: Int +head (ys ++ ys) :: Int +head (ys ++ zs) :: Int +head (zs ++ xs) :: Int +head (zs ++ ys) :: Int +head (zs ++ zs) :: Int +tail (tail (tail xs)) :: [Int] +tail (tail (tail ys)) :: [Int] +tail (tail (tail zs)) :: [Int] +tail (tail (tail [])) :: [Int] +tail (xs ++ xs) :: [Int] +tail (xs ++ ys) :: [Int] +tail (xs ++ zs) :: [Int] +tail (ys ++ xs) :: [Int] +tail (ys ++ ys) :: [Int] +tail (ys ++ zs) :: [Int] +tail (zs ++ xs) :: [Int] +tail (zs ++ ys) :: [Int] +tail (zs ++ zs) :: [Int] +x:tail xs :: [Int] +x:tail ys :: [Int] +x:tail zs :: [Int] +y:tail xs :: [Int] +y:tail ys :: [Int] +y:tail zs :: [Int] +z:tail xs :: [Int] +z:tail ys :: [Int] +z:tail zs :: [Int] +x:tail [] :: [Int] +y:tail [] :: [Int] +z:tail [] :: [Int] +xs ++ tail xs :: [Int] +xs ++ tail ys :: [Int] +xs ++ tail zs :: [Int] +ys ++ tail xs :: [Int] +ys ++ tail ys :: [Int] +ys ++ tail zs :: [Int] +zs ++ tail xs :: [Int] +zs ++ tail ys :: [Int] +zs ++ tail zs :: [Int] +xs ++ tail [] :: [Int] +ys ++ tail [] :: [Int] +zs ++ tail [] :: [Int] +head xs:xs :: [Int] +head xs:ys :: [Int] +head xs:zs :: [Int] +head ys:xs :: [Int] +head ys:ys :: [Int] +head ys:zs :: [Int] +head zs:xs :: [Int] +head zs:ys :: [Int] +head zs:zs :: [Int] +[head xs] :: [Int] +[head ys] :: [Int] +[head zs] :: [Int] +head []:xs :: [Int] +head []:ys :: [Int] +head []:zs :: [Int] +[head []] :: [Int] +tail xs ++ xs :: [Int] +tail xs ++ ys :: [Int] +tail xs ++ zs :: [Int] +tail ys ++ xs :: [Int] +tail ys ++ ys :: [Int] +tail ys ++ zs :: [Int] +tail zs ++ xs :: [Int] +tail zs ++ ys :: [Int] +tail zs ++ zs :: [Int] +tail [] ++ xs :: [Int] +tail [] ++ ys :: [Int] +tail [] ++ zs :: [Int] +head (tail (tail (tail xs))) :: Int +head (tail (tail (tail ys))) :: Int +head (tail (tail (tail zs))) :: Int +head (tail (tail (tail []))) :: Int +head (tail (xs ++ xs)) :: Int +head (tail (xs ++ ys)) :: Int +head (tail (xs ++ zs)) :: Int +head (tail (ys ++ xs)) :: Int +head (tail (ys ++ ys)) :: Int +head (tail (ys ++ zs)) :: Int +head (tail (zs ++ xs)) :: Int +head (tail (zs ++ ys)) :: Int +head (tail (zs ++ zs)) :: Int +head (xs ++ tail xs) :: Int +head (xs ++ tail ys) :: Int +head (xs ++ tail zs) :: Int +head (ys ++ tail xs) :: Int +head (ys ++ tail ys) :: Int +head (ys ++ tail zs) :: Int +head (zs ++ tail xs) :: Int +head (zs ++ tail ys) :: Int +head (zs ++ tail zs) :: Int +head (xs ++ tail []) :: Int +head (ys ++ tail []) :: Int +head (zs ++ tail []) :: Int +head (tail xs ++ xs) :: Int +head (tail xs ++ ys) :: Int +head (tail xs ++ zs) :: Int +head (tail ys ++ xs) :: Int +head (tail ys ++ ys) :: Int +head (tail ys ++ zs) :: Int +head (tail zs ++ xs) :: Int +head (tail zs ++ ys) :: Int +head (tail zs ++ zs) :: Int +head (tail [] ++ xs) :: Int +head (tail [] ++ ys) :: Int +head (tail [] ++ zs) :: Int +tail (tail (tail (tail xs))) :: [Int] +tail (tail (tail (tail ys))) :: [Int] +tail (tail (tail (tail zs))) :: [Int] +tail (tail (tail (tail []))) :: [Int] +tail (tail (xs ++ xs)) :: [Int] +tail (tail (xs ++ ys)) :: [Int] +tail (tail (xs ++ zs)) :: [Int] +tail (tail (ys ++ xs)) :: [Int] +tail (tail (ys ++ ys)) :: [Int] +tail (tail (ys ++ zs)) :: [Int] +tail (tail (zs ++ xs)) :: [Int] +tail (tail (zs ++ ys)) :: [Int] +tail (tail (zs ++ zs)) :: [Int] +tail (xs ++ tail xs) :: [Int] +tail (xs ++ tail ys) :: [Int] +tail (xs ++ tail zs) :: [Int] +tail (ys ++ tail xs) :: [Int] +tail (ys ++ tail ys) :: [Int] +tail (ys ++ tail zs) :: [Int] +tail (zs ++ tail xs) :: [Int] +tail (zs ++ tail ys) :: [Int] +tail (zs ++ tail zs) :: [Int] +tail (xs ++ tail []) :: [Int] +tail (ys ++ tail []) :: [Int] +tail (zs ++ tail []) :: [Int] +tail (tail xs ++ xs) :: [Int] +tail (tail xs ++ ys) :: [Int] +tail (tail xs ++ zs) :: [Int] +tail (tail ys ++ xs) :: [Int] +tail (tail ys ++ ys) :: [Int] +tail (tail ys ++ zs) :: [Int] +tail (tail zs ++ xs) :: [Int] +tail (tail zs ++ ys) :: [Int] +tail (tail zs ++ zs) :: [Int] +tail (tail [] ++ xs) :: [Int] +tail (tail [] ++ ys) :: [Int] +tail (tail [] ++ zs) :: [Int] +x:tail (tail xs) :: [Int] +x:tail (tail ys) :: [Int] +x:tail (tail zs) :: [Int] +y:tail (tail xs) :: [Int] +y:tail (tail ys) :: [Int] +y:tail (tail zs) :: [Int] +z:tail (tail xs) :: [Int] +z:tail (tail ys) :: [Int] +z:tail (tail zs) :: [Int] +x:tail (tail []) :: [Int] +y:tail (tail []) :: [Int] +z:tail (tail []) :: [Int] +x:x:xs :: [Int] +x:x:ys :: [Int] +x:x:zs :: [Int] +x:y:xs :: [Int] +x:y:ys :: [Int] +x:y:zs :: [Int] +x:z:xs :: [Int] +x:z:ys :: [Int] +x:z:zs :: [Int] +y:x:xs :: [Int] +y:x:ys :: [Int] +y:x:zs :: [Int] +y:y:xs :: [Int] +y:y:ys :: [Int] +y:y:zs :: [Int] +y:z:xs :: [Int] +y:z:ys :: [Int] +y:z:zs :: [Int] +z:x:xs :: [Int] +z:x:ys :: [Int] +z:x:zs :: [Int] +z:y:xs :: [Int] +z:y:ys :: [Int] +z:y:zs :: [Int] +z:z:xs :: [Int] +z:z:ys :: [Int] +z:z:zs :: [Int] +[x,x] :: [Int] +[x,y] :: [Int] +[x,z] :: [Int] +[y,x] :: [Int] +[y,y] :: [Int] +[y,z] :: [Int] +[z,x] :: [Int] +[z,y] :: [Int] +[z,z] :: [Int] +x:(xs ++ xs) :: [Int] +x:(xs ++ ys) :: [Int] +x:(xs ++ zs) :: [Int] +x:(ys ++ xs) :: [Int] +x:(ys ++ ys) :: [Int] +x:(ys ++ zs) :: [Int] +x:(zs ++ xs) :: [Int] +x:(zs ++ ys) :: [Int] +x:(zs ++ zs) :: [Int] +y:(xs ++ xs) :: [Int] +y:(xs ++ ys) :: [Int] +y:(xs ++ zs) :: [Int] +y:(ys ++ xs) :: [Int] +y:(ys ++ ys) :: [Int] +y:(ys ++ zs) :: [Int] +y:(zs ++ xs) :: [Int] +y:(zs ++ ys) :: [Int] +y:(zs ++ zs) :: [Int] +z:(xs ++ xs) :: [Int] +z:(xs ++ ys) :: [Int] +z:(xs ++ zs) :: [Int] +z:(ys ++ xs) :: [Int] +z:(ys ++ ys) :: [Int] +z:(ys ++ zs) :: [Int] +z:(zs ++ xs) :: [Int] +z:(zs ++ ys) :: [Int] +z:(zs ++ zs) :: [Int] +xs ++ tail (tail xs) :: [Int] +xs ++ tail (tail ys) :: [Int] +xs ++ tail (tail zs) :: [Int] +ys ++ tail (tail xs) :: [Int] +ys ++ tail (tail ys) :: [Int] +ys ++ tail (tail zs) :: [Int] +zs ++ tail (tail xs) :: [Int] +zs ++ tail (tail ys) :: [Int] +zs ++ tail (tail zs) :: [Int] +xs ++ tail (tail []) :: [Int] +ys ++ tail (tail []) :: [Int] +zs ++ tail (tail []) :: [Int] +xs ++ (x:xs) :: [Int] +xs ++ (y:xs) :: [Int] +xs ++ (z:xs) :: [Int] +xs ++ (x:ys) :: [Int] +xs ++ (y:ys) :: [Int] +xs ++ (z:ys) :: [Int] +xs ++ (x:zs) :: [Int] +xs ++ (y:zs) :: [Int] +xs ++ (z:zs) :: [Int] +ys ++ (x:xs) :: [Int] +ys ++ (y:xs) :: [Int] +ys ++ (z:xs) :: [Int] +ys ++ (x:ys) :: [Int] +ys ++ (y:ys) :: [Int] +ys ++ (z:ys) :: [Int] +ys ++ (x:zs) :: [Int] +ys ++ (y:zs) :: [Int] +ys ++ (z:zs) :: [Int] +zs ++ (x:xs) :: [Int] +zs ++ (y:xs) :: [Int] +zs ++ (z:xs) :: [Int] +zs ++ (x:ys) :: [Int] +zs ++ (y:ys) :: [Int] +zs ++ (z:ys) :: [Int] +zs ++ (x:zs) :: [Int] +zs ++ (y:zs) :: [Int] +zs ++ (z:zs) :: [Int] +xs ++ [x] :: [Int] +xs ++ [y] :: [Int] +xs ++ [z] :: [Int] +ys ++ [x] :: [Int] +ys ++ [y] :: [Int] +ys ++ [z] :: [Int] +zs ++ [x] :: [Int] +zs ++ [y] :: [Int] +zs ++ [z] :: [Int] +xs ++ (xs ++ xs) :: [Int] +xs ++ (xs ++ ys) :: [Int] +xs ++ (xs ++ zs) :: [Int] +xs ++ (ys ++ xs) :: [Int] +xs ++ (ys ++ ys) :: [Int] +xs ++ (ys ++ zs) :: [Int] +xs ++ (zs ++ xs) :: [Int] +xs ++ (zs ++ ys) :: [Int] +xs ++ (zs ++ zs) :: [Int] +ys ++ (xs ++ xs) :: [Int] +ys ++ (xs ++ ys) :: [Int] +ys ++ (xs ++ zs) :: [Int] +ys ++ (ys ++ xs) :: [Int] +ys ++ (ys ++ ys) :: [Int] +ys ++ (ys ++ zs) :: [Int] +ys ++ (zs ++ xs) :: [Int] +ys ++ (zs ++ ys) :: [Int] +ys ++ (zs ++ zs) :: [Int] +zs ++ (xs ++ xs) :: [Int] +zs ++ (xs ++ ys) :: [Int] +zs ++ (xs ++ zs) :: [Int] +zs ++ (ys ++ xs) :: [Int] +zs ++ (ys ++ ys) :: [Int] +zs ++ (ys ++ zs) :: [Int] +zs ++ (zs ++ xs) :: [Int] +zs ++ (zs ++ ys) :: [Int] +zs ++ (zs ++ zs) :: [Int] +head xs:tail xs :: [Int] +head xs:tail ys :: [Int] +head xs:tail zs :: [Int] +head ys:tail xs :: [Int] +head ys:tail ys :: [Int] +head ys:tail zs :: [Int] +head zs:tail xs :: [Int] +head zs:tail ys :: [Int] +head zs:tail zs :: [Int] +head xs:tail [] :: [Int] +head ys:tail [] :: [Int] +head zs:tail [] :: [Int] +head []:tail xs :: [Int] +head []:tail ys :: [Int] +head []:tail zs :: [Int] +head []:tail [] :: [Int] +tail xs ++ tail xs :: [Int] +tail xs ++ tail ys :: [Int] +tail xs ++ tail zs :: [Int] +tail ys ++ tail xs :: [Int] +tail ys ++ tail ys :: [Int] +tail ys ++ tail zs :: [Int] +tail zs ++ tail xs :: [Int] +tail zs ++ tail ys :: [Int] +tail zs ++ tail zs :: [Int] +tail xs ++ tail [] :: [Int] +tail ys ++ tail [] :: [Int] +tail zs ++ tail [] :: [Int] +tail [] ++ tail xs :: [Int] +tail [] ++ tail ys :: [Int] +tail [] ++ tail zs :: [Int] +tail [] ++ tail [] :: [Int] +head (tail xs):xs :: [Int] +head (tail xs):ys :: [Int] +head (tail xs):zs :: [Int] +head (tail ys):xs :: [Int] +head (tail ys):ys :: [Int] +head (tail ys):zs :: [Int] +head (tail zs):xs :: [Int] +head (tail zs):ys :: [Int] +head (tail zs):zs :: [Int] +[head (tail xs)] :: [Int] +[head (tail ys)] :: [Int] +[head (tail zs)] :: [Int] +head (tail []):xs :: [Int] +head (tail []):ys :: [Int] +head (tail []):zs :: [Int] +[head (tail [])] :: [Int] +tail (tail xs) ++ xs :: [Int] +tail (tail xs) ++ ys :: [Int] +tail (tail xs) ++ zs :: [Int] +tail (tail ys) ++ xs :: [Int] +tail (tail ys) ++ ys :: [Int] +tail (tail ys) ++ zs :: [Int] +tail (tail zs) ++ xs :: [Int] +tail (tail zs) ++ ys :: [Int] +tail (tail zs) ++ zs :: [Int] +tail (tail []) ++ xs :: [Int] +tail (tail []) ++ ys :: [Int] +tail (tail []) ++ zs :: [Int] + +Number of Eq schema classes: 90 +Number of Eq 1-var classes: 68 +Number of Eq 2-var classes: 191 +Number of Eq 3-var classes: 406 diff --git a/tests/model/list-c.out b/tests/model/list-c.out new file mode 100644 --- /dev/null +++ b/tests/model/list-c.out @@ -0,0 +1,777 @@ +max expr size = 5 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +head :: [Int] -> Int +tail :: [Int] -> [Int] + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +head _ :: Int (holes: [Int]) +head [] :: Int +tail _ :: [Int] (holes: [Int]) +tail [] :: [Int] +head (tail _) :: Int (holes: [Int]) +head (tail []) :: Int +tail (tail _) :: [Int] (holes: [Int]) +tail (tail []) :: [Int] +_:_ :: [Int] (holes: Int, [Int]) +[_] :: [Int] (holes: Int) +_ ++ _ :: [Int] (holes: [Int], [Int]) +head (tail (tail _)) :: Int (holes: [Int]) +head (tail (tail [])) :: Int +head (_ ++ _) :: Int (holes: [Int], [Int]) +tail (tail (tail _)) :: [Int] (holes: [Int]) +tail (tail (tail [])) :: [Int] +tail (_ ++ _) :: [Int] (holes: [Int], [Int]) +_:tail _ :: [Int] (holes: Int, [Int]) +_:tail [] :: [Int] (holes: Int) +_ ++ tail _ :: [Int] (holes: [Int], [Int]) +_ ++ tail [] :: [Int] (holes: [Int]) +[] ++ tail _ :: [Int] (holes: [Int]) +[] ++ tail [] :: [Int] +head _:_ :: [Int] (holes: [Int], [Int]) +[head _] :: [Int] (holes: [Int]) +head []:_ :: [Int] (holes: [Int]) +[head []] :: [Int] +tail _ ++ _ :: [Int] (holes: [Int], [Int]) +tail _ ++ [] :: [Int] (holes: [Int]) +tail [] ++ _ :: [Int] (holes: [Int]) +tail [] ++ [] :: [Int] +head (tail (tail (tail _))) :: Int (holes: [Int]) +head (tail (tail (tail []))) :: Int +head (tail (_ ++ _)) :: Int (holes: [Int], [Int]) +head (_ ++ tail _) :: Int (holes: [Int], [Int]) +head (_ ++ tail []) :: Int (holes: [Int]) +head ([] ++ tail _) :: Int (holes: [Int]) +head ([] ++ tail []) :: Int +head (head _:_) :: Int (holes: [Int], [Int]) +head [head _] :: Int (holes: [Int]) +head (head []:_) :: Int (holes: [Int]) +head [head []] :: Int +head (tail _ ++ _) :: Int (holes: [Int], [Int]) +head (tail _ ++ []) :: Int (holes: [Int]) +head (tail [] ++ _) :: Int (holes: [Int]) +head (tail [] ++ []) :: Int +tail (tail (tail (tail _))) :: [Int] (holes: [Int]) +tail (tail (tail (tail []))) :: [Int] +tail (tail (_ ++ _)) :: [Int] (holes: [Int], [Int]) +tail (_:tail _) :: [Int] (holes: Int, [Int]) +tail (_:tail []) :: [Int] (holes: Int) +tail (_ ++ tail _) :: [Int] (holes: [Int], [Int]) +tail (_ ++ tail []) :: [Int] (holes: [Int]) +tail ([] ++ tail _) :: [Int] (holes: [Int]) +tail ([] ++ tail []) :: [Int] +tail (tail _ ++ _) :: [Int] (holes: [Int], [Int]) +tail (tail _ ++ []) :: [Int] (holes: [Int]) +tail (tail [] ++ _) :: [Int] (holes: [Int]) +tail (tail [] ++ []) :: [Int] +_:tail (tail _) :: [Int] (holes: Int, [Int]) +_:tail (tail []) :: [Int] (holes: Int) +_:_:_ :: [Int] (holes: Int, Int, [Int]) +[_,_] :: [Int] (holes: Int, Int) +_:(_ ++ _) :: [Int] (holes: Int, [Int], [Int]) +_ ++ tail (tail _) :: [Int] (holes: [Int], [Int]) +_ ++ tail (tail []) :: [Int] (holes: [Int]) +_ ++ (_:_) :: [Int] (holes: [Int], Int, [Int]) +_ ++ [_] :: [Int] (holes: [Int], Int) +_ ++ (_ ++ _) :: [Int] (holes: [Int], [Int], [Int]) +[] ++ tail (tail _) :: [Int] (holes: [Int]) +[] ++ tail (tail []) :: [Int] +head _:tail _ :: [Int] (holes: [Int], [Int]) +head _:tail [] :: [Int] (holes: [Int]) +head []:tail _ :: [Int] (holes: [Int]) +head []:tail [] :: [Int] +tail _ ++ tail _ :: [Int] (holes: [Int], [Int]) +tail _ ++ tail [] :: [Int] (holes: [Int]) +tail [] ++ tail _ :: [Int] (holes: [Int]) +tail [] ++ tail [] :: [Int] +head (tail _):_ :: [Int] (holes: [Int], [Int]) +[head (tail _)] :: [Int] (holes: [Int]) +head (tail []):_ :: [Int] (holes: [Int]) +[head (tail [])] :: [Int] +tail (tail _) ++ _ :: [Int] (holes: [Int], [Int]) +tail (tail _) ++ [] :: [Int] (holes: [Int]) +tail (tail []) ++ _ :: [Int] (holes: [Int]) +tail (tail []) ++ [] :: [Int] + +x :: Int +xs :: [Int] +[] :: [Int] +head xs :: Int +head [] :: Int +tail xs :: [Int] +tail [] :: [Int] +head (tail xs) :: Int +head (tail []) :: Int +tail (tail xs) :: [Int] +tail (tail []) :: [Int] +x:xs :: [Int] +[x] :: [Int] +xs ++ xs :: [Int] +head (tail (tail xs)) :: Int +head (tail (tail [])) :: Int +head (xs ++ xs) :: Int +tail (tail (tail xs)) :: [Int] +tail (tail (tail [])) :: [Int] +tail (xs ++ xs) :: [Int] +x:tail xs :: [Int] +x:tail [] :: [Int] +xs ++ tail xs :: [Int] +xs ++ tail [] :: [Int] +head xs:xs :: [Int] +[head xs] :: [Int] +head []:xs :: [Int] +[head []] :: [Int] +tail xs ++ xs :: [Int] +tail [] ++ xs :: [Int] +head (tail (tail (tail xs))) :: Int +head (tail (tail (tail []))) :: Int +head (tail (xs ++ xs)) :: Int +head (xs ++ tail xs) :: Int +head (xs ++ tail []) :: Int +head (tail xs ++ xs) :: Int +head (tail [] ++ xs) :: Int +tail (tail (tail (tail xs))) :: [Int] +tail (tail (tail (tail []))) :: [Int] +tail (tail (xs ++ xs)) :: [Int] +tail (xs ++ tail xs) :: [Int] +tail (xs ++ tail []) :: [Int] +tail (tail xs ++ xs) :: [Int] +tail (tail [] ++ xs) :: [Int] +x:tail (tail xs) :: [Int] +x:tail (tail []) :: [Int] +x:x:xs :: [Int] +[x,x] :: [Int] +x:(xs ++ xs) :: [Int] +xs ++ tail (tail xs) :: [Int] +xs ++ tail (tail []) :: [Int] +xs ++ (x:xs) :: [Int] +xs ++ [x] :: [Int] +xs ++ (xs ++ xs) :: [Int] +head xs:tail xs :: [Int] +head xs:tail [] :: [Int] +head []:tail xs :: [Int] +head []:tail [] :: [Int] +tail xs ++ tail xs :: [Int] +tail xs ++ tail [] :: [Int] +tail [] ++ tail xs :: [Int] +tail [] ++ tail [] :: [Int] +head (tail xs):xs :: [Int] +[head (tail xs)] :: [Int] +head (tail []):xs :: [Int] +[head (tail [])] :: [Int] +tail (tail xs) ++ xs :: [Int] +tail (tail []) ++ xs :: [Int] + +x :: Int +y :: Int +xs :: [Int] +ys :: [Int] +[] :: [Int] +head xs :: Int +head ys :: Int +head [] :: Int +tail xs :: [Int] +tail ys :: [Int] +tail [] :: [Int] +head (tail xs) :: Int +head (tail ys) :: Int +head (tail []) :: Int +tail (tail xs) :: [Int] +tail (tail ys) :: [Int] +tail (tail []) :: [Int] +x:xs :: [Int] +x:ys :: [Int] +y:xs :: [Int] +y:ys :: [Int] +[x] :: [Int] +[y] :: [Int] +xs ++ xs :: [Int] +xs ++ ys :: [Int] +ys ++ xs :: [Int] +ys ++ ys :: [Int] +head (tail (tail xs)) :: Int +head (tail (tail ys)) :: Int +head (tail (tail [])) :: Int +head (xs ++ xs) :: Int +head (xs ++ ys) :: Int +head (ys ++ xs) :: Int +head (ys ++ ys) :: Int +tail (tail (tail xs)) :: [Int] +tail (tail (tail ys)) :: [Int] +tail (tail (tail [])) :: [Int] +tail (xs ++ xs) :: [Int] +tail (xs ++ ys) :: [Int] +tail (ys ++ xs) :: [Int] +tail (ys ++ ys) :: [Int] +x:tail xs :: [Int] +x:tail ys :: [Int] +y:tail xs :: [Int] +y:tail ys :: [Int] +x:tail [] :: [Int] +y:tail [] :: [Int] +xs ++ tail xs :: [Int] +xs ++ tail ys :: [Int] +ys ++ tail xs :: [Int] +ys ++ tail ys :: [Int] +xs ++ tail [] :: [Int] +ys ++ tail [] :: [Int] +head xs:xs :: [Int] +head xs:ys :: [Int] +head ys:xs :: [Int] +head ys:ys :: [Int] +[head xs] :: [Int] +[head ys] :: [Int] +head []:xs :: [Int] +head []:ys :: [Int] +[head []] :: [Int] +tail xs ++ xs :: [Int] +tail xs ++ ys :: [Int] +tail ys ++ xs :: [Int] +tail ys ++ ys :: [Int] +tail [] ++ xs :: [Int] +tail [] ++ ys :: [Int] +head (tail (tail (tail xs))) :: Int +head (tail (tail (tail ys))) :: Int +head (tail (tail (tail []))) :: Int +head (tail (xs ++ xs)) :: Int +head (tail (xs ++ ys)) :: Int +head (tail (ys ++ xs)) :: Int +head (tail (ys ++ ys)) :: Int +head (xs ++ tail xs) :: Int +head (xs ++ tail ys) :: Int +head (ys ++ tail xs) :: Int +head (ys ++ tail ys) :: Int +head (xs ++ tail []) :: Int +head (ys ++ tail []) :: Int +head (tail xs ++ xs) :: Int +head (tail xs ++ ys) :: Int +head (tail ys ++ xs) :: Int +head (tail ys ++ ys) :: Int +head (tail [] ++ xs) :: Int +head (tail [] ++ ys) :: Int +tail (tail (tail (tail xs))) :: [Int] +tail (tail (tail (tail ys))) :: [Int] +tail (tail (tail (tail []))) :: [Int] +tail (tail (xs ++ xs)) :: [Int] +tail (tail (xs ++ ys)) :: [Int] +tail (tail (ys ++ xs)) :: [Int] +tail (tail (ys ++ ys)) :: [Int] +tail (xs ++ tail xs) :: [Int] +tail (xs ++ tail ys) :: [Int] +tail (ys ++ tail xs) :: [Int] +tail (ys ++ tail ys) :: [Int] +tail (xs ++ tail []) :: [Int] +tail (ys ++ tail []) :: [Int] +tail (tail xs ++ xs) :: [Int] +tail (tail xs ++ ys) :: [Int] +tail (tail ys ++ xs) :: [Int] +tail (tail ys ++ ys) :: [Int] +tail (tail [] ++ xs) :: [Int] +tail (tail [] ++ ys) :: [Int] +x:tail (tail xs) :: [Int] +x:tail (tail ys) :: [Int] +y:tail (tail xs) :: [Int] +y:tail (tail ys) :: [Int] +x:tail (tail []) :: [Int] +y:tail (tail []) :: [Int] +x:x:xs :: [Int] +x:x:ys :: [Int] +x:y:xs :: [Int] +x:y:ys :: [Int] +y:x:xs :: [Int] +y:x:ys :: [Int] +y:y:xs :: [Int] +y:y:ys :: [Int] +[x,x] :: [Int] +[x,y] :: [Int] +[y,x] :: [Int] +[y,y] :: [Int] +x:(xs ++ xs) :: [Int] +x:(xs ++ ys) :: [Int] +x:(ys ++ xs) :: [Int] +x:(ys ++ ys) :: [Int] +y:(xs ++ xs) :: [Int] +y:(xs ++ ys) :: [Int] +y:(ys ++ xs) :: [Int] +y:(ys ++ ys) :: [Int] +xs ++ tail (tail xs) :: [Int] +xs ++ tail (tail ys) :: [Int] +ys ++ tail (tail xs) :: [Int] +ys ++ tail (tail ys) :: [Int] +xs ++ tail (tail []) :: [Int] +ys ++ tail (tail []) :: [Int] +xs ++ (x:xs) :: [Int] +xs ++ (y:xs) :: [Int] +xs ++ (x:ys) :: [Int] +xs ++ (y:ys) :: [Int] +ys ++ (x:xs) :: [Int] +ys ++ (y:xs) :: [Int] +ys ++ (x:ys) :: [Int] +ys ++ (y:ys) :: [Int] +xs ++ [x] :: [Int] +xs ++ [y] :: [Int] +ys ++ [x] :: [Int] +ys ++ [y] :: [Int] +xs ++ (xs ++ xs) :: [Int] +xs ++ (xs ++ ys) :: [Int] +xs ++ (ys ++ xs) :: [Int] +xs ++ (ys ++ ys) :: [Int] +ys ++ (xs ++ xs) :: [Int] +ys ++ (xs ++ ys) :: [Int] +ys ++ (ys ++ xs) :: [Int] +ys ++ (ys ++ ys) :: [Int] +head xs:tail xs :: [Int] +head xs:tail ys :: [Int] +head ys:tail xs :: [Int] +head ys:tail ys :: [Int] +head xs:tail [] :: [Int] +head ys:tail [] :: [Int] +head []:tail xs :: [Int] +head []:tail ys :: [Int] +head []:tail [] :: [Int] +tail xs ++ tail xs :: [Int] +tail xs ++ tail ys :: [Int] +tail ys ++ tail xs :: [Int] +tail ys ++ tail ys :: [Int] +tail xs ++ tail [] :: [Int] +tail ys ++ tail [] :: [Int] +tail [] ++ tail xs :: [Int] +tail [] ++ tail ys :: [Int] +tail [] ++ tail [] :: [Int] +head (tail xs):xs :: [Int] +head (tail xs):ys :: [Int] +head (tail ys):xs :: [Int] +head (tail ys):ys :: [Int] +[head (tail xs)] :: [Int] +[head (tail ys)] :: [Int] +head (tail []):xs :: [Int] +head (tail []):ys :: [Int] +[head (tail [])] :: [Int] +tail (tail xs) ++ xs :: [Int] +tail (tail xs) ++ ys :: [Int] +tail (tail ys) ++ xs :: [Int] +tail (tail ys) ++ ys :: [Int] +tail (tail []) ++ xs :: [Int] +tail (tail []) ++ ys :: [Int] + +x :: Int +y :: Int +z :: Int +xs :: [Int] +ys :: [Int] +zs :: [Int] +[] :: [Int] +head xs :: Int +head ys :: Int +head zs :: Int +head [] :: Int +tail xs :: [Int] +tail ys :: [Int] +tail zs :: [Int] +tail [] :: [Int] +head (tail xs) :: Int +head (tail ys) :: Int +head (tail zs) :: Int +head (tail []) :: Int +tail (tail xs) :: [Int] +tail (tail ys) :: [Int] +tail (tail zs) :: [Int] +tail (tail []) :: [Int] +x:xs :: [Int] +x:ys :: [Int] +x:zs :: [Int] +y:xs :: [Int] +y:ys :: [Int] +y:zs :: [Int] +z:xs :: [Int] +z:ys :: [Int] +z:zs :: [Int] +[x] :: [Int] +[y] :: [Int] +[z] :: [Int] +xs ++ xs :: [Int] +xs ++ ys :: [Int] +xs ++ zs :: [Int] +ys ++ xs :: [Int] +ys ++ ys :: [Int] +ys ++ zs :: [Int] +zs ++ xs :: [Int] +zs ++ ys :: [Int] +zs ++ zs :: [Int] +head (tail (tail xs)) :: Int +head (tail (tail ys)) :: Int +head (tail (tail zs)) :: Int +head (tail (tail [])) :: Int +head (xs ++ xs) :: Int +head (xs ++ ys) :: Int +head (xs ++ zs) :: Int +head (ys ++ xs) :: Int +head (ys ++ ys) :: Int +head (ys ++ zs) :: Int +head (zs ++ xs) :: Int +head (zs ++ ys) :: Int +head (zs ++ zs) :: Int +tail (tail (tail xs)) :: [Int] +tail (tail (tail ys)) :: [Int] +tail (tail (tail zs)) :: [Int] +tail (tail (tail [])) :: [Int] +tail (xs ++ xs) :: [Int] +tail (xs ++ ys) :: [Int] +tail (xs ++ zs) :: [Int] +tail (ys ++ xs) :: [Int] +tail (ys ++ ys) :: [Int] +tail (ys ++ zs) :: [Int] +tail (zs ++ xs) :: [Int] +tail (zs ++ ys) :: [Int] +tail (zs ++ zs) :: [Int] +x:tail xs :: [Int] +x:tail ys :: [Int] +x:tail zs :: [Int] +y:tail xs :: [Int] +y:tail ys :: [Int] +y:tail zs :: [Int] +z:tail xs :: [Int] +z:tail ys :: [Int] +z:tail zs :: [Int] +x:tail [] :: [Int] +y:tail [] :: [Int] +z:tail [] :: [Int] +xs ++ tail xs :: [Int] +xs ++ tail ys :: [Int] +xs ++ tail zs :: [Int] +ys ++ tail xs :: [Int] +ys ++ tail ys :: [Int] +ys ++ tail zs :: [Int] +zs ++ tail xs :: [Int] +zs ++ tail ys :: [Int] +zs ++ tail zs :: [Int] +xs ++ tail [] :: [Int] +ys ++ tail [] :: [Int] +zs ++ tail [] :: [Int] +head xs:xs :: [Int] +head xs:ys :: [Int] +head xs:zs :: [Int] +head ys:xs :: [Int] +head ys:ys :: [Int] +head ys:zs :: [Int] +head zs:xs :: [Int] +head zs:ys :: [Int] +head zs:zs :: [Int] +[head xs] :: [Int] +[head ys] :: [Int] +[head zs] :: [Int] +head []:xs :: [Int] +head []:ys :: [Int] +head []:zs :: [Int] +[head []] :: [Int] +tail xs ++ xs :: [Int] +tail xs ++ ys :: [Int] +tail xs ++ zs :: [Int] +tail ys ++ xs :: [Int] +tail ys ++ ys :: [Int] +tail ys ++ zs :: [Int] +tail zs ++ xs :: [Int] +tail zs ++ ys :: [Int] +tail zs ++ zs :: [Int] +tail [] ++ xs :: [Int] +tail [] ++ ys :: [Int] +tail [] ++ zs :: [Int] +head (tail (tail (tail xs))) :: Int +head (tail (tail (tail ys))) :: Int +head (tail (tail (tail zs))) :: Int +head (tail (tail (tail []))) :: Int +head (tail (xs ++ xs)) :: Int +head (tail (xs ++ ys)) :: Int +head (tail (xs ++ zs)) :: Int +head (tail (ys ++ xs)) :: Int +head (tail (ys ++ ys)) :: Int +head (tail (ys ++ zs)) :: Int +head (tail (zs ++ xs)) :: Int +head (tail (zs ++ ys)) :: Int +head (tail (zs ++ zs)) :: Int +head (xs ++ tail xs) :: Int +head (xs ++ tail ys) :: Int +head (xs ++ tail zs) :: Int +head (ys ++ tail xs) :: Int +head (ys ++ tail ys) :: Int +head (ys ++ tail zs) :: Int +head (zs ++ tail xs) :: Int +head (zs ++ tail ys) :: Int +head (zs ++ tail zs) :: Int +head (xs ++ tail []) :: Int +head (ys ++ tail []) :: Int +head (zs ++ tail []) :: Int +head (tail xs ++ xs) :: Int +head (tail xs ++ ys) :: Int +head (tail xs ++ zs) :: Int +head (tail ys ++ xs) :: Int +head (tail ys ++ ys) :: Int +head (tail ys ++ zs) :: Int +head (tail zs ++ xs) :: Int +head (tail zs ++ ys) :: Int +head (tail zs ++ zs) :: Int +head (tail [] ++ xs) :: Int +head (tail [] ++ ys) :: Int +head (tail [] ++ zs) :: Int +tail (tail (tail (tail xs))) :: [Int] +tail (tail (tail (tail ys))) :: [Int] +tail (tail (tail (tail zs))) :: [Int] +tail (tail (tail (tail []))) :: [Int] +tail (tail (xs ++ xs)) :: [Int] +tail (tail (xs ++ ys)) :: [Int] +tail (tail (xs ++ zs)) :: [Int] +tail (tail (ys ++ xs)) :: [Int] +tail (tail (ys ++ ys)) :: [Int] +tail (tail (ys ++ zs)) :: [Int] +tail (tail (zs ++ xs)) :: [Int] +tail (tail (zs ++ ys)) :: [Int] +tail (tail (zs ++ zs)) :: [Int] +tail (xs ++ tail xs) :: [Int] +tail (xs ++ tail ys) :: [Int] +tail (xs ++ tail zs) :: [Int] +tail (ys ++ tail xs) :: [Int] +tail (ys ++ tail ys) :: [Int] +tail (ys ++ tail zs) :: [Int] +tail (zs ++ tail xs) :: [Int] +tail (zs ++ tail ys) :: [Int] +tail (zs ++ tail zs) :: [Int] +tail (xs ++ tail []) :: [Int] +tail (ys ++ tail []) :: [Int] +tail (zs ++ tail []) :: [Int] +tail (tail xs ++ xs) :: [Int] +tail (tail xs ++ ys) :: [Int] +tail (tail xs ++ zs) :: [Int] +tail (tail ys ++ xs) :: [Int] +tail (tail ys ++ ys) :: [Int] +tail (tail ys ++ zs) :: [Int] +tail (tail zs ++ xs) :: [Int] +tail (tail zs ++ ys) :: [Int] +tail (tail zs ++ zs) :: [Int] +tail (tail [] ++ xs) :: [Int] +tail (tail [] ++ ys) :: [Int] +tail (tail [] ++ zs) :: [Int] +x:tail (tail xs) :: [Int] +x:tail (tail ys) :: [Int] +x:tail (tail zs) :: [Int] +y:tail (tail xs) :: [Int] +y:tail (tail ys) :: [Int] +y:tail (tail zs) :: [Int] +z:tail (tail xs) :: [Int] +z:tail (tail ys) :: [Int] +z:tail (tail zs) :: [Int] +x:tail (tail []) :: [Int] +y:tail (tail []) :: [Int] +z:tail (tail []) :: [Int] +x:x:xs :: [Int] +x:x:ys :: [Int] +x:x:zs :: [Int] +x:y:xs :: [Int] +x:y:ys :: [Int] +x:y:zs :: [Int] +x:z:xs :: [Int] +x:z:ys :: [Int] +x:z:zs :: [Int] +y:x:xs :: [Int] +y:x:ys :: [Int] +y:x:zs :: [Int] +y:y:xs :: [Int] +y:y:ys :: [Int] +y:y:zs :: [Int] +y:z:xs :: [Int] +y:z:ys :: [Int] +y:z:zs :: [Int] +z:x:xs :: [Int] +z:x:ys :: [Int] +z:x:zs :: [Int] +z:y:xs :: [Int] +z:y:ys :: [Int] +z:y:zs :: [Int] +z:z:xs :: [Int] +z:z:ys :: [Int] +z:z:zs :: [Int] +[x,x] :: [Int] +[x,y] :: [Int] +[x,z] :: [Int] +[y,x] :: [Int] +[y,y] :: [Int] +[y,z] :: [Int] +[z,x] :: [Int] +[z,y] :: [Int] +[z,z] :: [Int] +x:(xs ++ xs) :: [Int] +x:(xs ++ ys) :: [Int] +x:(xs ++ zs) :: [Int] +x:(ys ++ xs) :: [Int] +x:(ys ++ ys) :: [Int] +x:(ys ++ zs) :: [Int] +x:(zs ++ xs) :: [Int] +x:(zs ++ ys) :: [Int] +x:(zs ++ zs) :: [Int] +y:(xs ++ xs) :: [Int] +y:(xs ++ ys) :: [Int] +y:(xs ++ zs) :: [Int] +y:(ys ++ xs) :: [Int] +y:(ys ++ ys) :: [Int] +y:(ys ++ zs) :: [Int] +y:(zs ++ xs) :: [Int] +y:(zs ++ ys) :: [Int] +y:(zs ++ zs) :: [Int] +z:(xs ++ xs) :: [Int] +z:(xs ++ ys) :: [Int] +z:(xs ++ zs) :: [Int] +z:(ys ++ xs) :: [Int] +z:(ys ++ ys) :: [Int] +z:(ys ++ zs) :: [Int] +z:(zs ++ xs) :: [Int] +z:(zs ++ ys) :: [Int] +z:(zs ++ zs) :: [Int] +xs ++ tail (tail xs) :: [Int] +xs ++ tail (tail ys) :: [Int] +xs ++ tail (tail zs) :: [Int] +ys ++ tail (tail xs) :: [Int] +ys ++ tail (tail ys) :: [Int] +ys ++ tail (tail zs) :: [Int] +zs ++ tail (tail xs) :: [Int] +zs ++ tail (tail ys) :: [Int] +zs ++ tail (tail zs) :: [Int] +xs ++ tail (tail []) :: [Int] +ys ++ tail (tail []) :: [Int] +zs ++ tail (tail []) :: [Int] +xs ++ (x:xs) :: [Int] +xs ++ (y:xs) :: [Int] +xs ++ (z:xs) :: [Int] +xs ++ (x:ys) :: [Int] +xs ++ (y:ys) :: [Int] +xs ++ (z:ys) :: [Int] +xs ++ (x:zs) :: [Int] +xs ++ (y:zs) :: [Int] +xs ++ (z:zs) :: [Int] +ys ++ (x:xs) :: [Int] +ys ++ (y:xs) :: [Int] +ys ++ (z:xs) :: [Int] +ys ++ (x:ys) :: [Int] +ys ++ (y:ys) :: [Int] +ys ++ (z:ys) :: [Int] +ys ++ (x:zs) :: [Int] +ys ++ (y:zs) :: [Int] +ys ++ (z:zs) :: [Int] +zs ++ (x:xs) :: [Int] +zs ++ (y:xs) :: [Int] +zs ++ (z:xs) :: [Int] +zs ++ (x:ys) :: [Int] +zs ++ (y:ys) :: [Int] +zs ++ (z:ys) :: [Int] +zs ++ (x:zs) :: [Int] +zs ++ (y:zs) :: [Int] +zs ++ (z:zs) :: [Int] +xs ++ [x] :: [Int] +xs ++ [y] :: [Int] +xs ++ [z] :: [Int] +ys ++ [x] :: [Int] +ys ++ [y] :: [Int] +ys ++ [z] :: [Int] +zs ++ [x] :: [Int] +zs ++ [y] :: [Int] +zs ++ [z] :: [Int] +xs ++ (xs ++ xs) :: [Int] +xs ++ (xs ++ ys) :: [Int] +xs ++ (xs ++ zs) :: [Int] +xs ++ (ys ++ xs) :: [Int] +xs ++ (ys ++ ys) :: [Int] +xs ++ (ys ++ zs) :: [Int] +xs ++ (zs ++ xs) :: [Int] +xs ++ (zs ++ ys) :: [Int] +xs ++ (zs ++ zs) :: [Int] +ys ++ (xs ++ xs) :: [Int] +ys ++ (xs ++ ys) :: [Int] +ys ++ (xs ++ zs) :: [Int] +ys ++ (ys ++ xs) :: [Int] +ys ++ (ys ++ ys) :: [Int] +ys ++ (ys ++ zs) :: [Int] +ys ++ (zs ++ xs) :: [Int] +ys ++ (zs ++ ys) :: [Int] +ys ++ (zs ++ zs) :: [Int] +zs ++ (xs ++ xs) :: [Int] +zs ++ (xs ++ ys) :: [Int] +zs ++ (xs ++ zs) :: [Int] +zs ++ (ys ++ xs) :: [Int] +zs ++ (ys ++ ys) :: [Int] +zs ++ (ys ++ zs) :: [Int] +zs ++ (zs ++ xs) :: [Int] +zs ++ (zs ++ ys) :: [Int] +zs ++ (zs ++ zs) :: [Int] +head xs:tail xs :: [Int] +head xs:tail ys :: [Int] +head xs:tail zs :: [Int] +head ys:tail xs :: [Int] +head ys:tail ys :: [Int] +head ys:tail zs :: [Int] +head zs:tail xs :: [Int] +head zs:tail ys :: [Int] +head zs:tail zs :: [Int] +head xs:tail [] :: [Int] +head ys:tail [] :: [Int] +head zs:tail [] :: [Int] +head []:tail xs :: [Int] +head []:tail ys :: [Int] +head []:tail zs :: [Int] +head []:tail [] :: [Int] +tail xs ++ tail xs :: [Int] +tail xs ++ tail ys :: [Int] +tail xs ++ tail zs :: [Int] +tail ys ++ tail xs :: [Int] +tail ys ++ tail ys :: [Int] +tail ys ++ tail zs :: [Int] +tail zs ++ tail xs :: [Int] +tail zs ++ tail ys :: [Int] +tail zs ++ tail zs :: [Int] +tail xs ++ tail [] :: [Int] +tail ys ++ tail [] :: [Int] +tail zs ++ tail [] :: [Int] +tail [] ++ tail xs :: [Int] +tail [] ++ tail ys :: [Int] +tail [] ++ tail zs :: [Int] +tail [] ++ tail [] :: [Int] +head (tail xs):xs :: [Int] +head (tail xs):ys :: [Int] +head (tail xs):zs :: [Int] +head (tail ys):xs :: [Int] +head (tail ys):ys :: [Int] +head (tail ys):zs :: [Int] +head (tail zs):xs :: [Int] +head (tail zs):ys :: [Int] +head (tail zs):zs :: [Int] +[head (tail xs)] :: [Int] +[head (tail ys)] :: [Int] +[head (tail zs)] :: [Int] +head (tail []):xs :: [Int] +head (tail []):ys :: [Int] +head (tail []):zs :: [Int] +[head (tail [])] :: [Int] +tail (tail xs) ++ xs :: [Int] +tail (tail xs) ++ ys :: [Int] +tail (tail xs) ++ zs :: [Int] +tail (tail ys) ++ xs :: [Int] +tail (tail ys) ++ ys :: [Int] +tail (tail ys) ++ zs :: [Int] +tail (tail zs) ++ xs :: [Int] +tail (tail zs) ++ ys :: [Int] +tail (tail zs) ++ zs :: [Int] +tail (tail []) ++ xs :: [Int] +tail (tail []) ++ ys :: [Int] +tail (tail []) ++ zs :: [Int] + +Number of Eq schema classes: 90 +Number of Eq 1-var classes: 68 +Number of Eq 2-var classes: 191 +Number of Eq 3-var classes: 406 diff --git a/tests/model/list-s4.out b/tests/model/list-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/list-s4.out @@ -0,0 +1,26 @@ +max expr size = 4 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +head :: [Int] -> Int +tail :: [Int] -> [Int] + +head (x:xs) == x + xs ++ [] == xs + [] ++ xs == xs +tail (x:xs) == xs + + [] <= xs + xs <= x:xs + xs <= xs ++ ys + xs <= ys ++ xs + xs <= tail (xs ++ xs) +[x] <= x:xs + diff --git a/tests/model/list.out b/tests/model/list.out new file mode 100644 --- /dev/null +++ b/tests/model/list.out @@ -0,0 +1,37 @@ +max expr size = 5 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +[] :: [Int] +(:) :: Int -> [Int] -> [Int] +(++) :: [Int] -> [Int] -> [Int] +head :: [Int] -> Int +tail :: [Int] -> [Int] + + head (x:xs) == x + xs ++ [] == xs + [] ++ xs == xs + tail (x:xs) == xs +(xs ++ ys) ++ zs == xs ++ (ys ++ zs) + (x:xs) ++ ys == x:(xs ++ ys) + + [] <= xs + xs <= x:xs + xs <= xs ++ ys + xs <= ys ++ xs + xs <= tail (xs ++ xs) + [x] <= x:xs + xs <= head xs:tail xs + x:xs <= x:y:xs + xs ++ ys <= xs ++ (ys ++ zs) + xs ++ ys <= xs ++ (zs ++ ys) + x:xs <= x:(xs ++ ys) + x:xs <= x:(ys ++ xs) + xs ++ ys <= xs ++ (x:ys) + [x,y] <= x:y:xs +xs ++ [x] <= xs ++ (x:ys) + diff --git a/tests/model/minus-c-s4.out b/tests/model/minus-c-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/minus-c-s4.out @@ -0,0 +1,232 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +id :: Int -> Int +(+) :: Int -> Int -> Int +negate :: Int -> Int +(-) :: Int -> Int -> Int + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +negate _ :: Int (holes: Int) +negate 1 :: Int +_ + _ :: Int (holes: Int, Int) +_ + 1 :: Int (holes: Int) +1 + 1 :: Int +_ - _ :: Int (holes: Int, Int) +_ - 1 :: Int (holes: Int) +1 - _ :: Int (holes: Int) +negate (_ + _) :: Int (holes: Int, Int) +negate (_ + 1) :: Int (holes: Int) +negate (1 + 1) :: Int +_ + (_ + _) :: Int (holes: Int, Int, Int) +_ + (_ + 1) :: Int (holes: Int, Int) +_ + (1 + 1) :: Int (holes: Int) +_ + (_ - _) :: Int (holes: Int, Int, Int) +_ + (_ - 1) :: Int (holes: Int, Int) +_ + (1 - _) :: Int (holes: Int, Int) +1 + (1 + 1) :: Int +1 + (1 - _) :: Int (holes: Int) +_ - (_ + _) :: Int (holes: Int, Int, Int) +_ - (_ + 1) :: Int (holes: Int, Int) +_ - (1 + 1) :: Int (holes: Int) +1 - (_ + _) :: Int (holes: Int, Int) + +x :: Int +0 :: Int +1 :: Int +negate x :: Int +negate 1 :: Int +x + x :: Int +x + 1 :: Int +1 + 1 :: Int +x - 1 :: Int +1 - x :: Int +negate (x + x) :: Int +negate (x + 1) :: Int +negate (1 + 1) :: Int +x + (x + x) :: Int +x + (x + 1) :: Int +x + (1 + 1) :: Int +x + (x - 1) :: Int +1 + (1 + 1) :: Int +1 + (1 - x) :: Int +x - (1 + 1) :: Int +1 - (x + x) :: Int + +x :: Int +y :: Int +0 :: Int +1 :: Int +negate x :: Int +negate y :: Int +negate 1 :: Int +x + x :: Int +x + y :: Int +y + y :: Int +x + 1 :: Int +y + 1 :: Int +1 + 1 :: Int +x - y :: Int +y - x :: Int +x - 1 :: Int +y - 1 :: Int +1 - x :: Int +1 - y :: Int +negate (x + x) :: Int +negate (x + y) :: Int +negate (y + y) :: Int +negate (x + 1) :: Int +negate (y + 1) :: Int +negate (1 + 1) :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (y + y) :: Int +y + (y + y) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +y + (y + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +x + (x - y) :: Int +y + (y - x) :: Int +x + (x - 1) :: Int +x + (y - 1) :: Int +y + (y - 1) :: Int +x + (1 - y) :: Int +y + (1 - x) :: Int +1 + (1 + 1) :: Int +1 + (1 - x) :: Int +1 + (1 - y) :: Int +x - (y + y) :: Int +y - (x + x) :: Int +x - (y + 1) :: Int +y - (x + 1) :: Int +x - (1 + 1) :: Int +y - (1 + 1) :: Int +1 - (x + x) :: Int +1 - (x + y) :: Int +1 - (y + y) :: Int + +x :: Int +y :: Int +z :: Int +0 :: Int +1 :: Int +negate x :: Int +negate y :: Int +negate z :: Int +negate 1 :: Int +x + x :: Int +x + y :: Int +x + z :: Int +y + y :: Int +y + z :: Int +z + z :: Int +x + 1 :: Int +y + 1 :: Int +z + 1 :: Int +1 + 1 :: Int +x - y :: Int +x - z :: Int +y - x :: Int +y - z :: Int +z - x :: Int +z - y :: Int +x - 1 :: Int +y - 1 :: Int +z - 1 :: Int +1 - x :: Int +1 - y :: Int +1 - z :: Int +negate (x + x) :: Int +negate (x + y) :: Int +negate (x + z) :: Int +negate (y + y) :: Int +negate (y + z) :: Int +negate (z + z) :: Int +negate (x + 1) :: Int +negate (y + 1) :: Int +negate (z + 1) :: Int +negate (1 + 1) :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (x + z) :: Int +x + (y + y) :: Int +x + (y + z) :: Int +x + (z + z) :: Int +y + (y + y) :: Int +y + (y + z) :: Int +y + (z + z) :: Int +z + (z + z) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +x + (z + 1) :: Int +y + (y + 1) :: Int +y + (z + 1) :: Int +z + (z + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +z + (1 + 1) :: Int +x + (x - y) :: Int +x + (x - z) :: Int +x + (y - z) :: Int +x + (z - y) :: Int +y + (y - x) :: Int +y + (y - z) :: Int +y + (z - x) :: Int +z + (z - x) :: Int +z + (z - y) :: Int +x + (x - 1) :: Int +x + (y - 1) :: Int +x + (z - 1) :: Int +y + (y - 1) :: Int +y + (z - 1) :: Int +z + (z - 1) :: Int +x + (1 - y) :: Int +x + (1 - z) :: Int +y + (1 - x) :: Int +y + (1 - z) :: Int +z + (1 - x) :: Int +z + (1 - y) :: Int +1 + (1 + 1) :: Int +1 + (1 - x) :: Int +1 + (1 - y) :: Int +1 + (1 - z) :: Int +x - (y + y) :: Int +x - (y + z) :: Int +x - (z + z) :: Int +y - (x + x) :: Int +y - (x + z) :: Int +y - (z + z) :: Int +z - (x + x) :: Int +z - (x + y) :: Int +z - (y + y) :: Int +x - (y + 1) :: Int +x - (z + 1) :: Int +y - (x + 1) :: Int +y - (z + 1) :: Int +z - (x + 1) :: Int +z - (y + 1) :: Int +x - (1 + 1) :: Int +y - (1 + 1) :: Int +z - (1 + 1) :: Int +1 - (x + x) :: Int +1 - (x + y) :: Int +1 - (x + z) :: Int +1 - (y + y) :: Int +1 - (y + z) :: Int +1 - (z + z) :: Int + +Number of Eq schema classes: 26 +Number of Eq 1-var classes: 21 +Number of Eq 2-var classes: 53 +Number of Eq 3-var classes: 109 diff --git a/tests/model/minus-c.out b/tests/model/minus-c.out new file mode 100644 --- /dev/null +++ b/tests/model/minus-c.out @@ -0,0 +1,232 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +id :: Int -> Int +(+) :: Int -> Int -> Int +negate :: Int -> Int +(-) :: Int -> Int -> Int + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +negate _ :: Int (holes: Int) +negate 1 :: Int +_ + _ :: Int (holes: Int, Int) +_ + 1 :: Int (holes: Int) +1 + 1 :: Int +_ - _ :: Int (holes: Int, Int) +_ - 1 :: Int (holes: Int) +1 - _ :: Int (holes: Int) +negate (_ + _) :: Int (holes: Int, Int) +negate (_ + 1) :: Int (holes: Int) +negate (1 + 1) :: Int +_ + (_ + _) :: Int (holes: Int, Int, Int) +_ + (_ + 1) :: Int (holes: Int, Int) +_ + (1 + 1) :: Int (holes: Int) +_ + (_ - _) :: Int (holes: Int, Int, Int) +_ + (_ - 1) :: Int (holes: Int, Int) +_ + (1 - _) :: Int (holes: Int, Int) +1 + (1 + 1) :: Int +1 + (1 - _) :: Int (holes: Int) +_ - (_ + _) :: Int (holes: Int, Int, Int) +_ - (_ + 1) :: Int (holes: Int, Int) +_ - (1 + 1) :: Int (holes: Int) +1 - (_ + _) :: Int (holes: Int, Int) + +x :: Int +0 :: Int +1 :: Int +negate x :: Int +negate 1 :: Int +x + x :: Int +x + 1 :: Int +1 + 1 :: Int +x - 1 :: Int +1 - x :: Int +negate (x + x) :: Int +negate (x + 1) :: Int +negate (1 + 1) :: Int +x + (x + x) :: Int +x + (x + 1) :: Int +x + (1 + 1) :: Int +x + (x - 1) :: Int +1 + (1 + 1) :: Int +1 + (1 - x) :: Int +x - (1 + 1) :: Int +1 - (x + x) :: Int + +x :: Int +y :: Int +0 :: Int +1 :: Int +negate x :: Int +negate y :: Int +negate 1 :: Int +x + x :: Int +x + y :: Int +y + y :: Int +x + 1 :: Int +y + 1 :: Int +1 + 1 :: Int +x - y :: Int +y - x :: Int +x - 1 :: Int +y - 1 :: Int +1 - x :: Int +1 - y :: Int +negate (x + x) :: Int +negate (x + y) :: Int +negate (y + y) :: Int +negate (x + 1) :: Int +negate (y + 1) :: Int +negate (1 + 1) :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (y + y) :: Int +y + (y + y) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +y + (y + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +x + (x - y) :: Int +y + (y - x) :: Int +x + (x - 1) :: Int +x + (y - 1) :: Int +y + (y - 1) :: Int +x + (1 - y) :: Int +y + (1 - x) :: Int +1 + (1 + 1) :: Int +1 + (1 - x) :: Int +1 + (1 - y) :: Int +x - (y + y) :: Int +y - (x + x) :: Int +x - (y + 1) :: Int +y - (x + 1) :: Int +x - (1 + 1) :: Int +y - (1 + 1) :: Int +1 - (x + x) :: Int +1 - (x + y) :: Int +1 - (y + y) :: Int + +x :: Int +y :: Int +z :: Int +0 :: Int +1 :: Int +negate x :: Int +negate y :: Int +negate z :: Int +negate 1 :: Int +x + x :: Int +x + y :: Int +x + z :: Int +y + y :: Int +y + z :: Int +z + z :: Int +x + 1 :: Int +y + 1 :: Int +z + 1 :: Int +1 + 1 :: Int +x - y :: Int +x - z :: Int +y - x :: Int +y - z :: Int +z - x :: Int +z - y :: Int +x - 1 :: Int +y - 1 :: Int +z - 1 :: Int +1 - x :: Int +1 - y :: Int +1 - z :: Int +negate (x + x) :: Int +negate (x + y) :: Int +negate (x + z) :: Int +negate (y + y) :: Int +negate (y + z) :: Int +negate (z + z) :: Int +negate (x + 1) :: Int +negate (y + 1) :: Int +negate (z + 1) :: Int +negate (1 + 1) :: Int +x + (x + x) :: Int +x + (x + y) :: Int +x + (x + z) :: Int +x + (y + y) :: Int +x + (y + z) :: Int +x + (z + z) :: Int +y + (y + y) :: Int +y + (y + z) :: Int +y + (z + z) :: Int +z + (z + z) :: Int +x + (x + 1) :: Int +x + (y + 1) :: Int +x + (z + 1) :: Int +y + (y + 1) :: Int +y + (z + 1) :: Int +z + (z + 1) :: Int +x + (1 + 1) :: Int +y + (1 + 1) :: Int +z + (1 + 1) :: Int +x + (x - y) :: Int +x + (x - z) :: Int +x + (y - z) :: Int +x + (z - y) :: Int +y + (y - x) :: Int +y + (y - z) :: Int +y + (z - x) :: Int +z + (z - x) :: Int +z + (z - y) :: Int +x + (x - 1) :: Int +x + (y - 1) :: Int +x + (z - 1) :: Int +y + (y - 1) :: Int +y + (z - 1) :: Int +z + (z - 1) :: Int +x + (1 - y) :: Int +x + (1 - z) :: Int +y + (1 - x) :: Int +y + (1 - z) :: Int +z + (1 - x) :: Int +z + (1 - y) :: Int +1 + (1 + 1) :: Int +1 + (1 - x) :: Int +1 + (1 - y) :: Int +1 + (1 - z) :: Int +x - (y + y) :: Int +x - (y + z) :: Int +x - (z + z) :: Int +y - (x + x) :: Int +y - (x + z) :: Int +y - (z + z) :: Int +z - (x + x) :: Int +z - (x + y) :: Int +z - (y + y) :: Int +x - (y + 1) :: Int +x - (z + 1) :: Int +y - (x + 1) :: Int +y - (z + 1) :: Int +z - (x + 1) :: Int +z - (y + 1) :: Int +x - (1 + 1) :: Int +y - (1 + 1) :: Int +z - (1 + 1) :: Int +1 - (x + x) :: Int +1 - (x + y) :: Int +1 - (x + z) :: Int +1 - (y + y) :: Int +1 - (y + z) :: Int +1 - (z + z) :: Int + +Number of Eq schema classes: 26 +Number of Eq 1-var classes: 21 +Number of Eq 2-var classes: 53 +Number of Eq 3-var classes: 109 diff --git a/tests/model/minus-s4.out b/tests/model/minus-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/minus-s4.out @@ -0,0 +1,25 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +id :: Int -> Int +(+) :: Int -> Int -> Int +negate :: Int -> Int +(-) :: Int -> Int -> Int + + id x == x +negate (negate x) == x + x + 0 == x + x + negate x == 0 + x + y == y + x + x - y == x + negate y + + x <= x + 1 +x - 1 <= x + diff --git a/tests/model/minus.out b/tests/model/minus.out new file mode 100644 --- /dev/null +++ b/tests/model/minus.out @@ -0,0 +1,27 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +0 :: Int +1 :: Int +id :: Int -> Int +(+) :: Int -> Int -> Int +negate :: Int -> Int +(-) :: Int -> Int -> Int + + id x == x +negate (negate x) == x + x + 0 == x + x + negate x == 0 + x + y == y + x + x - y == x + negate y + negate (x + y) == negate x + negate y + (x + y) + z == x + (y + z) + + x <= x + 1 +x - 1 <= x + diff --git a/tests/model/monad-s4.out b/tests/model/monad-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/monad-s4.out @@ -0,0 +1,21 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +_ :: Int -> [Int] (holes: Int -> [Int]) +return :: Int -> [Int] +(>>=) :: [Int] -> (Int -> [Int]) -> [Int] +(>=>) :: (Int -> [Int]) -> (Int -> [Int]) -> Int -> [Int] + +(xs >>= return) == xs + f x == (return x >>= f) + (f >=> g) x == (f x >>= g) + (f >=> return) == f + (return >=> f) == f + + diff --git a/tests/model/monad.out b/tests/model/monad.out new file mode 100644 --- /dev/null +++ b/tests/model/monad.out @@ -0,0 +1,23 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +_ :: Int -> [Int] (holes: Int -> [Int]) +return :: Int -> [Int] +(>>=) :: [Int] -> (Int -> [Int]) -> [Int] +(>=>) :: (Int -> [Int]) -> (Int -> [Int]) -> Int -> [Int] + + (xs >>= return) == xs + f x == (return x >>= f) + (f >=> g) x == (f x >>= g) +((xs >>= f) >>= g) == (xs >>= (f >=> g)) + (f >=> return) == f + (return >=> f) == f + ((f >=> g) >=> h) == (f >=> (g >=> h)) + + diff --git a/tests/model/nord-s4.out b/tests/model/nord-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/nord-s4.out @@ -0,0 +1,15 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: EqButNotOrd (holes: EqButNotOrd) +C0 :: EqButNotOrd +id :: EqButNotOrd -> EqButNotOrd + +Warning: no Ord instance for EqButNotOrd, inequations of this type will not be considered + + + diff --git a/tests/model/nord.out b/tests/model/nord.out new file mode 100644 --- /dev/null +++ b/tests/model/nord.out @@ -0,0 +1,15 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: EqButNotOrd (holes: EqButNotOrd) +C0 :: EqButNotOrd +id :: EqButNotOrd -> EqButNotOrd + +Warning: no Ord instance for EqButNotOrd, inequations of this type will not be considered + + + diff --git a/tests/model/oddeven-s4.out b/tests/model/oddeven-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/oddeven-s4.out @@ -0,0 +1,44 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +0 :: Int +1 :: Int +2 :: Int +False :: Bool +True :: Bool +odd :: Int -> Bool +even :: Int -> Bool +mod :: Int -> Int -> Int +(==) :: Int -> Int -> Bool +(==) :: Bool -> Bool -> Bool + + (p == p) == True + (p == True) == p + (x == x) == True + (x == y) == (y == x) + odd (x `mod` 2) == odd x + even (x `mod` 2) == even x + (False == odd x) == even x +(False == even x) == odd x + x `mod` 1 == 0 + + p ==> True + False ==> p + x == 0 ==> even x + x == 1 ==> odd x + x == 2 ==> even x +x `mod` 2 <= 2 + 0 <= x `mod` 2 +x `mod` 2 <= 1 + + odd x ==> x `mod` x == 0 + odd x ==> 0 `mod` x == 0 + odd x ==> x `mod` 2 == 1 +even x ==> x `mod` 2 == 0 + diff --git a/tests/model/oddeven.out b/tests/model/oddeven.out new file mode 100644 --- /dev/null +++ b/tests/model/oddeven.out @@ -0,0 +1,52 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +0 :: Int +1 :: Int +2 :: Int +False :: Bool +True :: Bool +odd :: Int -> Bool +even :: Int -> Bool +mod :: Int -> Int -> Int +(==) :: Int -> Int -> Bool +(==) :: Bool -> Bool -> Bool + + (p == p) == True + (p == True) == p + (x == x) == True + (x == y) == (y == x) + odd (x `mod` 2) == odd x + even (x `mod` 2) == even x + (False == odd x) == even x + (False == even x) == odd x + (odd x == even x) == False + (2 == x `mod` 2) == False + (0 == x `mod` 2) == even x + (1 == x `mod` 2) == odd x + (even x == odd y) == (odd x == even y) + (even x == even y) == (odd x == odd y) + x `mod` 1 == 0 +(x `mod` 2) `mod` 2 == x `mod` 2 + + p ==> True + False ==> p + x == 0 ==> even x + x == 1 ==> odd x + x == 2 ==> even x +x `mod` 2 <= 2 + 0 <= x `mod` 2 +x `mod` 2 <= 1 + + odd x ==> x `mod` x == 0 + odd x ==> 0 `mod` x == 0 + odd x ==> x `mod` 2 == 1 + odd y ==> (x `mod` y) `mod` y == x `mod` y +even x ==> x `mod` 2 == 0 + diff --git a/tests/model/plus-abs-s4.out b/tests/model/plus-abs-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/plus-abs-s4.out @@ -0,0 +1,40 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +(+) :: Int -> Int -> Int +id :: Int -> Int +abs :: Int -> Int +0 :: Int +1 :: Int +(<=) :: Int -> Int -> Bool +(<) :: Int -> Int -> Bool +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Int -> Int -> Bool + +(x <= abs x) == True + (abs x < x) == False +(0 <= abs x) == True + (abs x < 0) == False +(abs x <= x) == (0 <= x) + (x < abs x) == (x < 0) +(x == abs x) == (0 <= x) + (x == 0) == (abs x <= 0) + id x == x + x + 0 == x + abs (abs x) == abs x + x + y == y + x + +x <= abs x +0 <= abs x +x <= x + 1 + +x <= 0 ==> x + abs x == 0 + diff --git a/tests/model/plus-abs.out b/tests/model/plus-abs.out new file mode 100644 --- /dev/null +++ b/tests/model/plus-abs.out @@ -0,0 +1,68 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +(+) :: Int -> Int -> Int +id :: Int -> Int +abs :: Int -> Int +0 :: Int +1 :: Int +(<=) :: Int -> Int -> Bool +(<) :: Int -> Int -> Bool +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Int -> Int -> Bool + + (x <= abs x) == True + (0 <= abs x) == True + (1 == x + x) == False + (abs x <= x) == (0 <= x) + (x == abs x) == (0 <= x) + (x == 0) == (abs x <= 0) + (0 <= x) == (y <= x + y) + (x + y <= x) == (y <= 0) + (x < y) == (x + 1 <= y) + (0 <= x + x) == (0 <= x) + (1 <= x + x) == (1 <= x) + (x + x <= 0) == (x <= 0) + (x + x <= 1) == (x <= 0) + (x == x + y) == (abs y <= 0) +(False == (x <= y)) == (y + 1 <= x) + id x == x + x + 0 == x + abs (abs x) == abs x + x + y == y + x + abs (x + x) == abs x + abs x + abs (x + abs x) == x + abs x + abs (1 + abs x) == 1 + abs x + (x + y) + z == x + (y + z) + + x <= y ==> x <= abs y + abs x <= y ==> x <= y + abs x < y ==> x < y + x <= 0 ==> x <= abs y + abs x <= y ==> 0 <= y + abs x < y ==> 1 <= y + x == 1 ==> 1 == abs x + x < 0 ==> 1 <= abs x + x <= abs x + 0 <= abs x + x <= x + 1 + x <= x + abs y + x <= abs (x + x) + x <= 1 + abs x + 0 <= x + abs x + x + y <= x + abs y +abs (x + 1) <= 1 + abs x + + y <= x ==> abs (x + abs y) == x + abs y + x <= 0 ==> x + abs x == 0 +abs x <= y ==> abs (x + y) == x + y +abs y <= x ==> abs (x + y) == x + y + diff --git a/tests/model/pretty-compact-s4.out b/tests/model/pretty-compact-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/pretty-compact-s4.out @@ -0,0 +1,32 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 360 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Char (holes: Char) +_ :: Int (holes: Int) +_ :: ODoc Any (holes: ODoc Any) +_ :: [Char] (holes: [Char]) +text :: [Char] -> ODoc Any +char :: Char -> ODoc Any +flush :: ODoc Any -> ODoc Any +hang :: Int -> ODoc Any -> ODoc Any -> ODoc Any +(<>) :: ODoc Any -> ODoc Any -> ODoc Any +(<+>) :: ODoc Any -> ODoc Any -> ODoc Any +($$) :: ODoc Any -> ODoc Any -> ODoc Any +() :: ODoc Any -> ODoc Any -> ODoc Any +() :: ODoc Any -> ODoc Any -> ODoc Any +(<$$>) :: ODoc Any -> ODoc Any -> ODoc Any + + d1 $$ d2 == flush d1 <> d2 + d1 <$$> d2 == flush d1 <> d2 + flush d1 d2 == flush (flush d1) <> d2 +flush d1 d2 == flush (flush d1) <> d2 + + d1 <= flush d1 + d1 <= d1 $$ d2 + d1 <= d1 d2 + d1 <= d1 d2 +flush d1 <= d1 $$ d2 + diff --git a/tests/model/pretty-compact.out b/tests/model/pretty-compact.out new file mode 100644 --- /dev/null +++ b/tests/model/pretty-compact.out @@ -0,0 +1,32 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 360 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Char (holes: Char) +_ :: Int (holes: Int) +_ :: ODoc Any (holes: ODoc Any) +_ :: [Char] (holes: [Char]) +text :: [Char] -> ODoc Any +char :: Char -> ODoc Any +flush :: ODoc Any -> ODoc Any +hang :: Int -> ODoc Any -> ODoc Any -> ODoc Any +(<>) :: ODoc Any -> ODoc Any -> ODoc Any +(<+>) :: ODoc Any -> ODoc Any -> ODoc Any +($$) :: ODoc Any -> ODoc Any -> ODoc Any +() :: ODoc Any -> ODoc Any -> ODoc Any +() :: ODoc Any -> ODoc Any -> ODoc Any +(<$$>) :: ODoc Any -> ODoc Any -> ODoc Any + + d1 $$ d2 == flush d1 <> d2 + d1 <$$> d2 == flush d1 <> d2 + flush d1 d2 == flush (flush d1) <> d2 +flush d1 d2 == flush (flush d1) <> d2 + + d1 <= flush d1 + d1 <= d1 $$ d2 + d1 <= d1 d2 + d1 <= d1 d2 +flush d1 <= d1 $$ d2 + diff --git a/tests/model/pretty-s4.out b/tests/model/pretty-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/pretty-s4.out @@ -0,0 +1,20 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Doc (holes: Doc) +_ :: Int (holes: Int) +_ :: [Char] (holes: [Char]) +($$) :: Doc -> Doc -> Doc +(<>) :: Doc -> Doc -> Doc +nest :: Int -> Doc -> Doc +(++) :: [Char] -> [Char] -> [Char] +length :: [Char] -> Int + + +d1 <= d1 $$ d2 +d1 <= d1 <> d2 + diff --git a/tests/model/pretty.out b/tests/model/pretty.out new file mode 100644 --- /dev/null +++ b/tests/model/pretty.out @@ -0,0 +1,33 @@ +max expr size = 7 + |- on ineqs = 6 + |- on conds = 6 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Doc (holes: Doc) +_ :: Int (holes: Int) +_ :: [Char] (holes: [Char]) +($$) :: Doc -> Doc -> Doc +(<>) :: Doc -> Doc -> Doc +nest :: Int -> Doc -> Doc +(++) :: [Char] -> [Char] -> [Char] +length :: [Char] -> Int + + d1 <> nest x d2 == d1 <> d2 + (d1 $$ d2) $$ d3 == d1 $$ (d2 $$ d3) + (d1 <> d2) <> d3 == d1 <> (d2 <> d3) + nest x (nest y d1) == nest y (nest x d1) + (d1 $$ d2) <> d3 == d1 $$ (d2 <> d3) + nest x (d1 <> d2) == nest x d1 <> d2 + d1 <> (nest x d2 <> d3) == d1 <> (d2 <> d3) + nest x (d1 $$ d2) == nest x d1 $$ nest x d2 +nest (length (cs ++ ds)) d1 == nest (length cs) (nest (length ds) d1) + + d1 <= d1 $$ d2 + d1 <= d1 <> d2 +d1 $$ d2 <= d1 $$ (d2 $$ d3) +d1 <> d2 <= d1 <> (d2 <> d3) +d1 $$ d2 <= d1 $$ (d2 <> d3) +d1 <> d2 <= d1 <> (d2 $$ d3) + diff --git a/tests/model/ratio-s4.out b/tests/model/ratio-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/ratio-s4.out @@ -0,0 +1,59 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Integer (holes: Integer) +_ :: Ratio Integer (holes: Ratio Integer) +id :: Ratio Integer -> Ratio Integer +abs :: Ratio Integer -> Ratio Integer +negate :: Ratio Integer -> Ratio Integer +(+) :: Ratio Integer -> Ratio Integer -> Ratio Integer +(*) :: Ratio Integer -> Ratio Integer -> Ratio Integer +(/) :: Ratio Integer -> Ratio Integer -> Ratio Integer +(%) :: Integer -> Integer -> Ratio Integer +recip :: Ratio Integer -> Ratio Integer +numerator :: Ratio Integer -> Integer +denominator :: Ratio Integer -> Integer +0 % 1 :: Ratio Integer +1 % 1 :: Ratio Integer +0 :: Integer +1 :: Integer + + denominator (abs q) == denominator q + denominator (negate q) == denominator q + numerator (x % 1) == x + denominator (x % 1) == 1 +denominator (q + 1 % 1) == denominator q + id q == q + negate (negate q) == q + q + 0 % 1 == q + q * (1 % 1) == q + q / (1 % 1) == q + q * (0 % 1) == 0 % 1 + abs (abs q) == abs q + abs (negate q) == abs q + q + negate q == 0 % 1 + 0 % denominator q == 0 % 1 + q + r == r + q + q * r == r * q + q / negate (1 % 1) == negate q + abs (q * q) == q * q + q * negate r == negate (q * r) + + 0 <= denominator q + 1 <= denominator q + 0 <= numerator (abs q) + numerator q <= numerator (abs q) +numerator (negate q) <= numerator (abs q) + q <= abs q + 0 % 1 <= abs q + q <= q + 1 % 1 + 0 % 1 <= q * q + negate q <= abs q + negate (abs q) <= q + negate (abs q) <= 0 % 1 + negate (abs q) <= negate q + diff --git a/tests/model/ratio.out b/tests/model/ratio.out new file mode 100644 --- /dev/null +++ b/tests/model/ratio.out @@ -0,0 +1,114 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Integer (holes: Integer) +_ :: Ratio Integer (holes: Ratio Integer) +id :: Ratio Integer -> Ratio Integer +abs :: Ratio Integer -> Ratio Integer +negate :: Ratio Integer -> Ratio Integer +(+) :: Ratio Integer -> Ratio Integer -> Ratio Integer +(*) :: Ratio Integer -> Ratio Integer -> Ratio Integer +(/) :: Ratio Integer -> Ratio Integer -> Ratio Integer +(%) :: Integer -> Integer -> Ratio Integer +recip :: Ratio Integer -> Ratio Integer +numerator :: Ratio Integer -> Integer +denominator :: Ratio Integer -> Integer +0 % 1 :: Ratio Integer +1 % 1 :: Ratio Integer +0 :: Integer +1 :: Integer + + denominator (abs q) == denominator q + denominator (negate q) == denominator q + numerator (x % 1) == x + denominator (x % 1) == 1 + denominator (q + 1 % 1) == denominator q + numerator (1 % denominator q) == 1 +denominator (1 % denominator q) == denominator q + denominator (q * abs r) == denominator (q * r) + id q == q + negate (negate q) == q + q + 0 % 1 == q + q * (1 % 1) == q + q / (1 % 1) == q + q * (0 % 1) == 0 % 1 + abs (abs q) == abs q + abs (negate q) == abs q + q + negate q == 0 % 1 + 0 % denominator q == 0 % 1 + q + r == r + q + q * r == r * q + numerator q % denominator q == q + denominator q % denominator q == 1 % 1 + q / negate (1 % 1) == negate q + abs (q * q) == q * q + q * negate r == negate (q * r) + abs (q * abs r) == abs (q * r) + negate q + r == negate (q + negate r) + abs q * abs r == abs (q * r) + abs (q + abs q) == q + abs q + abs q + abs q == abs (q + q) + abs (1 % 1 + abs q) == 1 % 1 + abs q + abs (1 % denominator q) == 1 % denominator q + abs (denominator q % 1) == denominator q % 1 + recip (1 % denominator q) == denominator q % 1 + recip (denominator q % 1) == 1 % denominator q + x % numerator (negate (1 % 1)) == negate (x % 1) + (q + r) + s == q + (r + s) + (q * r) * s == q * (r * s) + (q + q) * r == q * (r + r) + q * (r + 1 % 1) == q + q * r + numerator (abs q) % 1 == abs (numerator q % 1) + numerator (negate q) % 1 == negate (numerator q % 1) + + 0 <= denominator q + 1 <= denominator q + 0 <= numerator (abs q) + numerator q <= numerator (abs q) + 0 <= numerator (q * q) +numerator (negate (abs q)) <= 0 + numerator q <= numerator (q * q) + denominator q <= denominator (q * q) + denominator (q + q) <= denominator q + numerator q <= numerator (q + 1 % 1) + numerator (negate q) <= numerator (abs q) +numerator (negate (abs q)) <= numerator q + numerator (abs q) <= numerator (q * q) +numerator (negate (abs q)) <= numerator (negate q) + q <= abs q + 0 % 1 <= abs q + q <= q + 1 % 1 + 0 % 1 <= q * q + negate q <= abs q + negate (abs q) <= q + negate (abs q) <= 0 % 1 + q <= q + abs r + q <= abs (q + q) + negate (abs q) <= negate q + q <= 1 % 1 + abs q + 0 % 1 <= q + abs q + negate (q * q) <= 0 % 1 + q + negate (1 % 1) <= q + 0 % 1 <= 1 % denominator q + 0 % 1 <= denominator q % 1 + 1 % 1 <= denominator q % 1 + 1 % denominator q <= 1 % 1 + abs q <= abs (q + q) + negate (q + 1 % 1) <= negate q + q + r <= q + abs r + q * abs q <= q * q + negate (q + 1 % 1) <= q * q + negate (q * q) <= q + 1 % 1 + q + negate (1 % 1) <= q * q + q * abs r <= abs (q * r) + q + negate r <= q + abs r + x % denominator q <= abs (x % 1) + q + abs q <= abs (q + q) + negate (q * q) <= q * abs q + negate (q * q) <= 1 % 1 + negate q + abs (q + 1 % 1) <= 1 % 1 + abs q + diff --git a/tests/model/regexes-s4.out b/tests/model/regexes-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/regexes-s4.out @@ -0,0 +1,45 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 30 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: RE Symbol (holes: RE Symbol) +Empty :: RE Symbol +None :: RE Symbol +Star :: RE Symbol -> RE Symbol +(:+) :: RE Symbol -> RE Symbol -> RE Symbol +(:.) :: RE Symbol -> RE Symbol -> RE Symbol +(<=) :: RE Symbol -> RE Symbol -> Bool +(==) :: RE Symbol -> RE Symbol -> Bool +False :: Bool +True :: Bool + + (r <= Empty) == True + (None <= r) == True + (r <= Star s) == True + (Star r <= None) == False + (r == Empty) == (Empty <= r) + (r == None) == (r <= None) + (r == Star s) == (Star s <= r) + r :+ r == r + r :+ None == r + r :. Empty == r + r :. None == None + Star (Star r) == Star r + r :+ s == s :+ r + r :. s == s :. r + r :+ Star r == Star r +Star (r :+ Empty) == Star r + Empty :+ Star r == Star r + + r <= None ==> r <= s + None <= r + r <= Star r + Empty <= Star r + r <= r :+ s + r :. r <= Star r +r :+ Empty <= Star r + r :. s <= r :+ s + diff --git a/tests/model/regexes.out b/tests/model/regexes.out new file mode 100644 --- /dev/null +++ b/tests/model/regexes.out @@ -0,0 +1,45 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 30 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: RE Symbol (holes: RE Symbol) +Empty :: RE Symbol +None :: RE Symbol +Star :: RE Symbol -> RE Symbol +(:+) :: RE Symbol -> RE Symbol -> RE Symbol +(:.) :: RE Symbol -> RE Symbol -> RE Symbol +(<=) :: RE Symbol -> RE Symbol -> Bool +(==) :: RE Symbol -> RE Symbol -> Bool +False :: Bool +True :: Bool + + (r <= Empty) == True + (None <= r) == True + (r <= Star s) == True + (Star r <= None) == False + (r == Empty) == (Empty <= r) + (r == None) == (r <= None) + (r == Star s) == (Star s <= r) + r :+ r == r + r :+ None == r + r :. Empty == r + r :. None == None + Star (Star r) == Star r + r :+ s == s :+ r + r :. s == s :. r + r :+ Star r == Star r +Star (r :+ Empty) == Star r + Empty :+ Star r == Star r + + r <= None ==> r <= s + None <= r + r <= Star r + Empty <= Star r + r <= r :+ s + r :. r <= Star r +r :+ Empty <= Star r + r :. s <= r :+ s + diff --git a/tests/model/sets-s4.out b/tests/model/sets-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/sets-s4.out @@ -0,0 +1,50 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: Set Int (holes: Set Int) +emptyS :: Set Int +singleS :: Int -> Set Int +insertS :: Int -> Set Int -> Set Int +deleteS :: Int -> Set Int -> Set Int +sizeS :: Set Int -> Int +(<~) :: Int -> Set Int -> Bool +(\/) :: Set Int -> Set Int -> Set Int +(/\) :: Set Int -> Set Int -> Set Int +False :: Bool +True :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Int -> Int -> Bool +(==) :: Set Int -> Set Int -> Bool + + x <~ emptyS == False + x <~ singleS x == True +(emptyS == singleS x) == False + (x == y) == x <~ singleS y + x <~ singleS y == y <~ singleS x + sizeS (singleS x) == sizeS (singleS y) + s \/ s == s + s /\ s == s + s \/ emptyS == s + deleteS x emptyS == emptyS + s /\ emptyS == emptyS + insertS x emptyS == singleS x +deleteS x (singleS x) == emptyS + s \/ t == t \/ s + s /\ t == t /\ s +insertS x (singleS x) == singleS x + s \/ singleS x == insertS x s +insertS x (singleS y) == insertS y (singleS x) + + sizeS emptyS <= sizeS s + emptyS <= s +singleS (sizeS emptyS) <= singleS (sizeS s) + +x <~ s ==> insertS x s == s +x <~ s ==> s /\ singleS x == singleS x + diff --git a/tests/model/sets.out b/tests/model/sets.out new file mode 100644 --- /dev/null +++ b/tests/model/sets.out @@ -0,0 +1,81 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: Set Int (holes: Set Int) +emptyS :: Set Int +singleS :: Int -> Set Int +insertS :: Int -> Set Int -> Set Int +deleteS :: Int -> Set Int -> Set Int +sizeS :: Set Int -> Int +(<~) :: Int -> Set Int -> Bool +(\/) :: Set Int -> Set Int -> Set Int +(/\) :: Set Int -> Set Int -> Set Int +False :: Bool +True :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: Int -> Int -> Bool +(==) :: Set Int -> Set Int -> Bool + + x <~ emptyS == False + x <~ singleS x == True + (emptyS == singleS x) == False + x <~ insertS x s == True + x <~ deleteS x s == False + (emptyS == insertS x s) == False + (x == y) == x <~ singleS y + (s == insertS x s) == x <~ s + x <~ singleS y == y <~ singleS x + (singleS x == singleS y) == x <~ singleS y + (s /\ t == s) == (t == s \/ t) + (s == deleteS x s) == (False == x <~ s) + sizeS (singleS x) == sizeS (singleS y) +sizeS (deleteS x (singleS y)) == sizeS (deleteS y (singleS x)) + s \/ s == s + s /\ s == s + s \/ emptyS == s + deleteS x emptyS == emptyS + s /\ emptyS == emptyS + insertS x emptyS == singleS x + deleteS x (singleS x) == emptyS + s \/ t == t \/ s + s /\ t == t /\ s + s \/ deleteS x s == s + s \/ (s /\ t) == s + s /\ insertS x s == s + s /\ (s \/ t) == s + insertS x (singleS x) == singleS x + s \/ singleS x == insertS x s + insertS x (insertS x s) == insertS x s + deleteS x (deleteS x s) == deleteS x s + insertS x (deleteS x s) == insertS x s + deleteS x (insertS x s) == deleteS x s + insertS x (singleS y) == insertS y (singleS x) + insertS x (insertS y s) == insertS y (insertS x s) + deleteS x (deleteS y s) == deleteS y (deleteS x s) + (s \/ t) \/ u == s \/ (t \/ u) + (s /\ t) /\ u == s /\ (t /\ u) + s \/ insertS x t == insertS x (s \/ t) + s /\ deleteS x t == deleteS x (s /\ t) + + s == singleS x ==> x <~ s + sizeS emptyS <= sizeS s + sizeS s <= sizeS (insertS x s) + sizeS s <= sizeS (s \/ t) + sizeS (deleteS x s) <= sizeS s + sizeS (s /\ t) <= sizeS s + sizeS (singleS x) <= sizeS (insertS y s) + sizeS (deleteS x s) <= sizeS (t \/ s) + emptyS <= s + deleteS x (singleS y) <= singleS y + s /\ singleS x <= singleS x + singleS (sizeS emptyS) <= singleS (sizeS s) +insertS (sizeS emptyS) s <= singleS (sizeS s) +insertS (sizeS emptyS) s <= singleS (sizeS (singleS x)) + + diff --git a/tests/model/speculate-reason-s4.out b/tests/model/speculate-reason-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/speculate-reason-s4.out @@ -0,0 +1,28 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 6000 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Equation (holes: Equation) +_ :: Expr (holes: Expr) +_ :: Thyght (holes: Thyght) +_ :: [Expr] (holes: [Expr]) +okThy :: Thyght -> Bool +insert :: Expr -> Thyght -> Thyght +complete :: Thyght -> Thyght +normalize :: Thyght -> Expr -> Expr +equivalent :: Thyght -> Expr -> Expr -> Bool +append :: Thyght -> [Expr] -> Thyght +emptyThy :: Thyght +True :: Bool +False :: Bool +Equation :: Expr -> Expr -> Equation + + okThy t == True + equivalent t e e == True + equivalent t e f == equivalent t f e + normalize emptyThy e == e +complete (complete t) == complete t + diff --git a/tests/model/speculate-reason.out b/tests/model/speculate-reason.out new file mode 100644 --- /dev/null +++ b/tests/model/speculate-reason.out @@ -0,0 +1,28 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 6000 +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Equation (holes: Equation) +_ :: Expr (holes: Expr) +_ :: Thyght (holes: Thyght) +_ :: [Expr] (holes: [Expr]) +okThy :: Thyght -> Bool +insert :: Expr -> Thyght -> Thyght +complete :: Thyght -> Thyght +normalize :: Thyght -> Expr -> Expr +equivalent :: Thyght -> Expr -> Expr -> Bool +append :: Thyght -> [Expr] -> Thyght +emptyThy :: Thyght +True :: Bool +False :: Bool +Equation :: Expr -> Expr -> Equation + + okThy t == True + equivalent t e e == True + equivalent t e f == equivalent t f e + normalize emptyThy e == e +complete (complete t) == complete t + diff --git a/tests/model/string-s4.out b/tests/model/string-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/string-s4.out @@ -0,0 +1,47 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: [Char] (holes: [Char]) +_ :: [[Char]] (holes: [[Char]]) +"" :: [Char] +" " :: [Char] +"\n" :: [Char] +lines :: [Char] -> [[Char]] +words :: [Char] -> [[Char]] +unlines :: [[Char]] -> [Char] +unwords :: [[Char]] -> [Char] +(++) :: [Char] -> [Char] -> [Char] + + cs ++ "" == cs + "" ++ cs == cs +unlines (lines (unlines css)) == unlines css + lines (unlines (lines cs)) == lines cs + words (unlines (words cs)) == words cs + lines (unlines (words cs)) == words cs + words (cs ++ " ") == words cs + words (cs ++ "\n") == words cs + words (" " ++ cs) == words cs + words ("\n" ++ cs) == words cs + words (unlines (lines cs)) == words cs + words (unwords css) == words (unlines css) + + "" <= cs + cs <= cs ++ ds + cs <= unlines (lines cs) + "\n" <= cs ++ "\n" + "\n" <= cs ++ " " + "\n" ++ cs <= " " + unwords (lines cs) <= cs ++ ds + "\n" ++ cs <= ds ++ " " + unlines (lines cs) <= cs ++ cs + "\n" ++ cs <= cs ++ "\n" + cs ++ "\n" <= cs ++ " " + unlines (lines cs) <= cs ++ " " + unlines (lines cs) <= cs ++ "\n" + lines "" <= css +lines (unlines css) <= css + diff --git a/tests/model/string.out b/tests/model/string.out new file mode 100644 --- /dev/null +++ b/tests/model/string.out @@ -0,0 +1,73 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: [Char] (holes: [Char]) +_ :: [[Char]] (holes: [[Char]]) +"" :: [Char] +" " :: [Char] +"\n" :: [Char] +lines :: [Char] -> [[Char]] +words :: [Char] -> [[Char]] +unlines :: [[Char]] -> [Char] +unwords :: [[Char]] -> [Char] +(++) :: [Char] -> [Char] -> [Char] + + cs ++ "" == cs + "" ++ cs == cs + unlines (lines (unlines css)) == unlines css +unwords (lines (unwords (lines cs))) == unwords (lines cs) +unwords (lines (unwords (words cs))) == unwords (words cs) + unlines (lines (cs ++ "\n")) == cs ++ "\n" + (cs ++ ds) ++ es == cs ++ (ds ++ es) + cs ++ unlines (lines cs) == unlines (lines (cs ++ cs)) + cs ++ unlines (lines " ") == unlines (lines (cs ++ " ")) + " " ++ unwords (lines cs) == unwords (lines (" " ++ cs)) + "\n" ++ unlines (lines cs) == unlines (lines ("\n" ++ cs)) + unlines (lines " ") ++ cs == " " ++ ("\n" ++ cs) + lines (unlines (lines cs)) == lines cs + words (unlines (words cs)) == words cs + lines (unlines (words cs)) == words cs + words (cs ++ " ") == words cs + words (cs ++ "\n") == words cs + words (" " ++ cs) == words cs + words ("\n" ++ cs) == words cs + words (unlines (lines cs)) == words cs + words (unwords css) == words (unlines css) + words (cs ++ unwords css) == words (cs ++ unlines css) + + "" <= cs + cs <= cs ++ ds + cs <= unlines (lines cs) + "\n" <= cs ++ "\n" + "\n" <= cs ++ " " + "\n" ++ cs <= " " + unwords (lines cs) <= cs ++ ds + "\n" ++ cs <= ds ++ " " + unlines (lines cs) <= cs ++ cs + "\n" ++ cs <= cs ++ "\n" +unwords (lines (unwords css)) <= unwords css + cs ++ "\n" <= cs ++ " " + unwords css <= unwords (lines (unlines css)) + unlines css <= unwords css ++ " " + unlines css <= unwords css ++ "\n" + unlines (lines cs) <= cs ++ " " + unlines (lines cs) <= cs ++ "\n" +unwords (lines (unlines css)) <= unwords css ++ cs + unlines css ++ " " <= unwords css ++ " " + lines "" <= css + lines (unlines css) <= css + lines cs <= lines (cs ++ ds) + words cs <= words (cs ++ ds) + words cs <= lines (unwords (words cs)) + lines "\n" <= lines (cs ++ "\n") + lines "\n" <= lines (cs ++ " ") + lines ("\n" ++ cs) <= lines " " + lines (unwords (lines cs)) <= lines (cs ++ ds) + lines ("\n" ++ cs) <= lines (ds ++ " ") + lines ("\n" ++ cs) <= lines (cs ++ "\n") + lines (cs ++ "\n") <= lines (cs ++ " ") + diff --git a/tests/model/tauts-s4.out b/tests/model/tauts-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/tauts-s4.out @@ -0,0 +1,33 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 4000 +min #-tests = 200 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Name (holes: Name) +_ :: Prop (holes: Prop) +False :: Bool +True :: Bool +(==) :: Prop -> Prop -> Bool +eval :: Prop -> Prop +varOf :: Prop -> Name +subst :: Name -> Bool -> Prop -> Prop +taut :: Prop -> Bool +(==) :: Bool -> Bool -> Bool +(==) :: Name -> Name -> Bool + + (p == p) == True + (p == True) == p + (n == n) == True + (p == p) == True +taut (eval p) == taut p + (p == q) == (q == p) +eval (eval p) == eval p + + p ==> True +False ==> p + +p ==> subst n True q == subst n p q + diff --git a/tests/model/tauts.out b/tests/model/tauts.out new file mode 100644 --- /dev/null +++ b/tests/model/tauts.out @@ -0,0 +1,37 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 4000 +min #-tests = 200 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Name (holes: Name) +_ :: Prop (holes: Prop) +False :: Bool +True :: Bool +(==) :: Prop -> Prop -> Bool +eval :: Prop -> Prop +varOf :: Prop -> Name +subst :: Name -> Bool -> Prop -> Prop +taut :: Prop -> Bool +(==) :: Bool -> Bool -> Bool +(==) :: Name -> Name -> Bool + + (p == p) == True + (p == True) == p + (n == n) == True + (p == p) == True +taut (eval p) == taut p + (p == q) == (q == p) +eval (eval p) == eval p + + p ==> True + False ==> p + p == eval q ==> p == eval p + subst n p q <= q + subst n p q <= subst n True q +subst n False p <= subst n q p + +taut q ==> subst n (taut q) p == subst n True p + diff --git a/tests/model/tuples-s4.out b/tests/model/tuples-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/tuples-s4.out @@ -0,0 +1,36 @@ +max expr size = 4 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: () (holes: ()) +_ :: Int (holes: Int) +_ :: (Int,Int) (holes: (Int,Int)) +_ :: (Int,Int,Int) (holes: (Int,Int,Int)) +() :: () +id :: () -> () +id :: Int -> Int +id :: (Int,Int) -> (Int,Int) +id :: (Int,Int,Int) -> (Int,Int,Int) +(,) :: Int -> Int -> (Int,Int) +(,,) :: Int -> Int -> Int -> (Int,Int,Int) +fst :: (Int,Int) -> Int +snd :: (Int,Int) -> Int +swap :: (Int,Int) -> (Int,Int) +right :: (Int,Int,Int) -> (Int,Int,Int) +left :: (Int,Int,Int) -> (Int,Int,Int) + + id x == x + fst (x,y) == x + snd (x,y) == y + fst (swap xy) == snd xy + snd (swap xy) == fst xy + id xy == xy + swap (swap xy) == xy + swap (x,y) == (y,x) + id xyz == xyz +right (right (right xyz)) == xyz + left xyz == right (right xyz) + + diff --git a/tests/model/tuples.out b/tests/model/tuples.out new file mode 100644 --- /dev/null +++ b/tests/model/tuples.out @@ -0,0 +1,35 @@ +max expr size = 5 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: () (holes: ()) +_ :: Int (holes: Int) +_ :: (Int,Int) (holes: (Int,Int)) +_ :: (Int,Int,Int) (holes: (Int,Int,Int)) +() :: () +id :: () -> () +id :: Int -> Int +id :: (Int,Int) -> (Int,Int) +id :: (Int,Int,Int) -> (Int,Int,Int) +(,) :: Int -> Int -> (Int,Int) +(,,) :: Int -> Int -> Int -> (Int,Int,Int) +fst :: (Int,Int) -> Int +snd :: (Int,Int) -> Int +swap :: (Int,Int) -> (Int,Int) +right :: (Int,Int,Int) -> (Int,Int,Int) +left :: (Int,Int,Int) -> (Int,Int,Int) + + id x == x + fst (x,y) == x + snd (x,y) == y + id xy == xy + (fst xy,snd xy) == xy + swap xy == (snd xy,fst xy) + id xyz == xyz +right (right (right xyz)) == xyz + left xyz == right (right xyz) + right (x,y,z) == (z,x,y) + + diff --git a/tests/model/unit-s4.out b/tests/model/unit-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/unit-s4.out @@ -0,0 +1,13 @@ +max expr size = 4 + |- on ineqs = 3 + |- on conds = 3 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: () (holes: ()) +() :: () +id :: () -> () + + + diff --git a/tests/model/unit.out b/tests/model/unit.out new file mode 100644 --- /dev/null +++ b/tests/model/unit.out @@ -0,0 +1,13 @@ +max expr size = 5 + |- on ineqs = 4 + |- on conds = 4 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 2 (for inequational and conditional laws) + +_ :: () (holes: ()) +() :: () +id :: () -> () + + + diff --git a/tests/model/zip-s4.out b/tests/model/zip-s4.out new file mode 100644 --- /dev/null +++ b/tests/model/zip-s4.out @@ -0,0 +1,23 @@ +max expr size = 4 + |- on ineqs = 5 + |- on conds = 5 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +_ :: [(Int,Int)] (holes: [(Int,Int)]) +(++) :: [Int] -> [Int] -> [Int] +(==) :: Int -> Int -> Bool +length :: [Int] -> Int +zip :: [Int] -> [Int] -> [(Int,Int)] +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: [Int] -> [Int] -> Bool +(==) :: [(Int,Int)] -> [(Int,Int)] -> Bool + + + diff --git a/tests/model/zip.out b/tests/model/zip.out new file mode 100644 --- /dev/null +++ b/tests/model/zip.out @@ -0,0 +1,25 @@ +max expr size = 5 +max #-tests = 500 +min #-tests = 25 (to consider p ==> q true) +max #-vars = 3 (for inequational and conditional laws) + +_ :: Bool (holes: Bool) +_ :: Int (holes: Int) +_ :: [Int] (holes: [Int]) +_ :: [(Int,Int)] (holes: [(Int,Int)]) +(++) :: [Int] -> [Int] -> [Int] +(==) :: Int -> Int -> Bool +length :: [Int] -> Int +zip :: [Int] -> [Int] -> [(Int,Int)] +True :: Bool +False :: Bool +(==) :: Bool -> Bool -> Bool +(==) :: [Int] -> [Int] -> Bool +(==) :: [(Int,Int)] -> [(Int,Int)] -> Bool + +zip xs (xs ++ ys) == zip xs xs +zip (xs ++ ys) xs == zip xs xs + +length xs == length ys ==> zip xs (ys ++ zs) == zip xs ys +length xs == length ys ==> zip (xs ++ zs) ys == zip xs ys + diff --git a/tests/test-model b/tests/test-model new file mode 100644 --- /dev/null +++ b/tests/test-model @@ -0,0 +1,74 @@ +#!/bin/bash +top=`dirname $0`/.. +eg=$top/eg +model=$top/tests/model + +case "$1" in + -*) sz="$1" + shift + ;; +esac + +test-model() { + $1 $sz | diff -rud $model/$2$sz.out - || exit 1 +} + +update-test-model() { + $1 $sz > $model/$2$sz.out +} + +tym() { + /usr/bin/time -f%e "$@" +} + +spc() { + /usr/bin/time -f%M "$@" +} + +mean() { + sum="`echo -n $* | sed -e "s/ / + /g"`" + mean="`echo "scale = 3; ($sum) / $#" | bc`" + printf "%3.3f\n" $mean +} +export -f mean + +div1024() { + printf "%3.0f\n" "`echo "$1 / 1024" | bc`" +} +export -f div1024 + +benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +memory-benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + spc $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean | + xargs bash -c 'div1024 "$@"' div1024 +} + +benchmark-cmp() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + grep "^ *$2$sz " bench/runtime-$HOSTNAME | tr '\n' ' ' + echo -n ' ' + for run in {1..1} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +find $* | sed -e "s/^bench/ /;s/^eg/ /" | +sort -b | sed -e "s/^ /bench/;s/^ /eg/" | +while read e +do + `basename $0` $top/$e `basename $e` +done diff --git a/tests/test-sdist b/tests/test-sdist new file mode 100644 --- /dev/null +++ b/tests/test-sdist @@ -0,0 +1,28 @@ +#!/bin/bash +# +# test-sdist: tests the package generated by "cabal sdist". +# +# Copyright (c) 2015-2018 Rudy Matela. +# Distributed under the 3-Clause BSD licence. +pkgver=` cat *.cabal | grep "^version:" | sed -e "s/version: *//"` +pkgname=`cat *.cabal | grep "^name:" | sed -e "s/name: *//"` +pkg=$pkgname-$pkgver +set -x +cabal sdist && +cd dist && +if [ -d ../.git ] +then + # on git repo, test if files are the same + git -C .. ls-files | sort > ls-git && + tar -tf $pkg.tar.gz | grep -v "/$" | sed -e "s,$pkg/,," | sort > ls-cabal && + diff -rud ls-git ls-cabal && + rm -f ls-git ls-cabal +else + # outside of git repo, test build + rm -rf $pkg/ && + tar -xzf $pkg.tar.gz && + cd $pkg/ && + cabal configure --enable-tests --enable-benchmarks && + cabal build && + cabal test +fi diff --git a/tests/update-test-model b/tests/update-test-model new file mode 100644 --- /dev/null +++ b/tests/update-test-model @@ -0,0 +1,74 @@ +#!/bin/bash +top=`dirname $0`/.. +eg=$top/eg +model=$top/tests/model + +case "$1" in + -*) sz="$1" + shift + ;; +esac + +test-model() { + $1 $sz | diff -rud $model/$2$sz.out - || exit 1 +} + +update-test-model() { + $1 $sz > $model/$2$sz.out +} + +tym() { + /usr/bin/time -f%e "$@" +} + +spc() { + /usr/bin/time -f%M "$@" +} + +mean() { + sum="`echo -n $* | sed -e "s/ / + /g"`" + mean="`echo "scale = 3; ($sum) / $#" | bc`" + printf "%3.3f\n" $mean +} +export -f mean + +div1024() { + printf "%3.0f\n" "`echo "$1 / 1024" | bc`" +} +export -f div1024 + +benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +memory-benchmark() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + printf "%-18s " "$2$sz" + for run in {1..3} + do + spc $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean | + xargs bash -c 'div1024 "$@"' div1024 +} + +benchmark-cmp() { + [ -x $1 ] || { echo "$0: not found $1"; return 1; } + grep "^ *$2$sz " bench/runtime-$HOSTNAME | tr '\n' ' ' + echo -n ' ' + for run in {1..1} + do + tym $1 $sz 2>&1 >/dev/null + done | xargs bash -c 'mean "$@"' mean +} + +find $* | sed -e "s/^bench/ /;s/^eg/ /" | +sort -b | sed -e "s/^ /bench/;s/^ /eg/" | +while read e +do + `basename $0` $top/$e `basename $e` +done