l3lab/ntp-mathlib huggingface dataset:
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  

Proof state:
case mk
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ : U
p₁ : Path u v₁
⊢ ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := v₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := v₁, snd := p₁ } = a₂

Next tactic:
induction' p₁ with x₁ y₁ p₁ e₁ ih
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    

Proof state:
case mk.nil
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ : U
⊢ ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := u, snd := Path.nil } = a₂

Next tactic:
rintro ⟨y₂, p₂⟩
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    

Proof state:
case mk.cons
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
⊢ ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₁, snd := Path.cons p₁ e₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := y₁, snd := Path.cons p₁ e₁ } = a₂

Next tactic:
rintro ⟨y₂, p₂⟩
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    

Proof state:
case mk.nil.mk
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ y₂ : U
p₂ : Path u y₂
⊢ (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } =
      (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₂, snd := p₂ } →
    { fst := u, snd := Path.nil } = { fst := y₂, snd := p₂ }

Next tactic:
cases' p₂ with x₂ _ p₂ e₂
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    

Proof state:
case mk.cons.mk
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
y₂ : U
p₂ : Path u y₂
⊢ (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₁, snd := Path.cons p₁ e₁ } =
      (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₂, snd := p₂ } →
    { fst := y₁, snd := Path.cons p₁ e₁ } = { fst := y₂, snd := p₂ }

Next tactic:
cases' p₂ with x₂ _ p₂ e₂
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    

Proof state:
case mk.nil.mk.nil
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ : U
⊢ (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } =
      (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } →
    { fst := u, snd := Path.nil } = { fst := u, snd := Path.nil }

Next tactic:
intro h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    

Proof state:
case mk.nil.mk.cons
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
⊢ (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } =
      (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₂, snd := Path.cons p₂ e₂ } →
    { fst := u, snd := Path.nil } = { fst := y₂, snd := Path.cons p₂ e₂ }

Next tactic:
intro h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    

Proof state:
case mk.cons.mk.nil
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
⊢ (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₁, snd := Path.cons p₁ e₁ } =
      (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } →
    { fst := y₁, snd := Path.cons p₁ e₁ } = { fst := u, snd := Path.nil }

Next tactic:
intro h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    

Proof state:
case mk.cons.mk.cons
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
⊢ (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₁, snd := Path.cons p₁ e₁ } =
      (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₂, snd := Path.cons p₂ e₂ } →
    { fst := y₁, snd := Path.cons p₁ e₁ } = { fst := y₂, snd := Path.cons p₂ e₂ }

Next tactic:
intro h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    

Proof state:
case mk.nil.mk.nil
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ : U
h :
  (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } =
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil }
⊢ { fst := u, snd := Path.nil } = { fst := u, snd := Path.nil }

Next tactic:
simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    

Proof state:
case mk.nil.mk.cons
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
h :
  (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil } =
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₂, snd := Path.cons p₂ e₂ }
⊢ { fst := u, snd := Path.nil } = { fst := y₂, snd := Path.cons p₂ e₂ }

Next tactic:
simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    

Proof state:
case mk.cons.mk.nil
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
h :
  (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₁, snd := Path.cons p₁ e₁ } =
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := u, snd := Path.nil }
⊢ { fst := y₁, snd := Path.cons p₁ e₁ } = { fst := u, snd := Path.nil }

Next tactic:
simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    

Proof state:
case mk.cons.mk.cons
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
h :
  (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₁, snd := Path.cons p₁ e₁ } =
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := y₂, snd := Path.cons p₂ e₂ }
⊢ { fst := y₁, snd := Path.cons p₁ e₁ } = { fst := y₂, snd := Path.cons p₂ e₂ }

Next tactic:
simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    

Proof state:
case mk.nil.mk.nil
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ : U
h : True
⊢ { fst := u, snd := Path.nil } = { fst := u, snd := Path.nil }

Next tactic:
rfl
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · 

Proof state:
case mk.nil.mk.cons
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
h : φ.obj u = φ.obj y₂ ∧ HEq Path.nil (Path.cons (mapPath φ p₂) (φ.map e₂))
⊢ { fst := u, snd := Path.nil } = { fst := y₂, snd := Path.cons p₂ e₂ }

Next tactic:
exfalso
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · exfalso
    

Proof state:
case mk.nil.mk.cons.h
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
h : φ.obj u = φ.obj y₂ ∧ HEq Path.nil (Path.cons (mapPath φ p₂) (φ.map e₂))
⊢ False

Next tactic:
cases' h with h h'
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · exfalso
    cases' h with h h'
    

Proof state:
case mk.nil.mk.cons.h.intro
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
h : φ.obj u = φ.obj y₂
h' : HEq Path.nil (Path.cons (mapPath φ p₂) (φ.map e₂))
⊢ False

Next tactic:
rw [← Path.eq_cast_iff_heq rfl h.symm, Path.cast_cons] at h'
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · exfalso
    cases' h with h h'
    rw [← Path.eq_cast_iff_heq rfl h.symm, Path.cast_cons] at h'
    

Proof state:
case mk.nil.mk.cons.h.intro
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ y₂ x₂ : U
p₂ : Path u x₂
e₂ : x₂ ⟶ y₂
h : φ.obj u = φ.obj y₂
h' :
  Path.nil =
    Path.cons (Path.cast (_ : φ.obj u = φ.obj u) (_ : φ.obj x₂ = φ.obj x₂) (mapPath φ p₂))
      (Hom.cast (_ : φ.obj x₂ = φ.obj x₂) (_ : φ.obj y₂ = φ.obj u) (φ.map e₂))
⊢ False

Next tactic:
exact (Path.nil_ne_cons _ _) h'
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · exfalso
    cases' h with h h'
    rw [← Path.eq_cast_iff_heq rfl h.symm, Path.cast_cons] at h'
    exact (Path.nil_ne_cons _ _) h'
  · 

Proof state:
case mk.cons.mk.nil
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
h : φ.obj y₁ = φ.obj u ∧ HEq (Path.cons (mapPath φ p₁) (φ.map e₁)) Path.nil
⊢ { fst := y₁, snd := Path.cons p₁ e₁ } = { fst := u, snd := Path.nil }

Next tactic:
exfalso
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · exfalso
    cases' h with h h'
    rw [← Path.eq_cast_iff_heq rfl h.symm, Path.cast_cons] at h'
    exact (Path.nil_ne_cons _ _) h'
  · exfalso
    

Proof state:
case mk.cons.mk.nil.h
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
h : φ.obj y₁ = φ.obj u ∧ HEq (Path.cons (mapPath φ p₁) (φ.map e₁)) Path.nil
⊢ False

Next tactic:
cases' h with h h'
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · exfalso
    cases' h with h h'
    rw [← Path.eq_cast_iff_heq rfl h.symm, Path.cast_cons] at h'
    exact (Path.nil_ne_cons _ _) h'
  · exfalso
    cases' h with h h'
    

Proof state:
case mk.cons.mk.nil.h.intro
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
h : φ.obj y₁ = φ.obj u
h' : HEq (Path.cons (mapPath φ p₁) (φ.map e₁)) Path.nil
⊢ False

Next tactic:
rw [← Path.cast_eq_iff_heq rfl h, Path.cast_cons] at h'
theorem Prefunctor.pathStar_injective (hφ : ∀ u, Injective (φ.star u)) (u : U) :
    Injective (φ.pathStar u) := by
  dsimp (config := { unfoldPartialApp := true }) [Prefunctor.pathStar, Quiver.PathStar.mk]
  rintro ⟨v₁, p₁⟩
  induction' p₁ with x₁ y₁ p₁ e₁ ih <;>
    rintro ⟨y₂, p₂⟩ <;>
    cases' p₂ with x₂ _ p₂ e₂ <;>
    intro h <;>
    -- Porting note: added `Sigma.mk.inj_iff`
    simp only [Prefunctor.pathStar_apply, Prefunctor.mapPath_nil, Prefunctor.mapPath_cons,
      Sigma.mk.inj_iff] at h
  · -- Porting note: goal not present in lean3.
    rfl
  · exfalso
    cases' h with h h'
    rw [← Path.eq_cast_iff_heq rfl h.symm, Path.cast_cons] at h'
    exact (Path.nil_ne_cons _ _) h'
  · exfalso
    cases' h with h h'
    rw [← Path.cast_eq_iff_heq rfl h, Path.cast_cons] at h'
    

Proof state:
case mk.cons.mk.nil.h.intro
U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.13176
inst✝ : Quiver W
ψ : V ⥤q W
hφ : ∀ (u : U), Injective (star φ u)
u v₁ x₁ y₁ : U
p₁ : Path u x₁
e₁ : x₁ ⟶ y₁
ih :
  ∀ ⦃a₂ : PathStar u⦄,
    (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) { fst := x₁, snd := p₁ } =
        (fun p => { fst := φ.obj p.fst, snd := mapPath φ p.snd }) a₂ →
      { fst := x₁, snd := p₁ } = a₂
h : φ.obj y₁ = φ.obj u
h' :
  Path.cons (Path.cast (_ : φ.obj u = φ.obj u) (_ : φ.obj x₁ = φ.obj x₁) (mapPath φ p₁))
      (Hom.cast (_ : φ.obj x₁ = φ.obj x₁) h (φ.map e₁)) =
    Path.nil
⊢ False

Next tactic:
exact (Path.cons_ne_nil _ _) h'