Slightly modify fcb for list1 and put in common place.

Experiments with Let

Eval can be defined with additional freshness

Minor simplification

abs_res_fcb will be enough to finish the multiple-recursive proof, if we have a working 'default'.

More experiments with 'default'

Finished the proof with the invariant

Issue with 'default'

merged

merged

using the option "default" the function package allows one to give an explicit default value

Simpler proof of TypeSchemes/substs

Simplify fcb_res

FCB for res binding and simplified proof of subst for type schemes

Simplify ln-trans proof

cbvs can be easily defined without an invariant

defined the "count-bound-variables-occurences" function which has an accumulator like trans

merged

remove garbage (proofs that assumes the invariant outside function)

Proof of trans with invariant

Testing invariant in Lambda_F_T

cleaned ups a bit the examples with the invariant framework; exported nominal_function_config datatype into separate structure and file

fixed problem with earlier commit about nominal_function_common; added facility for specifying an invariant - added a definition of frees_set which need a finiteness invariant

slightly stronger property in fundef_ex_prop

added an option for an invariant (at the moment only a stub)

added a more general lemma fro fundef_ex1

Trying the induction on the graph

Finish and test the locale approach

FiniteSupp precondition in the function is enough to get rid of completeness obligationss

recursion combinator inside a locale

merge

F for lambda used to define translation to locally nameless

typo

removed dead code

finished the missing obligations

merged

a test with a recursion combinator defined on top of nominal_primrec

Use FCB to simplify proof

merge

Remove SMT

hopefully final fix for ho-functions

first test to fix the problem with free variables

proved subst for All constructor in type schemes.

DB translation using index; easier to reason about.

Problem: free variables in the goal

fixed previous commit

equivariance of db_trans

fixed the problem with cps-like functions

DeBruijn translation in a simplifier friendly way

map_term can be defined when equivariance is assumed

map_term is not a function the way it is defined

Defined translation from nominal to de-Bruijn; with a freshness condition for the lambda case.

Simple eqvt proofs with perm_simps for clarity

tuned last commit

functions involving if and case do not throw exceptions anymore; but eqvt_at assumption has now a precondition

updated to new Isabelle

added eq_iff and distinct lemmas of nominal datatypes to the simplifier

more on slides

added slides for copenhagen

added a problem with inductive_cases (reported by Randy)

misc

made the subtyping work again

updated to new Isabelle (> 9 May)

merged

added two mutual recursive inductive definitions

deleted two functions from the API

proved that lfp is equivariant (that simplifies equivariance proofs of inductively defined predicates)

more on pearl-paper

more on pearl-paper

updated Quotient paper so that it compiles again

merged

added slides for beijing

more to the pearl paper

updated to snapshot Isabelle 19 April

merged

added permute_pure back into the nominal_inductive procedure; updated to Isabelle 17 April

New way of forward elimination of Abs1_eq and simplifications of the function obligation proofs.

merged

introduced framework for finetuning eqvt-rules; this solves problem with permute_pure called in nominal_inductive

shanghai slides

pictures for slides

Shanghai slides

more paper

eqvt of supp and fresh is proved using equivariance infrastructure

more paper

more on the paper

tuned paper

tuned paper

typo

more on paper

eqvt_lambda without eta-expansion

changed default preprocessor that does not catch variables only occuring on the right

final version of slides

more on the slides

tuned IsaMakefile

rearranged directories and updated to new Isabelle

precise path to LaTeXsugar

a lit bit more on the pearl-jv paper

ported changes from function package....needs Isabelle 16 March or above

more on the pearl paper

equivariance for All and Ex can be proved in terms of their definition

more on the paper

merged

more on the pearl paper

distinct names at toplevel

merge

Pairing function

updated pearl papers

a bit more tuning

included old test cases for perm_simp into ROOT.ML file

split the library into a basics file; merged Nominal_Eqvt into Nominal_Base

some slight polishing

merged

added a lemma about fresh_star and Abs

Reduce the definition of trans to FCB; test that FCB can be proved with simp rules.

typeschemes/subst

further experiments with typeschemes subst

Finished the proof of a function that invents fresh variable names.

added eqvt for length

added eqvt lemmas for filter and distinct

added eqvt for cartesian products

cleaned up the experiments so that the tests go through

merge

Experiments defining a function on Let

updated TODO

Lambda.thy which works with Nominal_Isabelle2011

merged

removed diagnostic code

Only one of the subgoals is needed

Experiments with substitution on set+

More properties that relate abs_res and abs_set. Also abs_res with less binders.

alpha_res implies alpha_set :)

Showing that the binders difference is fresh for the left side solves the goal for 'set'.

Experiments with functions

some experiments

the proofs with eqvt_at

made eqvt-proof explicit in the function definitions

merge

minor

Down as infixr

added some slides

added Tutorial6

cleaning up

merged

cleaned up Tutorial 3 with solutions

Missing val.simps

merge

Tutorial 4s

cleaned up and solution section

cleaned up tutorial1...added solution file

better version of Tutorial 1

better flow of proofs and definitions and proof

separated type preservation and progress into a separate file

substitution lemma in separate file

added unbind example

a bit tuning

first split of tutorrial theory

added a very rough version of the tutorial; all seems to work

added obtain_fresh lemma; tuned Lambda.thy

base file for the tutorial (contains definitions for heigt, subst and beta-reduction)

ported some of the old proofs to serve as testcases

added eqvt and supp lemma for removeAll (function from List.thy)

theory name as it should be

removed diagnostic code

added Minimal file to test things

defined height as a function that returns an integer

deleted diagnostic code

some tryes about substitution over type-schemes

defined properly substitution

derived stronger Abs_eq_iff2 theorems

made alpha_abs_set_stronger1 stronger

removed finiteness assumption from set_rename_perm

alpha_abs_set_stronger1

alpha_abs_let_stronger is not true in the same form

the function translating lambda terms to locally nameless lambda terms; still needs a stronger abs_eq_iff lemma...at the moment only proved for restrictions

modified the renaming_perm lemmas

added a translation function from lambda-terms to deBruijn terms (equivariance fails at the moment)

added a few examples of functions to Lambda.thy

exported nominal function code to external file

removed old testing code from Lambda.thy

moved high level code from LamTest into the main libraries.

eliminated tracing code; added flag so that equivariance is only proved for the function graph, not the relation

subst also works now

nominal_function works now completely for frees and depth; still a propbelm with subst; no unproved assumptions

strengthened renaming lemmas

added eqvt_lemmas for subset and psubset

a few lemmas about freshness for at and at_base

added a property about finite support in the presense of eqvt_at

instantiated fundef_ex1_eqvt_at theorem with the indction hypothesis

solved subgoals for depth and subst function

added eqvt_at premises in function definition - however not proved at the moment

added one further lemma about equivariance of THE_default

equivariance of THE_default under the uniqueness assumption

derived equivariance for the function graph and function relation

a modified function package where, as a test, True has been injected into the compatibility condictions

removed last traces of debugging code

removed debugging code abd introduced a guarded tracing function

moved Weakening up....it does not compile when put at the last position

tuned

added weakening to the test cases

cleaned up weakening proof and added a version with finit sets

same

some further lemmas for fsets

made sure the raw datatypes and raw functions do not get any mixfix syntax

exported the code into a separate file

strong rule inductions; as an example the weakening lemma works

final version of the ESOP paper; used set+ instead of res as requested by one reviewer

file with most of the strong rule induction development

simple cases for string rule inductions

changed res keyword to set+ for restrictions; comment by a referee

added proper case names for all induct and exhaust theorems

added small example for strong inductions; functions still need a sorry

removed local fix for bug in induction_schema; added setup method for strong inductions

automated all strong induction lemmas

proper application of induction_schema and strong_exhaust rules; needs local fix in induction_schema.ML

generated goals for strong induction theorems.

test with strong inductions

moved all strong_exhaust code to nominal_dt_quot; tuned examples

moved generic functions into nominal_library

slight tuning

slight tuning

tuned examples

added fold_right which produces the correct term for left-infix operators

updated to Isabelle 22 December

a bit tuning

corrected premises of strong exhausts theorems

properly exported strong exhaust theorem; cleaned up some examples

all examples for strong exhausts work; recursive binders need to be treated differently; still unclean version with lots of diagnostic code

one interesting case done

a stronger statement for at_set_avoiding

tuned

tuned

simple cases for strong inducts done; infrastructure for the difficult ones is there

added theorem-rewriter conversion

freshness theorem in strong exhausts; (temporarily includes a cheat_tac to make all tests go through)

created strong_exhausts terms

moved setify and listify functions into the library; introduced versions that have a type argument

updated

a bit more tuning of the paper

brought the paper to 20 pages plus one page appendix

first tests about exhaust

moved some code into the nominal_library

moved definition of raw bn-functions into nominal_dt_rawfuns

kept the nested structure of constructors (belonging to one datatype)

moved general theorems into the libraries

automated permute_bn theorems

updated to changes in Isabelle

deleted nominal_dt_supp.ML

moved code from nominal_dt_supp to nominal_dt_quot

automated alpha_perm_bn theorems

ordered raw_bn_info to agree with the order of the raw_bn_functions; started alpha_bn proof

updated to Isabelle 2nd December

isarfied some of the high-level proofs

added abs_rename_res lemma

completed proofs in Foo2

completed the strong exhausts rules for Foo2 using general lemmas

tuned proof to reduce number of warnings

disabled the Foo examples, because of heavy work

slightly simplified the Foo2 tests and hint at a general lemma

completely different method fro deriving the exhaust lemma

merged

merged

added example from the F-ing paper by Rossberg, Russo and Dreyer

implemented concrete suggestion of 3rd reviewer

missing freshness assumptions

foo2 strong induction

foo2 full exhausts

Foo2 strong_exhaust for first variable.

single rename in let2

current isabelle

added example Foo2.thy

tuned example

proved that bn functions return a finite set

added a test for the various shallow binders

fixed bug in fv function where a shallow binder binds lists of names

merged Nominal-General directory into Nominal; renamed Abs.thy to Nominal2_Abs.thy

deleted special Nominal2_FSet theory

moved rest of the lemmas from Nominal2_FSet to the TypeScheme example

moved most material fron Nominal2_FSet into the Nominal_Base theory

tuned example

lifted permute_bn simp rules

lifted permute_bn constants

respectfulness for permute_bn functions

automated permute_bn functions (raw ones first)

adapted to changes by Florian on the quotient package and removed local fix for function package

expanded the paper by uncommenting the comments and adding the appendix

fixed locally the problem with the function package; all tests work again

added a test about subtyping; disabled two tests, because of problem with function package

small typo

squeezed qpaper to 6 pages

Qpaper / Move examples to commented out appendix

Unanonymize qpaper

FSet changes for Qpaper

Remove FSet and use the one from Isabelle

took out comment about map-types / adapted to recent changes

use definitions instead of functions

tuned

used functions instead of definitions

added missing style file

Use the generalized compositional quotient theorem

fixed typo

all tests work again

some tuning

naming scheme is now *_fset (not f*_)

more cleaning

further tuning

renamed fminus_raw to diff_list

renamed fcard_raw to card_list

slight update

Further reorganisation and cleaning

further cleaning

typo

FSet: stronger fact in Isabelle.

FSet synchronizing

Synchronizing FSet further.

Partially merging changes from Isabelle

fixed the typo in the abstract and the problem with append (the type of map_k and map_list seems to be indeed incorrect....did not yet look at this)

changed format of the pearl paper

deleted some unused lemmas

major reorganisation of fset (renamed fset_to_set to fset, changed the definition of list_eq and fcard_raw)

more on the pearl paper

added a section about abstractions

tiny work on the pearl paper

tuned

added apendix to paper detailing one proof

minor

minor

down to 20 pages

minor

down to 21 pages and changed strong induction section

tuned

down to 22 pages

down to 23 pages

down to 24 pages and a bit

llncs and more sqeezing

first part of sqeezing everything into 20 pages (at the moment we have 26)

changed to llncs

merged

minor experiments

merged

simplified exhaust proofs

Made the paper to compile with the renamings.

merged

worked example Foo1 with induct_schema

merged

use also induct_schema for the Let-example (permute_bn is used)

test with induct_schema for simpler strong_ind proofs

substitution definition with 'next_name'.

merged

added Foo1 to explore a contrived example

added postprocessed fresh-lemmas for constructors

post-processed eq_iff and supp threormes according to the fv-supp equality

more consistent naming in Abs.thy

some experiments

added simp rules for prod_fv and prod_alpha

a few more words about Ott

lifted size_thms and exported them as <name>.size

cleaned up two examples

added example about datatypes

updated to Isabelle 22 Sept

removed dead code

fixed

made supp proofs more robust by not using the standard induction; renamed some example files

introduced a general procedure for structural inductions; simplified reflexivity proof

updated to Isabelle Sept 16

updated to Isabelle Sept 13

tuned code

tuned (to conform with indentation policy of Markus)

supp-proofs work except for CoreHaskell and Modules (induct is probably not finding the correct instance)

generated inducts rule by Project_Rule.projections

added the definition supp_rel (support w.r.t. a relation)

merged

got rid of Nominal2_Supp (is now in Nomina2_Base)

moved everything out of Nominal_Supp

renamed alpha_gen -> alpha_set and Abs -> Abs_set etc

moved a proof to Abs

got rid of Nominal_Atoms (folded into Nominal2_Base)

cleaned a bit various thy-files in Nominal-General

adapted paper to changes

made the fv-definition aggree more with alpha (needed in the support proofs)

removed lemma finite_set (already in simpset)

added supp_set lemma

some experiments with support

added eqvt-attribute for permute_abs lemmas

slides of my talk

merge

update qpaper to new isabelle

No need to unfold mem_def with rsp/prs (requires new isabelle).

Anonymize, change Quotient to Quot and fix indentation

renamed NewParser to Nominal2

tuned

updated todos

added fs-instance proofs

added proofs for fsupp properties

fiexed problem with constructors that have no arguments

proved supports lemmas

slight cleaning

updated to new Isabelle

cut out most of the lifting section and cleaned up everything

made all typographic changes

first pass on section 1

make copies of the "old" files

Ball Bex can be lifted after unfolding.

"isabelle make test" makes all major examples....they work up to supp theorems (excluding)

merged

corrected bug with fv-function generation (that was the problem with recursive binders)

minor

cleaned up (almost completely) the examples

cleaning of unused files and code

automatic lifting

everything now lifts as expected

now every lemma lifts (even with type variables)

can now deal with type variables in nominal datatype definitions

updated to new Isabelle

merged

updated to new Isabelle

not needed anymore

moved lifting code from Lift.thy to nominal_dt_quot.ML

nominal_datatypes with type variables do not work

changed parser so that the binding mode is indicated as "bind (list)", "bind (set)" or "bind (res)"; if only "bind" is given, then bind (list) is assumed as default

Clarifications to FIXMEs.

Finished adding remarks from the reviewers.

few remaining remarks as fixme's.

used @{const_name} hopefully everywhere

Intuition behind REL

add missing mathpartir

Add 2 FIXMEs

The type does determine respectfulness, the constant without an instantiated type does not.

Add the SAC stylesheet and updated root file.

TODO

further comments from the referees

fixes for referees

put everything in a "timeit"

improved runtime slightly, by constructing an explicit size measure for the function definitions

more tuning of the code

deleted unused code

improved code

can also lift the various eqvt lemmas for bn, fv, fv_bn and size

also able to lift the bn_defs

added rsp-lemmas for alpha_bns

cezary made the eq_iff lemmas to lift (still needs some infrastructure in quotient)

pinpointed the problem

modified the code for class instantiations (with help from Florian)

defined qperms and qsizes

simplified code

improved code

more experiments with lifting

updated to Isabelle 12th Aug

rsp for constructors

updated to Isabelle 11 Aug

added a function that transforms the helper-rsp lemmas into real rsp lemmas

proved rsp-helper lemmas of size functions

tuning

further simplification with alpha_prove

introduced a general alpha_prove method

equivariance for size

helper lemmas for rsp-lemmas

tests

cleaned up a bit Abs.thy

fixed order of fold_union to make alpha and fv agree

small cleaning

added paper by james; some minor cleaning

samll changes

made compatible

added

updated to new Isabelle; made FSet more "quiet"

merged

minor

minor polishing

quote for a new paper

corrected lambda-preservation theorem

minor

minor things on the paper

merged

minor things

some test with quotient

some minor changes

changes suggested by Peter Homeier

tests

submitted version