2013-09-04 20:21:57 +00:00
|
|
|
|
Set: pp::colors
|
|
|
|
|
Set: pp::unicode
|
|
|
|
|
Assumed: f
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Failed to solve
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ (?M::1 ≈ λ x : ℕ, x) ⊕ (?M::1 ≈ nat_to_int) ⊕ (?M::1 ≈ nat_to_real)
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 4: pos: 8) Coercion for
|
|
|
|
|
10
|
|
|
|
|
Failed to solve
|
|
|
|
|
⊢ Bool ≺ ℕ
|
|
|
|
|
Substitution
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ Bool ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 4: pos: 6) Type of argument 3 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-10-25 02:08:35 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::0
|
|
|
|
|
?M::1 10
|
2013-10-25 02:08:35 +00:00
|
|
|
|
⊤
|
|
|
|
|
Assignment
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ ℕ ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Substitution
|
2013-12-14 20:25:00 +00:00
|
|
|
|
⊢ ?M::5[inst:0 (10)] ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 4: pos: 6) Type of argument 2 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-10-25 02:08:35 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::0
|
|
|
|
|
?M::1 10
|
2013-10-25 02:08:35 +00:00
|
|
|
|
⊤
|
|
|
|
|
Assignment
|
2013-12-14 20:25:00 +00:00
|
|
|
|
x : ℕ ⊢ ℕ ≈ ?M::5
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Destruct/Decompose
|
2013-12-14 20:25:00 +00:00
|
|
|
|
⊢ ℕ → ℕ ≈ Π x : ?M::4, ?M::5
|
|
|
|
|
Substitution
|
|
|
|
|
⊢ ?M::3 ≈ Π x : ?M::4, ?M::5
|
|
|
|
|
Function expected at
|
|
|
|
|
?M::1 10
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ℕ → ℕ ≺ ?M::3
|
|
|
|
|
Propagate type, ?M::1 : ?M::3
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ?M::1 ≈ λ x : ℕ, x
|
|
|
|
|
Assumption 0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Failed to solve
|
|
|
|
|
⊢ Bool ≺ ℤ
|
|
|
|
|
Substitution
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ Bool ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 4: pos: 6) Type of argument 3 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-10-25 02:08:35 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::0
|
|
|
|
|
?M::1 10
|
2013-10-25 02:08:35 +00:00
|
|
|
|
⊤
|
|
|
|
|
Assignment
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ ℤ ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Substitution
|
2013-12-14 20:25:00 +00:00
|
|
|
|
⊢ ?M::5[inst:0 (10)] ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 4: pos: 6) Type of argument 2 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-10-25 02:08:35 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::0
|
|
|
|
|
?M::1 10
|
2013-10-25 02:08:35 +00:00
|
|
|
|
⊤
|
|
|
|
|
Assignment
|
2013-12-19 22:47:53 +00:00
|
|
|
|
a : ℕ ⊢ ℤ ≈ ?M::5
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Destruct/Decompose
|
2013-12-14 20:25:00 +00:00
|
|
|
|
⊢ ℕ → ℤ ≈ Π x : ?M::4, ?M::5
|
|
|
|
|
Substitution
|
|
|
|
|
⊢ ?M::3 ≈ Π x : ?M::4, ?M::5
|
|
|
|
|
Function expected at
|
|
|
|
|
?M::1 10
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ℕ → ℤ ≺ ?M::3
|
|
|
|
|
Propagate type, ?M::1 : ?M::3
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ?M::1 ≈ nat_to_int
|
|
|
|
|
Assumption 1
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Failed to solve
|
|
|
|
|
⊢ Bool ≺ ℝ
|
|
|
|
|
Substitution
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ Bool ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 4: pos: 6) Type of argument 3 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-10-25 02:08:35 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::0
|
|
|
|
|
?M::1 10
|
2013-10-25 02:08:35 +00:00
|
|
|
|
⊤
|
|
|
|
|
Assignment
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ ℝ ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Substitution
|
2013-12-14 20:25:00 +00:00
|
|
|
|
⊢ ?M::5[inst:0 (10)] ≺ ?M::0
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 4: pos: 6) Type of argument 2 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-10-25 02:08:35 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::0
|
|
|
|
|
?M::1 10
|
2013-10-25 02:08:35 +00:00
|
|
|
|
⊤
|
|
|
|
|
Assignment
|
2013-12-19 22:47:53 +00:00
|
|
|
|
a : ℕ ⊢ ℝ ≈ ?M::5
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Destruct/Decompose
|
2013-12-14 20:25:00 +00:00
|
|
|
|
⊢ ℕ → ℝ ≈ Π x : ?M::4, ?M::5
|
|
|
|
|
Substitution
|
|
|
|
|
⊢ ?M::3 ≈ Π x : ?M::4, ?M::5
|
|
|
|
|
Function expected at
|
|
|
|
|
?M::1 10
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ℕ → ℝ ≺ ?M::3
|
|
|
|
|
Propagate type, ?M::1 : ?M::3
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ?M::1 ≈ nat_to_real
|
|
|
|
|
Assumption 2
|
2013-09-04 20:21:57 +00:00
|
|
|
|
Assumed: g
|
2013-12-21 06:00:50 +00:00
|
|
|
|
Error (line: 7, pos: 8) invalid expression, it still contains metavariables after elaboration, metavariable: ?M::1, type:
|
|
|
|
|
Type
|
2013-09-04 20:21:57 +00:00
|
|
|
|
Assumed: h
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Failed to solve
|
2013-12-14 20:25:00 +00:00
|
|
|
|
x : ?M::0, A : Type ⊢ ?M::0 ≺ A
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 11: pos: 27) Type of argument 2 must be convertible to the expected type in the application of
|
|
|
|
|
h
|
|
|
|
|
with arguments:
|
|
|
|
|
A
|
|
|
|
|
x
|
2013-10-29 23:20:02 +00:00
|
|
|
|
Assumed: my_eq
|
2013-10-25 02:08:35 +00:00
|
|
|
|
Failed to solve
|
2013-11-07 18:16:22 +00:00
|
|
|
|
A : Type, B : Type, a : ?M::0, b : ?M::1, C : Type ⊢ ?M::0[lift:0:3] ≺ C
|
2013-10-25 02:08:35 +00:00
|
|
|
|
(line: 15: pos: 51) Type of argument 2 must be convertible to the expected type in the application of
|
2013-10-29 23:20:02 +00:00
|
|
|
|
my_eq
|
2013-10-25 02:08:35 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
C
|
|
|
|
|
a
|
|
|
|
|
b
|
2013-09-04 20:21:57 +00:00
|
|
|
|
Assumed: a
|
|
|
|
|
Assumed: b
|
|
|
|
|
Assumed: H
|
2013-12-06 21:04:26 +00:00
|
|
|
|
Failed to solve
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
⊢ ?M::0 ⇒ ?M::3 ∧ a ≺ b
|
|
|
|
|
Substitution
|
|
|
|
|
⊢ ?M::0 ⇒ ?M::1 ≺ b
|
|
|
|
|
(line: 20: pos: 18) Type of definition 't1' must be convertible to expected type.
|
|
|
|
|
Assignment
|
|
|
|
|
H1 : ?M::2 ⊢ ?M::3 ∧ a ≺ ?M::1
|
|
|
|
|
Substitution
|
|
|
|
|
H1 : ?M::2 ⊢ ?M::3 ∧ ?M::4 ≺ ?M::1
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
⊢ Π H1 : ?M::2, ?M::3 ∧ ?M::4 ≺ Π a : ?M::0, ?M::1
|
|
|
|
|
(line: 20: pos: 18) Type of argument 3 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@Discharge
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
?M::0
|
|
|
|
|
?M::1
|
|
|
|
|
λ H1 : ?M::2, Conj H1 (Conjunct1 H)
|
|
|
|
|
Assignment
|
|
|
|
|
H1 : ?M::2 ⊢ a ≺ ?M::4
|
|
|
|
|
Substitution
|
|
|
|
|
H1 : ?M::2 ⊢ ?M::5 ≺ ?M::4
|
|
|
|
|
(line: 20: pos: 37) Type of argument 4 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@Conj
|
2013-12-14 23:13:56 +00:00
|
|
|
|
with arguments:
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
?M::3
|
|
|
|
|
?M::4
|
|
|
|
|
H1
|
|
|
|
|
Conjunct1 H
|
|
|
|
|
Assignment
|
|
|
|
|
H1 : ?M::2 ⊢ a ≈ ?M::5
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
H1 : ?M::2 ⊢ a ∧ b ≺ ?M::5 ∧ ?M::6
|
|
|
|
|
(line: 20: pos: 45) Type of argument 3 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@Conjunct1
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
?M::5
|
|
|
|
|
?M::6
|
|
|
|
|
H
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
|
|
|
|
⊢ b ≈ a
|
2013-10-29 09:11:06 +00:00
|
|
|
|
Substitution
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ b ≈ ?M::3
|
2013-10-29 09:11:06 +00:00
|
|
|
|
Destruct/Decompose
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ b == b ≺ ?M::3 == ?M::4
|
2013-10-25 02:56:44 +00:00
|
|
|
|
(line: 22: pos: 22) Type of argument 6 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@Trans
|
2013-10-25 02:56:44 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::1
|
|
|
|
|
?M::2
|
|
|
|
|
?M::3
|
|
|
|
|
?M::4
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Refl a
|
|
|
|
|
Refl b
|
2013-10-29 09:11:06 +00:00
|
|
|
|
Assignment
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ a ≈ ?M::3
|
2013-10-29 09:11:06 +00:00
|
|
|
|
Destruct/Decompose
|
2013-11-07 18:16:22 +00:00
|
|
|
|
⊢ a == a ≺ ?M::2 == ?M::3
|
2013-10-29 09:11:06 +00:00
|
|
|
|
(line: 22: pos: 22) Type of argument 5 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@Trans
|
2013-10-29 09:11:06 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::1
|
|
|
|
|
?M::2
|
|
|
|
|
?M::3
|
|
|
|
|
?M::4
|
2013-10-29 09:11:06 +00:00
|
|
|
|
Refl a
|
|
|
|
|
Refl b
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ (?M::1 ≈ Type) ⊕ (?M::1 ≈ Bool)
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Destruct/Decompose
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≺ Type
|
|
|
|
|
(line: 24: pos: 6) Type of argument 1 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-10-25 02:56:44 +00:00
|
|
|
|
with arguments:
|
2013-11-07 18:16:22 +00:00
|
|
|
|
?M::0
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Bool
|
|
|
|
|
Bool
|
|
|
|
|
Failed to solve
|
2013-12-21 11:58:39 +00:00
|
|
|
|
⊢ (?M::0 ≈ Type) ⊕ (?M::0 ≈ (Type 1)) ⊕ (?M::0 ≈ (Type M)) ⊕ (?M::0 ≈ (Type U))
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Destruct/Decompose
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ Type ≺ ?M::0
|
|
|
|
|
(line: 24: pos: 6) Type of argument 2 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-12-15 07:23:57 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
?M::0
|
|
|
|
|
Bool
|
|
|
|
|
Bool
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 1) ≺ Type
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 1) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ?M::0 ≈ Type
|
|
|
|
|
Assumption 1
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Type
|
|
|
|
|
Assumption 0
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 2) ≺ Type
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 2) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ ?M::0 ≈ (Type 1)
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Assumption 2
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Type
|
|
|
|
|
Assumption 0
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type M+1) ≺ Type
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type M+1) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ ?M::0 ≈ (Type M)
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 3
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Type
|
|
|
|
|
Assumption 0
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type U+1) ≺ Type
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type U+1) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ ?M::0 ≈ (Type U)
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 4
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Type
|
|
|
|
|
Assumption 0
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-21 11:58:39 +00:00
|
|
|
|
⊢ (?M::0 ≈ Type) ⊕ (?M::0 ≈ (Type 1)) ⊕ (?M::0 ≈ (Type M)) ⊕ (?M::0 ≈ (Type U))
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Destruct/Decompose
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ Type ≺ ?M::0
|
|
|
|
|
(line: 24: pos: 6) Type of argument 2 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@f
|
2013-12-15 07:23:57 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
?M::0
|
|
|
|
|
Bool
|
|
|
|
|
Bool
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 1) ≺ Bool
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 1) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
|
|
|
|
⊢ ?M::0 ≈ Type
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 6
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Bool
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 5
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 2) ≺ Bool
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type 2) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ ?M::0 ≈ (Type 1)
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 7
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Bool
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 5
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type M+1) ≺ Bool
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type M+1) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ ?M::0 ≈ (Type M)
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 8
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Bool
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 5
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type U+1) ≺ Bool
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ (Type U+1) ≺ ?M::1
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Propagate type, ?M::0 : ?M::1
|
|
|
|
|
Assignment
|
2013-12-19 23:23:43 +00:00
|
|
|
|
⊢ ?M::0 ≈ (Type U)
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 9
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Assignment
|
2013-12-15 07:23:57 +00:00
|
|
|
|
⊢ ?M::1 ≈ Bool
|
2013-12-21 11:58:39 +00:00
|
|
|
|
Assumption 5
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Failed to solve
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
a : Bool, b : Bool, H : ?M::2, H_a : ?M::6 ⊢ (a ⇒ b) ⇒ a ≺ a
|
|
|
|
|
Substitution
|
|
|
|
|
a : Bool, b : Bool, H : ?M::2, H_a : ?M::6 ⊢ (a ⇒ b) ⇒ a ≺ ?M::5[lift:0:1]
|
2013-10-25 02:56:44 +00:00
|
|
|
|
Substitution
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
a : Bool, b : Bool, H : ?M::2, H_a : ?M::6 ⊢ ?M::2[lift:0:2] ≺ ?M::5[lift:0:1]
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
a : Bool, b : Bool, H : ?M::2 ⊢ Π H_a : ?M::6, ?M::2[lift:0:2] ≺ Π a : ?M::3, ?M::5[lift:0:1]
|
|
|
|
|
(line: 27: pos: 21) Type of argument 5 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@DisjCases
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
?M::3
|
|
|
|
|
?M::4
|
|
|
|
|
?M::5
|
|
|
|
|
EM a
|
|
|
|
|
λ H_a : ?M::6, H
|
|
|
|
|
λ H_na : ?M::7, NotImp1 (MT H H_na)
|
|
|
|
|
Normalize assignment
|
|
|
|
|
?M::0
|
|
|
|
|
Assignment
|
|
|
|
|
a : Bool, b : Bool ⊢ ?M::2 ≈ ?M::0
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Destruct/Decompose
|
2013-12-19 22:47:53 +00:00
|
|
|
|
a : Bool, b : Bool ⊢ Π H : ?M::2, ?M::5 ≺ Π a : ?M::0, ?M::1[lift:0:1]
|
2013-12-15 07:23:57 +00:00
|
|
|
|
(line: 27: pos: 4) Type of argument 3 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@Discharge
|
2013-12-15 07:23:57 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
?M::0
|
|
|
|
|
?M::1
|
|
|
|
|
λ H : ?M::2, DisjCases (EM a) (λ H_a : ?M::6, H) (λ H_na : ?M::7, NotImp1 (MT H H_na))
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
Assignment
|
|
|
|
|
a : Bool, b : Bool ⊢ ?M::0 ≈ (a ⇒ b) ⇒ a
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
a : Bool, b : Bool ⊢ ?M::0 ⇒ ?M::1 ≺ ((a ⇒ b) ⇒ a) ⇒ a
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
a : Bool ⊢ Π b : Bool, ?M::0 ⇒ ?M::1 ≺ Π b : Bool, ((a ⇒ b) ⇒ a) ⇒ a
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
⊢ Π a b : Bool, ?M::0 ⇒ ?M::1 ≺ Π a b : Bool, ((a ⇒ b) ⇒ a) ⇒ a
|
|
|
|
|
(line: 26: pos: 16) Type of definition 'pierce' must be convertible to expected type.
|
|
|
|
|
Assignment
|
|
|
|
|
a : Bool, b : Bool, H : ?M::2 ⊢ ?M::5 ≺ a
|
|
|
|
|
Substitution
|
|
|
|
|
a : Bool, b : Bool, H : ?M::2 ⊢ ?M::5 ≺ ?M::1[lift:0:1]
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
a : Bool, b : Bool ⊢ Π H : ?M::2, ?M::5 ≺ Π a : ?M::0, ?M::1[lift:0:1]
|
|
|
|
|
(line: 27: pos: 4) Type of argument 3 must be convertible to the expected type in the application of
|
2013-12-22 01:02:16 +00:00
|
|
|
|
@Discharge
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
with arguments:
|
|
|
|
|
?M::0
|
|
|
|
|
?M::1
|
|
|
|
|
λ H : ?M::2, DisjCases (EM a) (λ H_a : ?M::6, H) (λ H_na : ?M::7, NotImp1 (MT H H_na))
|
|
|
|
|
Assignment
|
|
|
|
|
a : Bool, b : Bool ⊢ ?M::1 ≈ a
|
|
|
|
|
Destruct/Decompose
|
|
|
|
|
a : Bool, b : Bool ⊢ ?M::0 ⇒ ?M::1 ≺ ((a ⇒ b) ⇒ a) ⇒ a
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Destruct/Decompose
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
a : Bool ⊢ Π b : Bool, ?M::0 ⇒ ?M::1 ≺ Π b : Bool, ((a ⇒ b) ⇒ a) ⇒ a
|
2013-12-15 07:23:57 +00:00
|
|
|
|
Destruct/Decompose
|
feat(library/elaborator): only expand definitions that are not marked as hidden
The elaborator produces better proof terms. This is particularly important when we have to prove the remaining holes using tactics.
For example, in one of the tests, the elaborator was producing the sub-expression
(λ x : N, if ((λ x::1 : N, if (P a x x::1) ⊥ ⊤) == (λ x : N, ⊤)) ⊥ ⊤)
After, this commit it produces
(λ x : N, ¬ ∀ x::1 : N, ¬ P a x x::1)
The expressions above are definitionally equal, but the second is easier to work with.
Question: do we really need hidden definitions?
Perhaps, we can use only the opaque flag.
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2013-12-20 10:16:41 +00:00
|
|
|
|
⊢ Π a b : Bool, ?M::0 ⇒ ?M::1 ≺ Π a b : Bool, ((a ⇒ b) ⇒ a) ⇒ a
|
|
|
|
|
(line: 26: pos: 16) Type of definition 'pierce' must be convertible to expected type.
|