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

tactic: cases' M with k e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s : Seq α
M : a ∈ s
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
⊢ C s

tactic: unfold Stream'.nth at e
state_before: case intro
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e : (fun b => some a = b) (nth (↑s) k)
⊢ C s

tactic: induction' k with k IH generalizing s
state_before: case intro
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e : (fun b => some a = b) (↑s k)
⊢ C s

tactic: revert e
state_before: case intro.succ
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e✝ : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
e : some a = ↑s (Nat.succ k)
⊢ C s

tactic: apply s.recOn _ fun b s' => _
state_before: case intro.succ
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
⊢ some a = ↑s (Nat.succ k) → C s

tactic: have TH : s = cons a (tail s) := by
  apply destruct_eq_cons
  unfold destruct get? Functor.map
  rw [← e]
  rfl
state_before: case intro.zero
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e✝ : (fun b => some a = b) (↑s✝ k)
s : Seq α
e : some a = ↑s Nat.zero
⊢ C s

tactic: rw [TH]
state_before: case intro.zero
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e✝ : (fun b => some a = b) (↑s✝ k)
s : Seq α
e : some a = ↑s Nat.zero
TH : s = cons a (tail s)
⊢ C s

tactic: apply h1 _ _ (Or.inl rfl)
state_before: case intro.zero
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e✝ : (fun b => some a = b) (↑s✝ k)
s : Seq α
e : some a = ↑s Nat.zero
TH : s = cons a (tail s)
⊢ C (cons a (tail s))

tactic: apply destruct_eq_cons
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e✝ : (fun b => some a = b) (↑s✝ k)
s : Seq α
e : some a = ↑s Nat.zero
⊢ s = cons a (tail s)

tactic: unfold destruct get? Functor.map
state_before: case a
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e✝ : (fun b => some a = b) (↑s✝ k)
s : Seq α
e : some a = ↑s Nat.zero
⊢ destruct s = some (a, tail s)

tactic: rw [← e]
state_before: case a
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e✝ : (fun b => some a = b) (↑s✝ k)
s : Seq α
e : some a = ↑s Nat.zero
⊢ instFunctorOption.1 (fun a' => (a', tail s)) (↑s 0) = some (a, tail s)

tactic: rfl
state_before: case a
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
e✝ : (fun b => some a = b) (↑s✝ k)
s : Seq α
e : some a = ↑s Nat.zero
⊢ instFunctorOption.1 (fun a' => (a', tail s)) (some a) = some (a, tail s)

tactic: intro e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
⊢ some a = ↑nil (Nat.succ k) → C nil

tactic: injection e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e✝ : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
e : some a = ↑nil (Nat.succ k)
⊢ C nil

tactic: intro b s' e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
⊢ ∀ (b : α) (s' : Seq α), some a = ↑(cons b s') (Nat.succ k) → C (cons b s')

tactic: have h_eq : (cons b s').val (Nat.succ k) = s'.val k := by cases s' ; rfl
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e✝ : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑(cons b s') (Nat.succ k)
⊢ C (cons b s')

tactic: rw [h_eq] at e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e✝ : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑(cons b s') (Nat.succ k)
h_eq : ↑(cons b s') (Nat.succ k) = ↑s' k
⊢ C (cons b s')

tactic: apply h1 _ _ (Or.inr (IH e))
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e✝ : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑s' k
h_eq : ↑(cons b s') (Nat.succ k) = ↑s' k
⊢ C (cons b s')

tactic: cases s'
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e✝ : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑(cons b s') (Nat.succ k)
⊢ ↑(cons b s') (Nat.succ k) = ↑s' k

tactic: rfl
state_before: case mk
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
s✝ : Seq α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k✝ : ℕ
e✝ : (fun b => some a = b) (↑s✝ k✝)
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
val✝ : Stream' (Option α)
property✝ : IsSeq val✝
e : some a = ↑(cons b { val := val✝, property := property✝ }) (Nat.succ k)
⊢ ↑(cons b { val := val✝, property := property✝ }) (Nat.succ k) = ↑{ val := val✝, property := property✝ } k