Theorem: List.list_reverse_induction
File: Mathlib/Data/List/Indexes.lean

tactic: let q := fun l ↦ p (reverse l)
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
⊢ ∀ (l : List α), p l

tactic: have pq : ∀ l, p (reverse l) → q l := by simp only [reverse_reverse]; intro; exact id
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
⊢ ∀ (l : List α), p l

tactic: have qp : ∀ l, q (reverse l) → p l := by simp only [reverse_reverse]; intro; exact id
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
⊢ ∀ (l : List α), p l

tactic: intro l
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
⊢ ∀ (l : List α), p l

tactic: apply qp
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
⊢ p l

tactic: generalize (reverse l) = l
state_before: case a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
⊢ q (reverse l)

tactic: induction' l with head tail ih
state_before: case a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l✝ l : List α
⊢ q l

tactic: simp only [reverse_reverse]
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
⊢ ∀ (l : List α), p (reverse l) → q l

tactic: intro
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
⊢ ∀ (l : List α), p (reverse l) → p (reverse l)

tactic: exact id
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
l✝ : List α
⊢ p (reverse l✝) → p (reverse l✝)

tactic: simp only [reverse_reverse]
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
⊢ ∀ (l : List α), q (reverse l) → p l

tactic: intro
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
⊢ ∀ (l : List α), p l → p l

tactic: exact id
state_before: α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
l✝ : List α
⊢ p l✝ → p l✝

tactic: apply pq
state_before: case a.nil
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
⊢ q []

tactic: simp only [reverse_nil, base]
state_before: case a.nil.a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
⊢ p (reverse [])

tactic: apply pq
state_before: case a.cons
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
head : α
tail : List α
ih : q tail
⊢ q (head :: tail)

tactic: simp only [reverse_cons]
state_before: case a.cons.a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
head : α
tail : List α
ih : q tail
⊢ p (reverse (head :: tail))

tactic: apply ind
state_before: case a.cons.a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
head : α
tail : List α
ih : q tail
⊢ p (reverse tail ++ [head])

tactic: apply qp
state_before: case a.cons.a.a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
head : α
tail : List α
ih : q tail
⊢ p (reverse tail)

tactic: rw [reverse_reverse]
state_before: case a.cons.a.a.a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
head : α
tail : List α
ih : q tail
⊢ q (reverse (reverse tail))

tactic: exact ih
state_before: case a.cons.a.a.a
α : Type u
β : Type v
p : List α → Prop
base : p []
ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])
q : List α → Prop := fun l => p (reverse l)
pq : ∀ (l : List α), p (reverse l) → q l
qp : ∀ (l : List α), q (reverse l) → p l
l : List α
head : α
tail : List α
ih : q tail
⊢ q tail