Theorem: Stream'.Seq.of_mem_append
File: Mathlib/Data/Seq/Seq.lean

tactic: have := h
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ append s₁ s₂
⊢ a ∈ s₁ ∨ a ∈ s₂

tactic: revert this
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h this : a ∈ append s₁ s₂
⊢ a ∈ s₁ ∨ a ∈ s₂

tactic: generalize e : append s₁ s₂ = ss
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ append s₁ s₂
⊢ a ∈ append s₁ s₂ → a ∈ s₁ ∨ a ∈ s₂

tactic: intro h
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ append s₁ s₂
ss : Seq α
e : append s₁ s₂ = ss
⊢ a ∈ ss → a ∈ s₁ ∨ a ∈ s₂

tactic: revert s₁
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h✝ : a ∈ append s₁ s₂
ss : Seq α
e : append s₁ s₂ = ss
h : a ∈ ss
⊢ a ∈ s₁ ∨ a ∈ s₂

tactic: apply mem_rec_on h _
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
⊢ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = ss → a ∈ s₁ ∨ a ∈ s₂

tactic: intro b s' o s₁
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
⊢ ∀ (b : α) (s' : Seq α),
    (a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂) →
      ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = cons b s' → a ∈ s₁ ∨ a ∈ s₂

tactic: apply s₁.recOn _ fun c t₁ => _
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
⊢ a ∈ append s₁ s₂ → append s₁ s₂ = cons b s' → a ∈ s₁ ∨ a ∈ s₂

tactic: intro m _
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
⊢ a ∈ append nil s₂ → append nil s₂ = cons b s' → a ∈ nil ∨ a ∈ s₂

tactic: apply Or.inr
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
m : a ∈ append nil s₂
e✝ : append nil s₂ = cons b s'
⊢ a ∈ nil ∨ a ∈ s₂

tactic: simpa using m
state_before: case h
α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
m : a ∈ append nil s₂
e✝ : append nil s₂ = cons b s'
⊢ a ∈ s₂

tactic: intro c t₁ m e
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
⊢ ∀ (c : α) (t₁ : Seq α), a ∈ append (cons c t₁) s₂ → append (cons c t₁) s₂ = cons b s' → a ∈ cons c t₁ ∨ a ∈ s₂

tactic: have this := congr_arg destruct e
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
⊢ a ∈ cons c t₁ ∨ a ∈ s₂

tactic: cases' show a = c ∨ a ∈ append t₁ s₂ by simpa using m with e' m
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
⊢ a ∈ cons c t₁ ∨ a ∈ s₂

tactic: simpa using m
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
⊢ a = c ∨ a ∈ append t₁ s₂

tactic: rw [e']
state_before: case inl
α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
e' : a = c
⊢ a ∈ cons c t₁ ∨ a ∈ s₂

tactic: exact Or.inl (mem_cons _ _)
state_before: case inl
α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
e' : a = c
⊢ c ∈ cons c t₁ ∨ c ∈ s₂

tactic: cases' show c = b ∧ append t₁ s₂ = s' by simpa with i1 i2
state_before: case inr
α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m✝ : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
m : a ∈ append t₁ s₂
⊢ a ∈ cons c t₁ ∨ a ∈ s₂

tactic: cases' o with e' IH
state_before: case inr.intro
α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m✝ : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
m : a ∈ append t₁ s₂
i1 : c = b
i2 : append t₁ s₂ = s'
⊢ a ∈ cons c t₁ ∨ a ∈ s₂

tactic: simpa
state_before: α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' : Seq α
o : a = b ∨ ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
s₁ : Seq α
c : α
t₁ : Seq α
m✝ : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
m : a ∈ append t₁ s₂
⊢ c = b ∧ append t₁ s₂ = s'

tactic: simp [i1, e']
state_before: case inr.intro.inl
α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' s₁ : Seq α
c : α
t₁ : Seq α
m✝ : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
m : a ∈ append t₁ s₂
i1 : c = b
i2 : append t₁ s₂ = s'
e' : a = b
⊢ a ∈ cons c t₁ ∨ a ∈ s₂

tactic: exact Or.imp_left (mem_cons_of_mem _) (IH m i2)
state_before: case inr.intro.inr
α : Type u
β : Type v
γ : Type w
s₂ : Seq α
a : α
ss : Seq α
h : a ∈ ss
b : α
s' s₁ : Seq α
c : α
t₁ : Seq α
m✝ : a ∈ append (cons c t₁) s₂
e : append (cons c t₁) s₂ = cons b s'
this : destruct (append (cons c t₁) s₂) = destruct (cons b s')
m : a ∈ append t₁ s₂
i1 : c = b
i2 : append t₁ s₂ = s'
IH : ∀ {s₁ : Seq α}, a ∈ append s₁ s₂ → append s₁ s₂ = s' → a ∈ s₁ ∨ a ∈ s₂
⊢ a ∈ cons c t₁ ∨ a ∈ s₂