l3lab/ntp-mathlib huggingface dataset:
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> 

Proof state:
case inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
h : t ≠ v
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

Next tactic:
obtain rfl | h' := eq_or_ne t u
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (

Proof state:
case inl.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t w : V
p' : Walk G t w
p : Walk G t t
⊢ t = t ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = t ∨ t ∈ List.tail (support p)) ∨ t = t ∨ t ∈ List.tail (support p')

Next tactic:
try have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try 

Proof state:
case inl.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t w : V
p' : Walk G t w
p : Walk G t t
⊢ t = t ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = t ∨ t ∈ List.tail (support p)) ∨ t = t ∨ t ∈ List.tail (support p')

Next tactic:
have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (

Proof state:
case inl.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u w : V
p : Walk G u t
p' : Walk G t w
h' : t ≠ u
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = t ∨ t ∈ List.tail (support p')

Next tactic:
try have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try 

Proof state:
case inl.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u w : V
p : Walk G u t
p' : Walk G t w
h' : t ≠ u
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = t ∨ t ∈ List.tail (support p')

Next tactic:
have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (

Proof state:
case inr.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t v w : V
p' : Walk G v w
h : t ≠ v
p : Walk G t v
⊢ t = t ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = t ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

Next tactic:
try have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try 

Proof state:
case inr.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t v w : V
p' : Walk G v w
h : t ≠ v
p : Walk G t v
⊢ t = t ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = t ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

Next tactic:
have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (

Proof state:
case inr.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
h : t ≠ v
h' : t ≠ u
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

Next tactic:
try have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try 

Proof state:
case inr.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
h : t ≠ v
h' : t ≠ u
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

Next tactic:
have := h'.symm
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try have := h'.symm) <;> 

Proof state:
case inl.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t w : V
p' : Walk G t w
p : Walk G t t
⊢ t = t ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = t ∨ t ∈ List.tail (support p)) ∨ t = t ∨ t ∈ List.tail (support p')

Next tactic:
simp [*]
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try have := h'.symm) <;> 

Proof state:
case inl.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u w : V
p : Walk G u t
p' : Walk G t w
h' : t ≠ u
this : u ≠ t
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = t ∨ t ∈ List.tail (support p')

Next tactic:
simp [*]
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try have := h'.symm) <;> 

Proof state:
case inr.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t v w : V
p' : Walk G v w
h : t ≠ v
p : Walk G t v
⊢ t = t ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = t ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

Next tactic:
simp [*]
@[simp, nolint unusedHavesSuffices]
theorem mem_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support := by
  simp only [mem_support_iff, mem_tail_support_append_iff]
  obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
    -- this `have` triggers the unusedHavesSuffices linter:
    (try have := h'.symm) <;> 

Proof state:
case inr.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
h : t ≠ v
h' : t ≠ u
this : u ≠ t
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

Next tactic:
simp [*]
@[simp]
theorem subset_support_append_left {V : Type u} {G : SimpleGraph V} {u v w : V}
    (p : G.Walk u v) (q : G.Walk v w) : p.support ⊆ (p.append q).support := by
  

Proof state:
V✝ : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V✝
G' : SimpleGraph V'
G'' : SimpleGraph V''
V : Type u
G : SimpleGraph V
u v w : V
p : Walk G u v
q : Walk G v w
⊢ support p ⊆ support (append p q)

Next tactic:
simp only [Walk.support_append, List.subset_append_left]
@[simp]
theorem subset_support_append_right {V : Type u} {G : SimpleGraph V} {u v w : V}
    (p : G.Walk u v) (q : G.Walk v w) : q.support ⊆ (p.append q).support := by
  

Proof state:
V✝ : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V✝
G' : SimpleGraph V'
G'' : SimpleGraph V''
V : Type u
G : SimpleGraph V
u v w : V
p : Walk G u v
q : Walk G v w
⊢ support q ⊆ support (append p q)

Next tactic:
intro h
@[simp]
theorem subset_support_append_right {V : Type u} {G : SimpleGraph V} {u v w : V}
    (p : G.Walk u v) (q : G.Walk v w) : q.support ⊆ (p.append q).support := by
  intro h
  

Proof state:
V✝ : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V✝
G' : SimpleGraph V'
G'' : SimpleGraph V''
V : Type u
G : SimpleGraph V
u v w : V
p : Walk G u v
q : Walk G v w
h : V
⊢ h ∈ support q → h ∈ support (append p q)

Next tactic:
simp (config := { contextual := true }) only [mem_support_append_iff, or_true_iff, imp_true_iff]
theorem coe_support {u v : V} (p : G.Walk u v) : (p.support : Multiset V) = {u} + p.support.tail :=
  by 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ ↑(support p) = {u} + ↑(List.tail (support p))

Next tactic:
cases p
theorem coe_support {u v : V} (p : G.Walk u v) : (p.support : Multiset V) = {u} + p.support.tail :=
  by cases p <;> 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
⊢ ↑(support nil) = {u} + ↑(List.tail (support nil))

Next tactic:
rfl
theorem coe_support {u v : V} (p : G.Walk u v) : (p.support : Multiset V) = {u} + p.support.tail :=
  by cases p <;> 

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v v✝ : V
h✝ : Adj G u v✝
p✝ : Walk G v✝ v
⊢ ↑(support (cons h✝ p✝)) = {u} + ↑(List.tail (support (cons h✝ p✝)))

Next tactic:
rfl
theorem coe_support_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    ((p.append p').support : Multiset V) = {u} + p.support.tail + p'.support.tail := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ ↑(support (append p p')) = {u} + ↑(List.tail (support p)) + ↑(List.tail (support p'))

Next tactic:
rw [support_append, ← Multiset.coe_add, coe_support]
theorem coe_support_append' [DecidableEq V] {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    ((p.append p').support : Multiset V) = p.support + p'.support - {v} := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ ↑(support (append p p')) = ↑(support p) + ↑(support p') - {v}

Next tactic:
rw [support_append, ← Multiset.coe_add]
theorem coe_support_append' [DecidableEq V] {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    ((p.append p').support : Multiset V) = p.support + p'.support - {v} := by
  rw [support_append, ← Multiset.coe_add]
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ ↑(support p) + ↑(List.tail (support p')) = ↑(support p) + ↑(support p') - {v}

Next tactic:
simp only [coe_support]
theorem coe_support_append' [DecidableEq V] {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    ((p.append p').support : Multiset V) = p.support + p'.support - {v} := by
  rw [support_append, ← Multiset.coe_add]
  simp only [coe_support]
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ {u} + ↑(List.tail (support p)) + ↑(List.tail (support p')) =
    {u} + ↑(List.tail (support p)) + ({v} + ↑(List.tail (support p'))) - {v}

Next tactic:
rw [add_comm ({v} : Multiset V)]
theorem coe_support_append' [DecidableEq V] {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    ((p.append p').support : Multiset V) = p.support + p'.support - {v} := by
  rw [support_append, ← Multiset.coe_add]
  simp only [coe_support]
  rw [add_comm ({v} : Multiset V)]
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ {u} + ↑(List.tail (support p)) + ↑(List.tail (support p')) =
    {u} + ↑(List.tail (support p)) + (↑(List.tail (support p')) + {v}) - {v}

Next tactic:
simp only [← add_assoc, add_tsub_cancel_right]
theorem chain_dartAdj_darts {d : G.Dart} {v w : V} (h : d.snd = v) (p : G.Walk v w) :
    List.Chain G.DartAdj d p.darts := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
d : Dart G
v w : V
h : d.toProd.2 = v
p : Walk G v w
⊢ List.Chain (DartAdj G) d (darts p)

Next tactic:
induction p generalizing d with
  | nil => exact List.Chain.nil
  -- porting note: needed to defer `h` and `rfl` to help elaboration
  | cons h' p ih => exact List.Chain.cons (by exact h) (ih (by rfl))
theorem chain_dartAdj_darts {d : G.Dart} {v w : V} (h : d.snd = v) (p : G.Walk v w) :
    List.Chain G.DartAdj d p.darts := by
  induction p generalizing d with
  

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ : V
d : Dart G
h : d.toProd.2 = u✝
⊢ List.Chain (DartAdj G) d (darts nil)

Next tactic:
| nil => exact List.Chain.nil
theorem chain_dartAdj_darts {d : G.Dart} {v w : V} (h : d.snd = v) (p : G.Walk v w) :
    List.Chain G.DartAdj d p.darts := by
  induction p generalizing d with
  | nil => 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ : V
d : Dart G
h : d.toProd.2 = u✝
⊢ List.Chain (DartAdj G) d (darts nil)

Next tactic:
exact List.Chain.nil
theorem chain_dartAdj_darts {d : G.Dart} {v w : V} (h : d.snd = v) (p : G.Walk v w) :
    List.Chain G.DartAdj d p.darts := by
  induction p generalizing d with
  | nil => exact List.Chain.nil
  -- porting note: needed to defer `h` and `rfl` to help elaboration
  

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ v✝ w✝ : V
h' : Adj G u✝ v✝
p : Walk G v✝ w✝
ih : ∀ {d : Dart G}, d.toProd.2 = v✝ → List.Chain (DartAdj G) d (darts p)
d : Dart G
h : d.toProd.2 = u✝
⊢ List.Chain (DartAdj G) d (darts (cons h' p))

Next tactic:
| cons h' p ih => exact List.Chain.cons (by exact h) (ih (by rfl))
theorem chain_dartAdj_darts {d : G.Dart} {v w : V} (h : d.snd = v) (p : G.Walk v w) :
    List.Chain G.DartAdj d p.darts := by
  induction p generalizing d with
  | nil => exact List.Chain.nil
  -- porting note: needed to defer `h` and `rfl` to help elaboration
  | cons h' p ih => 

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ v✝ w✝ : V
h' : Adj G u✝ v✝
p : Walk G v✝ w✝
ih : ∀ {d : Dart G}, d.toProd.2 = v✝ → List.Chain (DartAdj G) d (darts p)
d : Dart G
h : d.toProd.2 = u✝
⊢ List.Chain (DartAdj G) d (darts (cons h' p))

Next tactic:
exact List.Chain.cons (by exact h) (ih (by rfl))
theorem chain_dartAdj_darts {d : G.Dart} {v w : V} (h : d.snd = v) (p : G.Walk v w) :
    List.Chain G.DartAdj d p.darts := by
  induction p generalizing d with
  | nil => exact List.Chain.nil
  -- porting note: needed to defer `h` and `rfl` to help elaboration
  | cons h' p ih => exact List.Chain.cons (by 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ v✝ w✝ : V
h' : Adj G u✝ v✝
p : Walk G v✝ w✝
ih : ∀ {d : Dart G}, d.toProd.2 = v✝ → List.Chain (DartAdj G) d (darts p)
d : Dart G
h : d.toProd.2 = u✝
⊢ DartAdj G d { toProd := (u✝, v✝), is_adj := h' }

Next tactic:
exact h
theorem chain_dartAdj_darts {d : G.Dart} {v w : V} (h : d.snd = v) (p : G.Walk v w) :
    List.Chain G.DartAdj d p.darts := by
  induction p generalizing d with
  | nil => exact List.Chain.nil
  -- porting note: needed to defer `h` and `rfl` to help elaboration
  | cons h' p ih => exact List.Chain.cons (by exact h) (ih (by 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ v✝ w✝ : V
h' : Adj G u✝ v✝
p : Walk G v✝ w✝
ih : ∀ {d : Dart G}, d.toProd.2 = v✝ → List.Chain (DartAdj G) d (darts p)
d : Dart G
h : d.toProd.2 = u✝
⊢ { toProd := (u✝, v✝), is_adj := h' }.toProd.2 = v✝

Next tactic:
rfl
theorem chain'_dartAdj_darts {u v : V} : ∀ (p : G.Walk u v), List.Chain' G.DartAdj p.darts
  | nil => trivial
  -- porting note: needed to defer `rfl` to help elaboration
  | cons h p => chain_dartAdj_darts (by 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v✝¹ v v✝ : V
h : Adj G u v✝
p : Walk G v✝ v
⊢ { toProd := (u, v✝), is_adj := h }.toProd.2 = v✝

Next tactic:
rfl
/-- Every edge in a walk's edge list is an edge of the graph.
It is written in this form (rather than using `⊆`) to avoid unsightly coercions. -/
theorem edges_subset_edgeSet {u v : V} :
    ∀ (p : G.Walk u v) ⦃e : Sym2 V⦄, e ∈ p.edges → e ∈ G.edgeSet
  | cons h' p', e, h => by
    

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v v✝ : V
h' : Adj G u v✝
p' : Walk G v✝ v
e : Sym2 V
h : e ∈ edges (cons h' p')
⊢ e ∈ edgeSet G

Next tactic:
cases h
/-- Every edge in a walk's edge list is an edge of the graph.
It is written in this form (rather than using `⊆`) to avoid unsightly coercions. -/
theorem edges_subset_edgeSet {u v : V} :
    ∀ (p : G.Walk u v) ⦃e : Sym2 V⦄, e ∈ p.edges → e ∈ G.edgeSet
  | cons h' p', e, h => by
    cases h
    · 

Proof state:
case head
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v v✝ : V
h' : Adj G u v✝
p' : Walk G v✝ v
⊢ Dart.edge { toProd := (u, v✝), is_adj := h' } ∈ edgeSet G

Next tactic:
exact h'
/-- Every edge in a walk's edge list is an edge of the graph.
It is written in this form (rather than using `⊆`) to avoid unsightly coercions. -/
theorem edges_subset_edgeSet {u v : V} :
    ∀ (p : G.Walk u v) ⦃e : Sym2 V⦄, e ∈ p.edges → e ∈ G.edgeSet
  | cons h' p', e, h => by
    cases h
    · exact h'
    

Proof state:
case tail
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v v✝ : V
h' : Adj G u v✝
p' : Walk G v✝ v
e : Sym2 V
a✝ : List.Mem e (List.map Dart.edge (darts p'))
⊢ e ∈ edgeSet G

Next tactic:
next h' => exact edges_subset_edgeSet p' h'
/-- Every edge in a walk's edge list is an edge of the graph.
It is written in this form (rather than using `⊆`) to avoid unsightly coercions. -/
theorem edges_subset_edgeSet {u v : V} :
    ∀ (p : G.Walk u v) ⦃e : Sym2 V⦄, e ∈ p.edges → e ∈ G.edgeSet
  | cons h' p', e, h => by
    cases h
    · exact h'
    next h' => 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v v✝ : V
h'✝ : Adj G u v✝
p' : Walk G v✝ v
e : Sym2 V
h' : List.Mem e (List.map Dart.edge (darts p'))
⊢ e ∈ edgeSet G

Next tactic:
exact edges_subset_edgeSet p' h'
@[simp]
theorem darts_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    (p.concat h).darts = p.darts.concat ⟨(v, w), h⟩ := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
h : Adj G v w
⊢ darts (concat p h) = List.concat (darts p) { toProd := (v, w), is_adj := h }

Next tactic:
induction p
@[simp]
theorem darts_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    (p.concat h).darts = p.darts.concat ⟨(v, w), h⟩ := by
  induction p <;> 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ : V
h : Adj G u✝ w
⊢ darts (concat nil h) = List.concat (darts nil) { toProd := (u✝, w), is_adj := h }

Next tactic:
simp [*, concat_nil]
@[simp]
theorem darts_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    (p.concat h).darts = p.darts.concat ⟨(v, w), h⟩ := by
  induction p <;> 

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
p_ih✝ : ∀ (h : Adj G w✝ w), darts (concat p✝ h) = List.concat (darts p✝) { toProd := (w✝, w), is_adj := h }
h : Adj G w✝ w
⊢ darts (concat (cons h✝ p✝) h) = List.concat (darts (cons h✝ p✝)) { toProd := (w✝, w), is_adj := h }

Next tactic:
simp [*, concat_nil]
@[simp]
theorem darts_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).darts = p.darts := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u' v' : V
p : Walk G u v
hu : u = u'
hv : v = v'
⊢ darts (Walk.copy p hu hv) = darts p

Next tactic:
subst_vars
@[simp]
theorem darts_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).darts = p.darts := by
  subst_vars
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' : V
p : Walk G u' v'
⊢ darts (Walk.copy p (_ : u' = u') (_ : v' = v')) = darts p

Next tactic:
rfl
@[simp]
theorem darts_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    (p.append p').darts = p.darts ++ p'.darts := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ darts (append p p') = darts p ++ darts p'

Next tactic:
induction p
@[simp]
theorem darts_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    (p.append p').darts = p.darts ++ p'.darts := by
  induction p <;> 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ : V
p' : Walk G u✝ w
⊢ darts (append nil p') = darts nil ++ darts p'

Next tactic:
simp [*]