speculate 0.3.4 → 0.3.5

raw patch · 175 files changed

+11670/−2 lines, 175 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

.gitignore +111/−0
.travis.yml +107/−0
Makefile +234/−0
bench/arith-c +3/−0
bench/arithficial.hs +27/−0
bench/bool-c +3/−0
bench/list-c +3/−0
bench/minus-c +3/−0
bench/nord.hs +26/−0
bench/qs1/Makefile +42/−0
bench/qs1/arith-negate-abs.hs +15/−0
bench/qs1/arith-negate-abs.out +48/−0
bench/qs1/arith.hs +15/−0
bench/qs1/arith.out +30/−0
bench/qs1/arithficial.hs +23/−0
bench/qs1/arithficial.out +36/−0
bench/qs1/bool.hs +11/−0
bench/qs1/bool.out +44/−0
bench/qs1/list.hs +15/−0
bench/qs1/list.out +55/−0
bench/qs1/plus-abs.hs +13/−0
bench/qs1/plus-abs.out +38/−0
bench/qs1/regexes.hs +48/−0
bench/qs1/regexes.out +48/−0
bench/qs1/runtime-zero +7/−0
bench/qs2/Makefile +58/−0
bench/qs2/arith-negate-abs.hs +14/−0
bench/qs2/arith-negate-abs.out +40/−0
bench/qs2/arith.hs +13/−0
bench/qs2/arith.out +21/−0
bench/qs2/arithficial.hs +22/−0
bench/qs2/arithficial.out +19/−0
bench/qs2/binarytree.hs +121/−0
bench/qs2/binarytree.out +55/−0
bench/qs2/binarytree.out1 +55/−0
bench/qs2/binarytree.out2 +55/−0
bench/qs2/binarytree.out3 +37/−0
bench/qs2/binarytree.out4 +44/−0
bench/qs2/binarytree.out5 +55/−0
bench/qs2/binarytree.out6 +55/−0
bench/qs2/binarytree.runtime-zero +6/−0
bench/qs2/bool.hs +12/−0
bench/qs2/bool.out +32/−0
bench/qs2/insertsort.hs +21/−0
bench/qs2/insertsort.out +37/−0
bench/qs2/list-ineq.hs +19/−0
bench/qs2/list.hs +14/−0
bench/qs2/list.out +15/−0
bench/qs2/plus-abs-ineq.hs +16/−0
bench/qs2/plus-abs.hs +14/−0
bench/qs2/plus-abs.out +24/−0
bench/qs2/regexes.hs +60/−0
bench/qs2/regexes.out +11/−0
bench/qs2/runtime-zero +10/−0
bench/qs2/zip.hs +23/−0
bench/qs2/zip.out +35/−0
bench/runtime-zero +31/−0
bench/unit.hs +11/−0
bin/compare-arith +23/−0
bin/compare-arithficial +30/−0
bin/compare-bool +23/−0
bin/compare-with-qs +22/−0
bin/run-heavy-regexes-benchmark +13/−0
eg/Digraph.hs +214/−0
eg/Regex.hs +52/−0
eg/Set.hs +243/−0
eg/Taut.hs +47/−0
eg/algebraic-graphs.hs +79/−0
eg/arith-negate-abs.hs +18/−0
eg/arith.hs +11/−0
eg/binarytree.hs +121/−0
eg/binarytree0.hs +111/−0
eg/bool.hs +14/−0
eg/colour.hs +90/−0
eg/digraphs.hs +68/−0
eg/fun.hs +14/−0
eg/insertsort.hs +32/−0
eg/insertsort0.hs +21/−0
eg/length.hs +24/−0
eg/list.hs +25/−0
eg/minus.hs +15/−0
eg/monad.hs +19/−0
eg/oddeven.hs +33/−0
eg/pretty-compact.hs +55/−0
eg/pretty.hs +41/−0
eg/ratio.hs +24/−0
eg/regexes.hs +124/−0
eg/sets.hs +42/−0
eg/speculate-reason.hs +67/−0
eg/string.hs +18/−0
eg/tauts.hs +38/−0
eg/tuples.hs +28/−0
eg/zip.hs +17/−0
mk/depend.mk +2030/−0
mk/ghcdeps +49/−0
mk/haddock-i +24/−0
mk/haskell.mk +110/−0
speculate.cabal +46/−2
stack.yaml +16/−0
tests/benchmark +74/−0
tests/benchmark-cmp +74/−0
tests/benchmark-save +3/−0
tests/memory-benchmark +74/−0
tests/model/algebraic-graphs-s4.out +51/−0
tests/model/algebraic-graphs-s7.out +64/−0
tests/model/algebraic-graphs.out +58/−0
tests/model/arith-c-s4.out +183/−0
tests/model/arith-c.out +183/−0
tests/model/arith-negate-abs-s4.out +40/−0
tests/model/arith-negate-abs.out +68/−0
tests/model/arith-s4.out +23/−0
tests/model/arith.out +27/−0
tests/model/arithficial-s4.out +26/−0
tests/model/arithficial.out +27/−0
tests/model/binarytree-s4.out +41/−0
tests/model/binarytree.out +55/−0
tests/model/binarytree0-s4.out +31/−0
tests/model/binarytree0.out +45/−0
tests/model/bool-c-s4.out +124/−0
tests/model/bool-c.out +124/−0
tests/model/bool-s4.out +38/−0
tests/model/bool.out +55/−0
tests/model/colour-s4.out +88/−0
tests/model/colour.out +88/−0
tests/model/digraphs-s4.out +41/−0
tests/model/digraphs.out +59/−0
tests/model/fun-s4.out +21/−0
tests/model/fun.out +23/−0
tests/model/insertsort-s4.out +41/−0
tests/model/insertsort.out +71/−0
tests/model/insertsort0-s4.out +30/−0
tests/model/insertsort0.out +37/−0
tests/model/length-s4.out +20/−0
tests/model/length.out +23/−0
tests/model/list-c-s4.out +777/−0
tests/model/list-c.out +777/−0
tests/model/list-s4.out +26/−0
tests/model/list.out +37/−0
tests/model/minus-c-s4.out +232/−0
tests/model/minus-c.out +232/−0
tests/model/minus-s4.out +25/−0
tests/model/minus.out +27/−0
tests/model/monad-s4.out +21/−0
tests/model/monad.out +23/−0
tests/model/nord-s4.out +15/−0
tests/model/nord.out +15/−0
tests/model/oddeven-s4.out +44/−0
tests/model/oddeven.out +52/−0
tests/model/plus-abs-s4.out +40/−0
tests/model/plus-abs.out +68/−0
tests/model/pretty-compact-s4.out +32/−0
tests/model/pretty-compact.out +32/−0
tests/model/pretty-s4.out +20/−0
tests/model/pretty.out +33/−0
tests/model/ratio-s4.out +59/−0
tests/model/ratio.out +114/−0
tests/model/regexes-s4.out +45/−0
tests/model/regexes.out +45/−0
tests/model/sets-s4.out +50/−0
tests/model/sets.out +81/−0
tests/model/speculate-reason-s4.out +28/−0
tests/model/speculate-reason.out +28/−0
tests/model/string-s4.out +47/−0
tests/model/string.out +73/−0
tests/model/tauts-s4.out +33/−0
tests/model/tauts.out +37/−0
tests/model/tuples-s4.out +36/−0
tests/model/tuples.out +35/−0
tests/model/unit-s4.out +13/−0
tests/model/unit.out +13/−0
tests/model/zip-s4.out +23/−0
tests/model/zip.out +25/−0
tests/test-model +74/−0
tests/test-sdist +28/−0
tests/update-test-model +74/−0

+ .gitignore view

@@ -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

+ .travis.yml view

@@ -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 <rudy@matela.com.br>++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

+ Makefile view

@@ -0,0 +1,234 @@+# Makefile for Speculate+#+# Copyright:   (c) 2015-2018 Rudy Matela+# License:     3-Clause BSD  (see the file LICENSE)+# Maintainer:  Rudy Matela <rudy@matela.com.br>+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 $<

+ bench/arith-c view

@@ -0,0 +1,3 @@+#!/bin/bash+EG=`dirname "$0"`/../eg+$EG/arith -ES -r0 -r1 -r2 -r3

+ bench/arithficial.hs view

@@ -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+      ]+  }

+ bench/bool-c view

@@ -0,0 +1,3 @@+#!/bin/bash+EG=`dirname "$0"`/../eg+$EG/bool  -ES -r0 -r1 -r2 -r3

+ bench/list-c view

@@ -0,0 +1,3 @@+#!/bin/bash+EG=`dirname "$0"`/../eg+$EG/list  -ES -r0 -r1 -r2 -r3

+ bench/minus-c view

@@ -0,0 +1,3 @@+#!/bin/bash+EG=`dirname "$0"`/../eg+$EG/minus -ES -r0 -r1 -r2 -r3

+ bench/nord.hs view

@@ -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)+                ]+  }

+ bench/qs1/Makefile view

@@ -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

+ bench/qs1/arith-negate-abs.hs view

@@ -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)+    ]

+ bench/qs1/arith-negate-abs.out view

@@ -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)+

+ bench/qs1/arith.hs view

@@ -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+    ]

+ bench/qs1/arith.out view

@@ -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)+

+ bench/qs1/arithficial.hs view

@@ -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)+    ]

+ bench/qs1/arithficial.out view

@@ -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+

+ bench/qs1/bool.hs view

@@ -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` (||)+    ]

+ bench/qs1/bool.out view

@@ -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&&not 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&&not q == not (p||q)+ 21: not p||not q == not (p&&q)+

+ bench/qs1/list.hs view

@@ -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])+    ]

+ bench/qs1/list.out view

@@ -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)+

+ bench/qs1/plus-abs.hs view

@@ -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)+  ]

+ bench/qs1/plus-abs.out view

@@ -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))+

+ bench/qs1/regexes.hs view

@@ -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+  ]

+ bench/qs1/regexes.out view

@@ -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)+

+ bench/qs1/runtime-zero view

@@ -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

+ bench/qs2/Makefile view

@@ -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

+ bench/qs2/arith-negate-abs.hs view

@@ -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)+      ]+  }

+ bench/qs2/arith-negate-abs.out view

@@ -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)+

+ bench/qs2/arith.hs view

@@ -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)+      ]+  }

+ bench/qs2/arith.out view

@@ -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))+

+ bench/qs2/arithficial.hs view

@@ -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)+      ]+  }

+ bench/qs2/arithficial.out view

@@ -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)+

+ bench/qs2/binarytree.hs view

@@ -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

+ bench/qs2/binarytree.out view

@@ -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)+

+ bench/qs2/binarytree.out1 view

@@ -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)+

+ bench/qs2/binarytree.out2 view

@@ -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)+

+ bench/qs2/binarytree.out3 view

@@ -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)+

+ bench/qs2/binarytree.out4 view

@@ -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)))+

+ bench/qs2/binarytree.out5 view

@@ -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)+

+ bench/qs2/binarytree.out6 view

@@ -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)+

+ bench/qs2/binarytree.runtime-zero view

@@ -0,0 +1,6 @@+37.020+37.130+22.720+23.000+37.650+36.530

+ bench/qs2/bool.hs view

@@ -0,0 +1,12 @@+import QuickSpec++main = quickSpec signature+  { maxTermSize = Just 5+  , constants =+      [ constant "False" False+      , constant "True"  True+      , constant "not" not+      , constant "&&" (&&)+      , constant "||" (||)+      ]+  }

+ bench/qs2/bool.out view

@@ -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)+

+ bench/qs2/insertsort.hs view

@@ -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)+      ]+  }

+ bench/qs2/insertsort.out view

@@ -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)+

+ bench/qs2/list-ineq.hs view

@@ -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+      ]+  }

+ bench/qs2/list.hs view

@@ -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])+      ]+  }

+ bench/qs2/list.out view

@@ -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+

+ bench/qs2/plus-abs-ineq.hs view

@@ -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)+      ]+  }

+ bench/qs2/plus-abs.hs view

@@ -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)+      ]+  }

+ bench/qs2/plus-abs.out view

@@ -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))+

+ bench/qs2/regexes.hs view

@@ -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)+      ]+  }

+ bench/qs2/regexes.out view

@@ -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+

+ bench/qs2/runtime-zero view

@@ -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

+ bench/qs2/zip.hs view

@@ -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

+ bench/qs2/zip.out view

@@ -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))+

+ bench/runtime-zero view

@@ -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

+ bench/unit.hs view

@@ -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 :: () -> ())+      ]+  }

+ bin/compare-arith view

@@ -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

+ bin/compare-arithficial view

@@ -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

+ bin/compare-bool view

@@ -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

+ bin/compare-with-qs view

@@ -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

+ bin/run-heavy-regexes-benchmark view

@@ -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)

+ eg/Digraph.hs view

@@ -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]+

+ eg/Regex.hs view

@@ -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

+ eg/Set.hs view

@@ -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

+ eg/Taut.hs view

@@ -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'))

+ eg/algebraic-graphs.hs view

@@ -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

+ eg/arith-negate-abs.hs view

@@ -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)+--    ]+  }

+ eg/arith.hs view

@@ -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)+      ]+  }

+ eg/binarytree.hs view

@@ -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)+      ]+  }

+ eg/binarytree0.hs view

@@ -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)+      ]+  }

+ eg/bool.hs view

@@ -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 "==>" (==>)+      ]+  }

+ eg/colour.hs view

@@ -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+      ]+  }

+ eg/digraphs.hs view

@@ -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]+      ]+  }

+ eg/fun.hs view

@@ -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))+      ]+  }

+ eg/insertsort.hs view

@@ -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+  }

+ eg/insertsort0.hs view

@@ -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+  }

+ eg/length.hs view

@@ -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) ]+  }

+ eg/list.hs view

@@ -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)+      ]+  }

+ eg/minus.hs view

@@ -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+      ]+  }

+ eg/monad.hs view

@@ -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]))+      ]+  }

+ eg/oddeven.hs view

@@ -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!+-}+  }

+ eg/pretty-compact.hs view

@@ -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+      ]+  }

+ eg/pretty.hs view

@@ -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+      ]+  }

+ eg/ratio.hs view

@@ -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)+      ]+  }

+ eg/regexes.hs view

@@ -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+  }

+ eg/sets.hs view

@@ -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+      ]+  }

+ eg/speculate-reason.hs view

@@ -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+      ]+  }

+ eg/string.hs view

@@ -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]+      ]+  }

+ eg/tauts.hs view

@@ -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+      ]+  }

+ eg/tuples.hs view

@@ -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))+      ]+  }

+ eg/zip.hs view

@@ -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+  }

+ mk/depend.mk view

@@ -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

+ mk/ghcdeps view

@@ -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 <<LIST+#   program.hs+#   Library.hs+#   Path/To/Library.hs+#   LIST+#   program: ...+#   Library.o: ...+#   Path/To/Library.o: ...+#+# Or:+#   $ find -name \*.hs -o -name \*.lhs | ghcdeps [GHCFLAGS]+#   ...+#+# Note that when using find, you have to remember to exclude unecessary files,+# e.g.:  dist, Setup.hs+#+# Yes, this is hacky.  But hey, it works.+while read fn+do+	ghc "$@" -dep-suffix=. -dep-makefile=tmp.mk -M "$fn" ||+	exit 1+	deps="`cat tmp.mk |+	       grep "hs$" |+	       sort |+	       sed -e "s/.*: //" |+	       tac |+	       tr '\n' ' ' |+	       sed -e "s/ $//"`"+	obj=`echo $fn | sed -e 's,^\./,,;s/\.hs$/.o/'`+	bin=`echo $fn | sed -e 's,^\./,,;s/\.hs$//'`+	echo "$obj: $deps"+	grep -q "main" "$fn" && echo "$bin: `echo $deps | sed -e 's|[^ ]*src[^ ]*||g'` mk/toplibs"+	rm -f tmp.mk+done |+sort |+sed -e 's,  *, \\\n  ,g'

+ mk/haddock-i view

@@ -0,0 +1,24 @@+#!/bin/bash+#+# haddock-i: list haddock's -i parameters.+#+# Copyright (c) 2015-2017 Rudy Matela.+# Distributed under the 3-Clause BSD licence.+#+# $ haddock-i <package1> <package2> ... <packageN>+#+# 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 <files>+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/"

+ mk/haskell.mk view

@@ -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)

speculate.cabal view

@@ -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

+ stack.yaml view

@@ -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: []

+ tests/benchmark view

@@ -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

+ tests/benchmark-cmp view

@@ -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

+ tests/benchmark-save view

@@ -0,0 +1,3 @@+#!/bin/bash+top=`dirname $0`+$top/benchmark "$@" | tee bench/runtime-$HOSTNAME

+ tests/memory-benchmark view

@@ -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

+ tests/model/algebraic-graphs-s4.out view

@@ -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+

+ tests/model/algebraic-graphs-s7.out view

@@ -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+

+ tests/model/algebraic-graphs.out view

@@ -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+

+ tests/model/arith-c-s4.out view

@@ -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

+ tests/model/arith-c.out view

@@ -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

+ tests/model/arith-negate-abs-s4.out view

@@ -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+

+ tests/model/arith-negate-abs.out view

@@ -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+

+ tests/model/arith-s4.out view

@@ -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+

+ tests/model/arith.out view

@@ -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+

+ tests/model/arithficial-s4.out view

@@ -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+

+ tests/model/arithficial.out view

@@ -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+

+ tests/model/binarytree-s4.out view

@@ -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+

+ tests/model/binarytree.out view

@@ -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)+

+ tests/model/binarytree0-s4.out view

@@ -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+

+ tests/model/binarytree0.out view

@@ -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)+

+ tests/model/bool-c-s4.out view

@@ -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

+ tests/model/bool-c.out view

@@ -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

+ tests/model/bool-s4.out view

@@ -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++

+ tests/model/bool.out view

@@ -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)++

+ tests/model/colour-s4.out view

@@ -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+

+ tests/model/colour.out view

@@ -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+

+ tests/model/digraphs-s4.out view

@@ -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+

+ tests/model/digraphs.out view

@@ -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+

+ tests/model/fun-s4.out view

@@ -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++

+ tests/model/fun.out view

@@ -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)++

+ tests/model/insertsort-s4.out view

@@ -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++

+ tests/model/insertsort.out view

@@ -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+

+ tests/model/insertsort0-s4.out view

@@ -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)++

+ tests/model/insertsort0.out view

@@ -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+

+ tests/model/length-s4.out view

@@ -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+

+ tests/model/length.out view

@@ -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)+

+ tests/model/list-c-s4.out view

@@ -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

+ tests/model/list-c.out view

@@ -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

+ tests/model/list-s4.out view

@@ -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+

+ tests/model/list.out view

@@ -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)+

+ tests/model/minus-c-s4.out view

@@ -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

+ tests/model/minus-c.out view

@@ -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

+ tests/model/minus-s4.out view

@@ -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+

+ tests/model/minus.out view

@@ -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+

+ tests/model/monad-s4.out view

@@ -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++

+ tests/model/monad.out view

@@ -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))++

+ tests/model/nord-s4.out view

@@ -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+++

+ tests/model/nord.out view

@@ -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+++

+ tests/model/oddeven-s4.out view

@@ -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+

+ tests/model/oddeven.out view

@@ -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+

+ tests/model/plus-abs-s4.out view

@@ -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+

+ tests/model/plus-abs.out view

@@ -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+

+ tests/model/pretty-compact-s4.out view

@@ -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+

+ tests/model/pretty-compact.out view

@@ -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+

+ tests/model/pretty-s4.out view

@@ -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+

+ tests/model/pretty.out view

@@ -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)+

+ tests/model/ratio-s4.out view

@@ -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+

+ tests/model/ratio.out view

@@ -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+

+ tests/model/regexes-s4.out view

@@ -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+

+ tests/model/regexes.out view

@@ -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+

+ tests/model/sets-s4.out view

@@ -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+

+ tests/model/sets.out view

@@ -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))++

+ tests/model/speculate-reason-s4.out view

@@ -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+

+ tests/model/speculate-reason.out view

@@ -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+

+ tests/model/string-s4.out view

@@ -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+

+ tests/model/string.out view

@@ -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 ++ " ")+

+ tests/model/tauts-s4.out view

@@ -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+

+ tests/model/tauts.out view

@@ -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+

+ tests/model/tuples-s4.out view

@@ -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)++

+ tests/model/tuples.out view

@@ -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)++

+ tests/model/unit-s4.out view

@@ -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 :: () -> ()+++

+ tests/model/unit.out view

@@ -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 :: () -> ()+++

+ tests/model/zip-s4.out view

@@ -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+++

+ tests/model/zip.out view

@@ -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+

+ tests/test-model view

@@ -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

+ tests/test-sdist view

@@ -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

+ tests/update-test-model view

@@ -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