l3lab/ntp-mathlib huggingface dataset:
/-- If `f : α → β` is a fibration between relations `rα` and `rβ`, and `a : α` is
  accessible under `rα`, then `f a` is accessible under `rβ`. -/
theorem _root_.Acc.of_fibration (fib : Fibration rα rβ f) {a} (ha : Acc rα a) : Acc rβ (f a) := by
  induction' ha with a _ ih
  refine' Acc.intro (f a) fun b hr ↦ _
  

Proof state:
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
rα : α → α → Prop
rβ : β → β → Prop
f : α → β
fib : Fibration rα rβ f
a✝ a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
ih : ∀ (y : α), rα y a → Acc rβ (f y)
b : β
hr : rβ b (f a)
⊢ Acc rβ b

Next tactic:
obtain ⟨a', hr', rfl⟩ := fib hr
/-- If `f : α → β` is a fibration between relations `rα` and `rβ`, and `a : α` is
  accessible under `rα`, then `f a` is accessible under `rβ`. -/
theorem _root_.Acc.of_fibration (fib : Fibration rα rβ f) {a} (ha : Acc rα a) : Acc rβ (f a) := by
  induction' ha with a _ ih
  refine' Acc.intro (f a) fun b hr ↦ _
  obtain ⟨a', hr', rfl⟩ := fib hr
  

Proof state:
case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
rα : α → α → Prop
rβ : β → β → Prop
f : α → β
fib : Fibration rα rβ f
a✝ a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
ih : ∀ (y : α), rα y a → Acc rβ (f y)
a' : α
hr' : rα a' a
hr : rβ (f a') (f a)
⊢ Acc rβ (f a')

Next tactic:
exact ih a' hr'
@[simp] lemma map_map (r : α → β → Prop) (f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ) :
    Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
r : α → β → Prop
f₁ : α → γ
g₁ : β → δ
f₂ : γ → ε
g₂ : δ → ζ
⊢ Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁)

Next tactic:
ext a b
@[simp] lemma map_map (r : α → β → Prop) (f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ) :
    Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) := by
  ext a b
  

Proof state:
case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
r : α → β → Prop
f₁ : α → γ
g₁ : β → δ
f₂ : γ → ε
g₂ : δ → ζ
a : ε
b : ζ
⊢ Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ a b ↔ Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) a b

Next tactic:
simp_rw [Relation.Map, Function.comp_apply, ← exists_and_right, @exists_comm γ, @exists_comm δ]
@[simp] lemma map_map (r : α → β → Prop) (f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ) :
    Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) := by
  ext a b
  simp_rw [Relation.Map, Function.comp_apply, ← exists_and_right, @exists_comm γ, @exists_comm δ]
  

Proof state:
case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
r : α → β → Prop
f₁ : α → γ
g₁ : β → δ
f₂ : γ → ε
g₂ : δ → ζ
a : ε
b : ζ
⊢ (∃ b_1 b_2 b_3 a_1, (r b_1 b_2 ∧ f₁ b_1 = b_3 ∧ g₁ b_2 = a_1) ∧ f₂ b_3 = a ∧ g₂ a_1 = b) ↔
    ∃ a_1 b_1, r a_1 b_1 ∧ f₂ (f₁ a_1) = a ∧ g₂ (g₁ b_1) = b

Next tactic:
refine' exists₂_congr fun a b ↦ ⟨_, fun h ↦ ⟨_, _, ⟨⟨h.1, rfl, rfl⟩, h.2⟩⟩⟩
@[simp] lemma map_map (r : α → β → Prop) (f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ) :
    Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) := by
  ext a b
  simp_rw [Relation.Map, Function.comp_apply, ← exists_and_right, @exists_comm γ, @exists_comm δ]
  refine' exists₂_congr fun a b ↦ ⟨_, fun h ↦ ⟨_, _, ⟨⟨h.1, rfl, rfl⟩, h.2⟩⟩⟩
  

Proof state:
case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
r : α → β → Prop
f₁ : α → γ
g₁ : β → δ
f₂ : γ → ε
g₂ : δ → ζ
a✝ : ε
b✝ : ζ
a : α
b : β
⊢ (∃ b_1 a_1, (r a b ∧ f₁ a = b_1 ∧ g₁ b = a_1) ∧ f₂ b_1 = a✝ ∧ g₂ a_1 = b✝) → r a b ∧ f₂ (f₁ a) = a✝ ∧ g₂ (g₁ b) = b✝

Next tactic:
rintro ⟨_, _, ⟨hab, rfl, rfl⟩, h⟩
@[simp] lemma map_map (r : α → β → Prop) (f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ) :
    Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) := by
  ext a b
  simp_rw [Relation.Map, Function.comp_apply, ← exists_and_right, @exists_comm γ, @exists_comm δ]
  refine' exists₂_congr fun a b ↦ ⟨_, fun h ↦ ⟨_, _, ⟨⟨h.1, rfl, rfl⟩, h.2⟩⟩⟩
  rintro ⟨_, _, ⟨hab, rfl, rfl⟩, h⟩
  

Proof state:
case h.h.a.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
r : α → β → Prop
f₁ : α → γ
g₁ : β → δ
f₂ : γ → ε
g₂ : δ → ζ
a✝ : ε
b✝ : ζ
a : α
b : β
hab : r a b
h : f₂ (f₁ a) = a✝ ∧ g₂ (g₁ b) = b✝
⊢ r a b ∧ f₂ (f₁ a) = a✝ ∧ g₂ (g₁ b) = b✝

Next tactic:
exact ⟨hab, h⟩
@[simp]
lemma map_apply_apply (hf : Injective f) (hg : Injective g) (r : α → β → Prop) (a : α) (b : β) :
    Relation.Map r f g (f a) (g b) ↔ r a b := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
hf : Injective f
hg : Injective g
r : α → β → Prop
a : α
b : β
⊢ Relation.Map r f g (f a) (g b) ↔ r a b

Next tactic:
simp [Relation.Map, hf.eq_iff, hg.eq_iff]
@[simp] lemma map_id_id (r : α → β → Prop) : Relation.Map r id id = r := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
r : α → β → Prop
⊢ Relation.Map r id id = r

Next tactic:
ext
@[simp] lemma map_id_id (r : α → β → Prop) : Relation.Map r id id = r := by ext; 

Proof state:
case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
f : α → γ
g : β → δ
c : γ
d : δ
r : α → β → Prop
x✝¹ : α
x✝ : β
⊢ Relation.Map r id id x✝¹ x✝ ↔ r x✝¹ x✝

Next tactic:
simp [Relation.Map]
theorem to_reflTransGen : ∀ {a b}, ReflGen r a b → ReflTransGen r a b
  | a, _, refl => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d a : α
⊢ ReflTransGen r a a

Next tactic:
rfl
theorem mono {p : α → α → Prop} (hp : ∀ a b, r a b → p a b) : ∀ {a b}, ReflGen r a b → ReflGen p a b
  | a, _, ReflGen.refl => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d : α
p : α → α → Prop
hp : ∀ (a b : α), r a b → p a b
a : α
⊢ ReflGen p a a

Next tactic:
rfl
@[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
hbc : ReflTransGen r b c
⊢ ReflTransGen r a c

Next tactic:
induction hbc
@[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  

Proof state:
case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
⊢ ReflTransGen r a b
case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

Next tactic:
case refl => assumption
@[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
⊢ ReflTransGen r a b

Next tactic:
case refl => assumption
@[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
⊢ ReflTransGen r a b

Next tactic:
assumption
@[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => assumption
  

Proof state:
case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : ReflTransGen r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

Next tactic:
case tail c d _ hcd hac => exact hac.tail hcd
@[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => assumption
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c✝ d✝ : α
hab : ReflTransGen r a b
c d : α
a✝ : ReflTransGen r b c
hcd : r c d
hac : ReflTransGen r a c
⊢ ReflTransGen r a d

Next tactic:
case tail c d _ hcd hac => exact hac.tail hcd
@[trans]
theorem trans (hab : ReflTransGen r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => assumption
  case tail c d _ hcd hac => 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c✝ d✝ : α
hab : ReflTransGen r a b
c d : α
a✝ : ReflTransGen r b c
hcd : r c d
hac : ReflTransGen r a c
⊢ ReflTransGen r a d

Next tactic:
exact hac.tail hcd
theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : r a b
hbc : ReflTransGen r b c
⊢ ReflTransGen r a c

Next tactic:
induction hbc
theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  

Proof state:
case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : r a b
⊢ ReflTransGen r a b
case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

Next tactic:
case refl => exact refl.tail hab
theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : r a b
⊢ ReflTransGen r a b

Next tactic:
case refl => exact refl.tail hab
theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : r a b
⊢ ReflTransGen r a b

Next tactic:
exact refl.tail hab
theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => exact refl.tail hab
  

Proof state:
case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hab : r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

Next tactic:
case tail c d _ hcd hac => exact hac.tail hcd
theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => exact refl.tail hab
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c✝ d✝ : α
hab : r a b
c d : α
a✝ : ReflTransGen r b c
hcd : r c d
hac : ReflTransGen r a c
⊢ ReflTransGen r a d

Next tactic:
case tail c d _ hcd hac => exact hac.tail hcd
theorem head (hab : r a b) (hbc : ReflTransGen r b c) : ReflTransGen r a c := by
  induction hbc
  case refl => exact refl.tail hab
  case tail c d _ hcd hac => 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c✝ d✝ : α
hab : r a b
c d : α
a✝ : ReflTransGen r b c
hcd : r c d
hac : ReflTransGen r a c
⊢ ReflTransGen r a d

Next tactic:
exact hac.tail hcd
theorem symmetric (h : Symmetric r) : Symmetric (ReflTransGen r) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : Symmetric r
⊢ Symmetric (ReflTransGen r)

Next tactic:
intro x y h
theorem symmetric (h : Symmetric r) : Symmetric (ReflTransGen r) := by
  intro x y h
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h✝ : Symmetric r
x y : α
h : ReflTransGen r x y
⊢ ReflTransGen r y x

Next tactic:
induction' h with z w _ b c
theorem symmetric (h : Symmetric r) : Symmetric (ReflTransGen r) := by
  intro x y h
  induction' h with z w _ b c
  · 

Proof state:
case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : Symmetric r
x y : α
⊢ ReflTransGen r x x

Next tactic:
rfl
theorem symmetric (h : Symmetric r) : Symmetric (ReflTransGen r) := by
  intro x y h
  induction' h with z w _ b c
  · rfl
  · 

Proof state:
case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b✝ c✝ d : α
h : Symmetric r
x y z w : α
a✝ : ReflTransGen r x z
b : r z w
c : ReflTransGen r z x
⊢ ReflTransGen r w x

Next tactic:
apply Relation.ReflTransGen.head (h b) c
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d : α
P : (a : α) → ReflTransGen r a b → Prop
a : α
h : ReflTransGen r a b
refl : P b (_ : ReflTransGen r b b)
head : ∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (_ : ReflTransGen r a b)
⊢ P a h

Next tactic:
induction h
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  

Proof state:
case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d a : α
P : (a_1 : α) → ReflTransGen r a_1 a → Prop
refl : P a (_ : ReflTransGen r a a)
head : ∀ {a_1 c : α} (h' : r a_1 c) (h : ReflTransGen r c a), P c h → P a_1 (_ : ReflTransGen r a_1 a)
⊢ P a (_ : ReflTransGen r a a)
case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝² b c d a b✝ c✝ : α
a✝¹ : ReflTransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ :
  ∀ {P : (a : α) → ReflTransGen r a b✝ → Prop},
    P b✝ (_ : ReflTransGen r b✝ b✝) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b✝), P c h → P a (_ : ReflTransGen r a b✝)) → P a a✝¹
P : (a : α) → ReflTransGen r a c✝ → Prop
refl : P c✝ (_ : ReflTransGen r c✝ c✝)
head : ∀ {a c : α} (h' : r a c) (h : ReflTransGen r c c✝), P c h → P a (_ : ReflTransGen r a c✝)
⊢ P a (_ : ReflTransGen r a c✝)

Next tactic:
case refl => exact refl
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d a : α
P : (a_1 : α) → ReflTransGen r a_1 a → Prop
refl : P a (_ : ReflTransGen r a a)
head : ∀ {a_1 c : α} (h' : r a_1 c) (h : ReflTransGen r c a), P c h → P a_1 (_ : ReflTransGen r a_1 a)
⊢ P a (_ : ReflTransGen r a a)

Next tactic:
case refl => exact refl
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  case refl => 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b c d a : α
P : (a_1 : α) → ReflTransGen r a_1 a → Prop
refl : P a (_ : ReflTransGen r a a)
head : ∀ {a_1 c : α} (h' : r a_1 c) (h : ReflTransGen r c a), P c h → P a_1 (_ : ReflTransGen r a_1 a)
⊢ P a (_ : ReflTransGen r a a)

Next tactic:
exact refl
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  case refl => exact refl
  

Proof state:
case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝² b c d a b✝ c✝ : α
a✝¹ : ReflTransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ :
  ∀ {P : (a : α) → ReflTransGen r a b✝ → Prop},
    P b✝ (_ : ReflTransGen r b✝ b✝) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b✝), P c h → P a (_ : ReflTransGen r a b✝)) → P a a✝¹
P : (a : α) → ReflTransGen r a c✝ → Prop
refl : P c✝ (_ : ReflTransGen r c✝ c✝)
head : ∀ {a c : α} (h' : r a c) (h : ReflTransGen r c c✝), P c h → P a (_ : ReflTransGen r a c✝)
⊢ P a (_ : ReflTransGen r a c✝)

Next tactic:
case tail b c _ hbc ih =>
  -- Porting note: Lean 3 figured out the motive and `apply ih` worked
  refine @ih (λ {a : α} (hab : ReflTransGen r a b) => P a (ReflTransGen.tail hab hbc)) ?_ ?_
  { exact head hbc _ refl }
  { exact fun h1 h2 ↦ head h1 (h2.tail hbc) }
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  case refl => exact refl
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : ReflTransGen r a b
hbc : r b c
ih :
  ∀ {P : (a : α) → ReflTransGen r a b → Prop},
    P b (_ : ReflTransGen r b b) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (_ : ReflTransGen r a b)) → P a a✝
P : (a : α) → ReflTransGen r a c → Prop
refl : P c (_ : ReflTransGen r c c)
head : ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 c), P c_1 h → P a (_ : ReflTransGen r a c)
⊢ P a (_ : ReflTransGen r a c)

Next tactic:
case tail b c _ hbc ih =>
  -- Porting note: Lean 3 figured out the motive and `apply ih` worked
  refine @ih (λ {a : α} (hab : ReflTransGen r a b) => P a (ReflTransGen.tail hab hbc)) ?_ ?_
  { exact head hbc _ refl }
  { exact fun h1 h2 ↦ head h1 (h2.tail hbc) }
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  case refl => exact refl
  case tail b c _ hbc ih =>
  -- Porting note: Lean 3 figured out the motive and `apply ih` worked
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : ReflTransGen r a b
hbc : r b c
ih :
  ∀ {P : (a : α) → ReflTransGen r a b → Prop},
    P b (_ : ReflTransGen r b b) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (_ : ReflTransGen r a b)) → P a a✝
P : (a : α) → ReflTransGen r a c → Prop
refl : P c (_ : ReflTransGen r c c)
head : ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 c), P c_1 h → P a (_ : ReflTransGen r a c)
⊢ P a (_ : ReflTransGen r a c)

Next tactic:
refine @ih (λ {a : α} (hab : ReflTransGen r a b) => P a (ReflTransGen.tail hab hbc)) ?_ ?_
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  case refl => exact refl
  case tail b c _ hbc ih =>
  -- Porting note: Lean 3 figured out the motive and `apply ih` worked
  refine @ih (λ {a : α} (hab : ReflTransGen r a b) => P a (ReflTransGen.tail hab hbc)) ?_ ?_
  

Proof state:
case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : ReflTransGen r a b
hbc : r b c
ih :
  ∀ {P : (a : α) → ReflTransGen r a b → Prop},
    P b (_ : ReflTransGen r b b) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (_ : ReflTransGen r a b)) → P a a✝
P : (a : α) → ReflTransGen r a c → Prop
refl : P c (_ : ReflTransGen r c c)
head : ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 c), P c_1 h → P a (_ : ReflTransGen r a c)
⊢ (fun {a} hab => P a (_ : ReflTransGen r a c)) (_ : ReflTransGen r b b)
case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : ReflTransGen r a b
hbc : r b c
ih :
  ∀ {P : (a : α) → ReflTransGen r a b → Prop},
    P b (_ : ReflTransGen r b b) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (_ : ReflTransGen r a b)) → P a a✝
P : (a : α) → ReflTransGen r a c → Prop
refl : P c (_ : ReflTransGen r c c)
head : ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 c), P c_1 h → P a (_ : ReflTransGen r a c)
⊢ ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 b),
    (fun {a} hab => P a (_ : ReflTransGen r a c)) h →
      (fun {a} hab => P a (_ : ReflTransGen r a c)) (_ : ReflTransGen r a b)

Next tactic:
{ exact head hbc _ refl }
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  case refl => exact refl
  case tail b c _ hbc ih =>
  -- Porting note: Lean 3 figured out the motive and `apply ih` worked
  refine @ih (λ {a : α} (hab : ReflTransGen r a b) => P a (ReflTransGen.tail hab hbc)) ?_ ?_
  { 

Proof state:
case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : ReflTransGen r a b
hbc : r b c
ih :
  ∀ {P : (a : α) → ReflTransGen r a b → Prop},
    P b (_ : ReflTransGen r b b) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (_ : ReflTransGen r a b)) → P a a✝
P : (a : α) → ReflTransGen r a c → Prop
refl : P c (_ : ReflTransGen r c c)
head : ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 c), P c_1 h → P a (_ : ReflTransGen r a c)
⊢ (fun {a} hab => P a (_ : ReflTransGen r a c)) (_ : ReflTransGen r b b)

Next tactic:
exact head hbc _ refl
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
    (refl : P b refl)
    (head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by
  induction h
  case refl => exact refl
  case tail b c _ hbc ih =>
  -- Porting note: Lean 3 figured out the motive and `apply ih` worked
  refine @ih (λ {a : α} (hab : ReflTransGen r a b) => P a (ReflTransGen.tail hab hbc)) ?_ ?_
  { exact head hbc _ refl }
  

Proof state:
case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝¹ b✝ c✝ d a b c : α
a✝ : ReflTransGen r a b
hbc : r b c
ih :
  ∀ {P : (a : α) → ReflTransGen r a b → Prop},
    P b (_ : ReflTransGen r b b) →
      (∀ {a c : α} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (_ : ReflTransGen r a b)) → P a a✝
P : (a : α) → ReflTransGen r a c → Prop
refl : P c (_ : ReflTransGen r c c)
head : ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 c), P c_1 h → P a (_ : ReflTransGen r a c)
⊢ ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 b),
    (fun {a} hab => P a (_ : ReflTransGen r a c)) h →
      (fun {a} hab => P a (_ : ReflTransGen r a c)) (_ : ReflTransGen r a b)

Next tactic:
{ exact fun h1 h2 ↦ head h1 (h2.tail hbc) }