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
state_after: 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).get k)
⊢ C s

tactic: unfold Stream'.get 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) ((↑s).get k)
⊢ C s
state_after: 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: 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
state_after: case intro.zero
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
s : Seq α
e : some a = ↑s 0
⊢ C s

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

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

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

α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
⊢ ∀ (b : α) (s' : Seq α), some a = ↑(cons b s') (k + 1) → C (cons b 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 : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
s : Seq α
e : some a = ↑s 0
⊢ C s
state_after: case intro.zero
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
s : Seq α
e : some a = ↑s 0
TH : s = cons a s.tail
⊢ C s

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

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

tactic: apply destruct_eq_cons
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
s : Seq α
e : some a = ↑s 0
⊢ s = cons a s.tail
state_after: case a
α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
s : Seq α
e : some a = ↑s 0
⊢ s.destruct = some (a, s.tail)

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

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

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

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

tactic: injection e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
e : some a = ↑nil (k + 1)
⊢ C nil
state_after: no goals

tactic: intro b s' e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
⊢ ∀ (b : α) (s' : Seq α), some a = ↑(cons b s') (k + 1) → C (cons b s')
state_after: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑(cons b s') (k + 1)
⊢ 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 : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑(cons b s') (k + 1)
⊢ C (cons b s')
state_after: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑(cons b s') (k + 1)
h_eq : ↑(cons b s') k.succ = ↑s' k
⊢ C (cons b s')

tactic: rw [h_eq] at e
state_before: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
b : α
s' : Seq α
e : some a = ↑(cons b s') (k + 1)
h_eq : ↑(cons b s') k.succ = ↑s' k
⊢ C (cons b s')
state_after: α : Type u
β : Type v
γ : Type w
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
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') k.succ = ↑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 : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
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') k.succ = ↑s' k
⊢ C (cons b s')
state_after: no goals

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

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