# Re: [Agda] x ∈ (append y xs) → ..

Ulf Norell ulf.norell at gmail.com
Wed Dec 18 22:56:22 CET 2013

```I'm not sure why you are leaving out cases. If you give all the appropriate
cases lemma1 goes through with no problems. Here's my version (with
slightly different definitions from yours):

lemma1 : ∀ x y xs → x ∈ append y xs → x ≡ y ∨ x ∈ xs
lemma1 x .x [] here = inl refl
lemma1 x y [] (there p) = inr p
lemma1 x y (.x ∷ xs) here = inr here
lemma1 x y (x₁ ∷ xs) (there p) with lemma1 x y xs p
lemma1 x y (x₂ ∷ xs) (there p) | inl x=y = inl x=y
lemma1 x y (x₂ ∷ xs) (there p) | inr x∈xs = inr (there x∈xs)

The reason you get the "I'm not sure..." error is that Agda gets confused
when trying to figure out which patterns are missing. I get the same error
for lemma0 though.

/ Ulf

On Wed, Dec 18, 2013 at 6:52 PM, Andreas Abel <andreas.abel at ifi.lmu.de>wrote:

> --Andreas
>
>
> On 18.12.2013 12:23, Sergei Meshveliani wrote:
>
>> Can anybody explain, please, why the below  lemma1  is more difficult to
>> prove to Agda than  lemma0
>> ?
>>
>> append0 : List ℕ → List ℕ
>> append0 []       =  0 ∷ []
>> append0 (x ∷ xs) =  x ∷ (append0 xs)
>>
>> append : ℕ → List ℕ → List ℕ
>> append x []       =  x ∷ []
>> append x (y ∷ xs) =  y ∷ (append x xs)
>>
>> open module Mem-ℕ = Membership natSetoid using (_∈_)
>>
>> ---------------------------------------------------------------------
>> lemma0 : (x : ℕ) → (xs : List ℕ) → x ∈ (append0 xs) → x ≡ 0 ⊎ (x ∈ xs)
>>
>> lemma0 _ [] (here x=y) =  inj₁ x=y
>> ...
>> -- skip other patterns
>>
>> --------------------------------------------------------------------
>> lemma1 : (x y : ℕ) → (xs : List ℕ) → x ∈ (append y xs) →
>>                                           x ≡ y ⊎ (x ∈ xs)
>> lemma1 _ _ [] (here x=y) =  inj₁ x=y
>> --------------------------------------------------------------------
>>
>> lemma0  is proved in a natural way, and is type-checked.
>>
>> For  lemma1,
>> I expected of the checker to report of "missing patterns" -- which will
>> mean that the first pattern is all right.
>>
>> And the   development Agda of November ~20 2013
>> reports
>> "
>> I'm not sure if there should be a case for the constructor here,
>> because I get stuck when trying to solve the following unification
>> problems (inferred index ≟ expected index):
>>    x₁ ∷ xs₁ ≟ append y xs
>> when checking the definition of lemma1
>> ".
>>
>> I fix the proof by writing a strange complicated code instead of the
>> first pattern:
>>
>>    lemma1 x y [] x∈app-y-xs =  inj₁ x=y
>>      where
>>      x=y : x ≡ y
>>      x=y  with x∈app-y-xs
>>      ... | here eq = eq
>>      ... | there ()
>>
>> This looks strange: the checker is sure and "is not sure" in a pattern
>> which is actually the same.
>> I guess that for the first pattern, it is not sure that  append y []
>> is non-empty. But it follows only from normalization.
>>
>> Does this present a bug?
>>
>> Thanks,
>>
>> ------
>> Sergei
>>
>>
>> _______________________________________________
>> Agda mailing list
>> Agda at lists.chalmers.se
>> https://lists.chalmers.se/mailman/listinfo/agda
>>
>>
>
> --
> Andreas Abel  <><      Du bist der geliebte Mensch.
>
> Theoretical Computer Science, University of Munich
> Oettingenstr. 67, D-80538 Munich, GERMANY
>
> andreas.abel at ifi.lmu.de
> http://www2.tcs.ifi.lmu.de/~abel/
>
> _______________________________________________
> Agda mailing list
> Agda at lists.chalmers.se
> https://lists.chalmers.se/mailman/listinfo/agda
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.chalmers.se/pipermail/agda/attachments/20131218/36d4d55c/attachment.html
```