michael/lean2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
2167 commits 3 branches 0 tags 28 MiB
Commit graph

1858 commits

Author SHA1 Message Date
Leonardo de Moura
d79e9af210 fix(frontends/lean): help msg 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-18 09:31:30 -08:00
Leonardo de Moura
f781ad823c doc(builtin): Diaconescu’s theorem 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-18 09:12:09 -08:00
Leonardo de Moura
e9dada5e14 refactor(builtin/kernel): use standard definition for 'or' and 'and' 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-17 12:05:34 -08:00
Leonardo de Moura
4692e04d70 feat(builtin/proof_irrel): prove proof irrelevance 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-16 18:06:10 -08:00
Leonardo de Moura
c526e5ec00 feat(builtin/kernel): prove false_elim without using case 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-15 14:26:13 -08:00
Leonardo de Moura
1739b5c153 fix(kernel/type_checker): caching bug 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-12 10:43:01 -08:00
Leonardo de Moura
c740d9d799 fix(builtin/num): bug in the factorial definition 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-12 10:04:32 -08:00
Leonardo de Moura
45a0dbcc34 feat(builtin/num): define fact and exp 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-12 09:51:49 -08:00
Leonardo de Moura
368fcb5ff9 refactor(builtin/kernel): rename refute to by_contradiction 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-12 08:49:19 -08:00
Leonardo de Moura
69bccb6014 feat(builtin): define list, cons, nil and prove basic theorems 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-11 21:32:05 -08:00
Leonardo de Moura
bfe64a7031 fix(library/elaborator): hack for fixing a bug due to pairs/projs, this is temporary fix until we build a new elaborator 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-11 21:30:26 -08:00
Leonardo de Moura
0878b44fc7 feat(frontends/lean): allow user to import several theories using a single import 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-11 17:15:12 -08:00
Leonardo de Moura
11a2b3016f fix(builtin/num): remove hacks for making the elaborator happy 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-10 14:05:51 -08:00
Leonardo de Moura
b7b868de85 fix(library/elaborator): bug reported by Jeremy Avigad 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-10 14:01:22 -08:00
Leonardo de Moura
a2d2e36f04 refactor(frontends/lean): remove notation for creating tuples 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-10 09:03:42 -08:00
Leonardo de Moura
4e08a3233e fix(builtin): build dependency issue 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-10 08:33:07 -08:00
Leonardo de Moura
273f78d1cb feat(builtin/num): prove strong induction and other theorems for num 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 21:09:50 -08:00
Leonardo de Moura
b119c11473 feat(builtin/tactic): add simp_no_assump tactic 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 20:28:30 -08:00
Leonardo de Moura
4317f67bd2 fix(builtin/tactic): more meaningful error message when skip tactic is used in a full proof 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 18:57:33 -08:00
Leonardo de Moura
57982135d9 fix(library/simplifier): bug using congr1 theorem 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 16:24:29 -08:00
Leonardo de Moura
c45c1748d8 refactor(builtin/kernel): reorder congr1 arguments 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 16:15:44 -08:00
Leonardo de Moura
fd6f8b1945 refactor(builtin/num): simplify proofs using 'by simp' 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 15:03:45 -08:00
Leonardo de Moura
2d70e2f4f2 fix(library/tactic/goal): bug in the proof builder 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 15:02:36 -08:00
Leonardo de Moura
4c76f6abb9 chore(builtin/num): remove leftover 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 11:39:26 -08:00
Leonardo de Moura
8df7c7b02d feat(kernel/type_checker): remove fallback that expands opaque definitions in the type checker 
We should not rely on this feature. It can be quite expensive.
We invoke is_convertible in several places, in particular, if we are using overloading. For example, the frontend uses is_convertible to check which overload should be used. Thus, it will make several calls such as

   is_convertible(num, Nat)

If is_convertible starts unfolding opaque definitions, we would keep expanding num.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 11:31:24 -08:00
Leonardo de Moura
4c4c8b3e0d feat(builtin/num): prove basic theorems using simplifier 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 11:24:53 -08:00
Leonardo de Moura
633ed6bb69 fix(frontends/lean/parser): bug in add_rewrite 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 09:46:56 -08:00
Leonardo de Moura
b24c085cb0 feat(frontends/lean): avoid warning message 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-09 09:26:51 -08:00
Leonardo de Moura
d6167eae32 feat(builtin/num): define add and mul 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-08 22:28:15 -08:00
Leonardo de Moura
cc4148a98d feat(builtin/num): primitive recursion theorem 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-08 22:05:57 -08:00
Leonardo de Moura
f28c56b188 feat(builtin/num): add auxiliary definitions and theorems for proving the primitive recursion theorem 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-08 19:36:17 -08:00
Leonardo de Moura
fa4b60963b feat(builtin/num): define lt predicate, and prove basic theorems 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-08 10:57:17 -08:00
Leonardo de Moura
1f3e0f7a38 chore(builtin/num): update object file 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-08 09:16:52 -08:00
Leonardo de Moura
aeaa803f9a feat(builtin): add num type (the base type that will be used to build nat, int, real) 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-08 09:12:53 -08:00
Leonardo de Moura
1c43020fc9 fix(library/tactic/goal): bug creating main proof builder 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-08 09:11:07 -08:00
Leonardo de Moura
24528ff685 fix(library/elaborator): fix glitches in the elaborator that were forcing us to provide parameters explicitly 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-07 18:02:08 -08:00
Leonardo de Moura
1ec01f5757 refactor(builtin): merge pair.lean with kernel.lean, and add basic theorems 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-07 16:04:44 -08:00
Leonardo de Moura
ad7b13104f feat(*): add support for heterogeneous equality in the parser, elaborator and simplifier, adjusts unit test to reflect changes 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-07 15:03:16 -08:00
Leonardo de Moura
6d7ec9d7b6 refactor(kernel): add heterogeneous equality back to expr 
The main motivation is that we will be able to move equalities between universes.

For example, suppose we have
    A : (Type i)
    B : (Type i)
    H : @eq (Type j) A B
where j > i

We didn't find any trick for deducing (@eq (Type i) A B) from H.
Before this commit, heterogeneous equality as a constant with type

   heq : {A B : (Type U)} : A -> B -> Bool

So, from H, we would only be able to deduce

   (@heq (Type j) (Type j) A B)

Not being able to move the equality back to a smaller universe is
problematic in several cases. I list some instances in the end of the commit message.

With this commit, Heterogeneous equality is a special kind of expression.
It is not a constant anymore. From H, we can deduce

   H1 : A == B

That is, we are essentially "erasing" the universes when we move to heterogeneous equality.
Now, since A and B have (Type i), we can deduce (@eq (Type i) A B) from H1. The proof term is

  (to_eq (Type i) A B (to_heq (Type j) A B H))  :  (@eq (Type i) A B)

So, it remains to explain why we need this feature.

For example, suppose we want to state the Pi extensionality axiom.

axiom hpiext {A A' : (Type U)} {B : A → (Type U)} {B' : A' → (Type U)} :
      A = A' → (∀ x x', x == x' → B x == B' x') → (∀ x, B x) == (∀ x, B' x)

This axiom produces an "inflated" equality at (Type U) when we treat heterogeneous
equality as a constant. The conclusion

     (∀ x, B x) == (∀ x, B' x)

is syntax sugar for

   (@heq (Type U) (Type U) (∀ x : A, B x) (∀ x : A', B' x))

Even if A, A', B, B' live in a much smaller universe.

As I described above, it doesn't seem to be a way to move this equality back to a smaller universe.

So, if we wanted to keep the heterogeneous equality as a constant, it seems we would
have to support axiom schemas. That is, hpiext would be parametrized by the universes where
A, A', B and B'. Another possibility would be to have universe polymorphism like Agda.
None of the solutions seem attractive.

So, we decided to have heterogeneous equality as a special kind of expression.
And use the trick above to move equalities back to the right universe.

BTW, the parser is not creating the new heterogeneous equalities yet.
Moreover, kernel.lean still contains a constant name heq2 that is the heterogeneous
equality as a constant.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-07 10:28:10 -08:00
Leonardo de Moura
354d5607af chore(builtin/sum): cleanup 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 21:25:57 -08:00
Leonardo de Moura
d4b08fcf96 feat(library/elaborator): be 'lazy' when normalizing terms in the elaborator 
Unification constraints of the form

         ctx |- ?m[inst:i v] == T

         and

         ctx |- (?m a1 ... an) == T

are delayed by elaborator because the produce case-splits.
On the other hand, the step that puts terms is head-normal form is eagerly applied.
This is a bad idea for constraints like the two above. The elaborator will put T in head normal form
before executing process_meta_app and process_meta_inst. This is just wasted work, and creates
fully unfolded terms for solvers and provers.

The new test demonstrates the problem. In this test, we mark several terms as non-opaque.
Without this commit, the produced goal is a huge term.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 21:08:00 -08:00
Leonardo de Moura
ff955f9830 chore(frontends/lean/parser): update comments 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 20:56:31 -08:00
Leonardo de Moura
593f1f2ebd fix(frontends/lean): allow user set constants defined in other namespaces as opaque 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 20:56:31 -08:00
Leonardo de Moura
363c4dc5c2 feat(library/elaborator): improve support for dependent pairs in the elaborator 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 20:56:31 -08:00
Leonardo de Moura
4b4b5e3345 fix(frontends/lean): import explicit versions when using the command 'using' 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 17:33:58 -08:00
Leonardo de Moura
ea06bb2885 feat(frontends/lean/pp): change how lift local entries are pretty printed 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 17:26:38 -08:00
Leonardo de Moura
a51139e63b feat(frontends/lean): position information in error messages 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 17:26:38 -08:00
Leonardo de Moura
e85b1f1ac0 feat(library/elaborator): expose elaborator configuration options 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 17:26:38 -08:00
Leonardo de Moura
e4579b93e4 fix(library/elaborator): try first projection before imitation in the higher-order unifier 
Projections build more general solutions. This commit also adds a test that demonstrates the issue. Before this commit, the elaborator would produce the "constant" predicate (fun x, a + b = b + a).

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 13:35:05 -08:00
Leonardo de Moura
ef321e730f feat(builtin/tactic): add the 'skip' (bogus) tactic for ignoring a proof hole in a big proof 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 12:47:23 -08:00
Leonardo de Moura
581ae0c83b chore(build): fix build dependencies 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 09:30:33 -08:00
Leonardo de Moura
db3bcdba55 refactor(builtin): move pair definition and theorems to pair.lean 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 09:20:52 -08:00
Leonardo de Moura
daf7075ce4 refactor(builtin/sum): use new 'have' expression to formalize optional-types 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 09:15:12 -08:00
Leonardo de Moura
5d698a60a7 refactor(builtin/sum): use new 'have' expression to formalize sum-types 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 08:59:05 -08:00
Leonardo de Moura
1d23d93e60 feat(frontends/lean): new 'have' expression 
Add 'have' notation suggested by Jeremy Avigad.
Add his example to the test suite.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 08:03:59 -08:00
Leonardo de Moura
ba9a8f9d98 feat(frontends/lean): add 'show' expression syntax sugar 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 07:50:22 -08:00
Leonardo de Moura
90f5a4f813 feat(builtin/sum): cleanup, and avoid unicode character that is not available in some platforms 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-06 00:20:49 -08:00
Leonardo de Moura
c01f82aeb7 feat(builtin): add sum types 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-05 23:04:44 -08:00
Leonardo de Moura
87da23649b feat(builtin/optional): prove dichotomy and induction theorems for optional types 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-05 19:49:50 -08:00
Leonardo de Moura
30570c843f feat(builtin): add optional type 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-05 17:33:06 -08:00
Leonardo de Moura
aec9c84d0d fix(util/lua): deadlock 
Errors in the Lua library produce longjmps.
The longjmp will not unwind the C++ stack.
In the new test, the lock was not being released, and the system was deadlocking in the next call that tried to lock the environment

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 15:16:29 -08:00
Leonardo de Moura
f4ec874c6e refactor(builtin): remove dead module heq 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 14:42:28 -08:00
Leonardo de Moura
0283887ee9 refactor(builtin/kernel): move the heq axioms into kernel.lean 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 14:17:34 -08:00
Leonardo de Moura
493007b7bc fix(frontends/lean/pp): bug in tuple/pair pretty printing 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 13:58:01 -08:00
Leonardo de Moura
f03c09c10b feat(library/elaborator): add support for proj/pair/sigma in the the higher-order unification procedure 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 13:53:30 -08:00
Leonardo de Moura
c9b72df34b fix(frontends/lean/parser): bug when applying tactics to synthesize remaining meta-variables 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 11:36:26 -08:00
Leonardo de Moura
9dc86e3cf5 fix(builtin/kernel): rename generalized proof_irrel axiom to hproof_irrel, and derive the restricted one 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 10:06:29 -08:00
Leonardo de Moura
9a677331da feat(builtin): simulate subtypes using sigma types 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-04 01:46:50 -08:00
Leonardo de Moura
61d0c792ff fix(frontends/lean/parser): bug in tuple/proj1/proj2 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-03 22:46:29 -08:00
Leonardo de Moura
4fcc292332 feat(frontends/lean): parse and pretty print pair/tuple projection operators proj1 and proj2, fix bug in the type checker 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-03 22:10:01 -08:00
Leonardo de Moura
cc96b50644 feat(frontends/lean): support for nary-tuples, improve notation for non-dependent tuples, add support in the elaborator for sigma types 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-03 20:53:11 -08:00
Leonardo de Moura
5c991f8fbf feat(frontends/lean): parse and pretty print tuples/pairs 
This commit also fixes a bug in the type checker when processing dependent pairs.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-03 20:10:30 -08:00
Leonardo de Moura
5e5ab1429d feat(frontends/lean): parse and pretty print sigma types 
This commit also fixes some bugs in the implementation of Sigma types.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-03 18:16:00 -08:00
Leonardo de Moura
8eec289ce1 feat(kernel): add dependent pairs 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-03 16:52:49 -08:00
Leonardo de Moura
6be50f0133 refactor(builtin/heq): merge cast and heq modules 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-02 15:01:48 -08:00
Leonardo de Moura
c56df132b8 refactor(kernel): remove semantic attachments from the kernel 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-02-02 14:48:27 -08:00
Leonardo de Moura
e3dc552c39 fix(library/simplifier): nontermination 
The example tests/lua/simp1.lua demonstrates the issue.
The higher-order matcher matches closed terms that are definitionally equal.
So, given a definition

    definition a := 1

it will match 'a' with '1' since they are definitionally equal.

Then, if we have a theorem

    theorem a_eq_1 : a = 1

as a rewrite rule, it was triggering the following infinite loop when simplifying the expression "a"

   a --> 1 --> 1 --> 1 ...

The first simplification is expected. The other ones are not.
The problem is that "1" is definitionally equal to "a", and they match.
The rewrite_rule_set manager accepts the rule a --> 1 since the left-hand-side does not occur in the right-hand-side.

To avoid this loop, we test if the new expression is not equal to the previous one.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-31 15:55:21 -08:00
Leonardo de Moura
1d85267d26 fix(library/simplifier): assumptions/context may contain equations where the left-hand-side is a metavariable or semantic attachment 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-31 15:38:22 -08:00
Leonardo de Moura
110ca84984 feat(library/simplifier): allow the user to associate a simplifier monitor with the lua_State object 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-31 13:49:24 -08:00
Leonardo de Moura
0ed35e2133 fix(build): kernel.lean depends on tactic.lua 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 23:15:44 -08:00
Leonardo de Moura
2aaded261e fix(kernel/environment): imported predicate 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 23:02:19 -08:00
Leonardo de Moura
bc2d504ccc feat(builtin/kernel): add rewrite rules for if-then-else 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 22:38:35 -08:00
Leonardo de Moura
b444756d20 fix(library/simplifier): missing condition in implication simplification 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 22:14:01 -08:00
Leonardo de Moura
4d533c6a25 feat(builtin/kernel): add nonempty_range theorem 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 22:13:34 -08:00
Leonardo de Moura
ddaf948c72 feat(builtin/kernel): add nonempty_fun theorem 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 19:38:51 -08:00
Leonardo de Moura
759aa61f70 refactor(builtin/kernel): define if-then-else using Hilbert's operator 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 19:28:42 -08:00
Leonardo de Moura
b45ab9dc30 feat(library/elaborator): use equality constraints instead of convertability constraints on definitions 
Convertability constraints are harder to solve than equality constraints, and it seems they don't buy us anything definitions. They are just increasing the search space for the elaborator.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 14:13:21 -08:00
Leonardo de Moura
8c1f6b9055 fix(kernel/typechecker): allow elaborator to infer (Type U+1) 
In the new test elab8.lean, the parameter B is in (Type U+1).
Before, this commit, the type checker was forcing all metavariables that must be types to be <= (Type U). This restriction was preventing the elaborator from succeeding in reasonable cases.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-30 14:00:01 -08:00
Leonardo de Moura
41f5e2a067 feat(library/simplifier): statically check (conditional) equations (aka rewrite rules) to verify whether we can skip type checking when using them in the simplifier 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 18:32:40 -08:00
Leonardo de Moura
01259b1e84 feat(kernel): make sure U is the maximal universe 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 16:31:00 -08:00
Leonardo de Moura
ea6bf224e5 feat(frontends/lean): make the parser accept (Type -> ...) 
Before this commit, the parser would accept only a universe level or a ')' after '(' 'Type'

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 15:23:20 -08:00
Leonardo de Moura
4f3127d3d5 fix(library/simplifier): check if the given types are convertible to ceq expected types 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 15:15:55 -08:00
Leonardo de Moura
a19f9d4846 feat(library/simplifier): discard conditional equations that are clearly non-terminating 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 13:56:45 -08:00
Leonardo de Moura
dd6aae378f fix(library/simplifier): must use metavar_env in is_ceq, otherwise it may ceqs that contain metavariables 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 13:29:20 -08:00
Leonardo de Moura
4dc3aa46c3 feat(frontends/lean): allow tactics to be used in axiom/variable declarations and in the type of definitions/theorems; add a new test showing the need for this feature 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 12:02:12 -08:00
Leonardo de Moura
069e5edf6b fix(library/simplifier): include flag indicating if the proof generated by simplifier is a homogenous or heterogenous equality, use flag to fix bug in the simp_tactic 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 12:01:01 -08:00
Leonardo de Moura
f0a2d3627e refactor(frontends/lean): use ascii prefix for auxiliary let-declarations 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 11:58:09 -08:00
Leonardo de Moura
92ba4e8b2d feat(library/simplifier): add support for metavariables in conditional rewrite rules 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 08:34:04 -08:00
Leonardo de Moura
f101554e93 fix(util/script_exception): make sure a script_nested_exception may have a nested script_nested_exception, use LEAN_THREAD_LOCAL macro instead of thread_local 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-29 08:07:52 -08:00
Leonardo de Moura
24452289dd feat(library/simplifier): make sure the simplifier can handle meta-variables 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
 2014-01-28 20:30:47 -08:00