ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SimpleGraph.Walk.length_concat
@[simp]
theorem length_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    (p.concat h).length = p.length + 1 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w)
Goal: (p.concat h).length = p.length + 1
-- SimpleGraph.Walk.length_reverseAux
@[simp]
protected theorem length_reverseAux {u v w : V} (p : G.Walk u v) (q : G.Walk u w) :
    (p.reverseAux q).length = p.length + q.length 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (q : G.Walk u w)
Goal: (p.reverseAux q).length = p.length + q.length
-- SimpleGraph.Walk.length_reverse
@[simp]
theorem length_reverse {u v : V} (p : G.Walk u v) : p.reverse.length = p.length 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.reverse.length = p.length
-- SimpleGraph.Walk.eq_of_length_eq_zero
theorem eq_of_length_eq_zero {u v : V} : ∀ {p : G.Walk u v}, p.length = 0 → u = v
  
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}
Goal: p.length = 0 → u = v
-- SimpleGraph.Walk.adj_of_length_eq_one
theorem adj_of_length_eq_one {u v : V} : ∀ {p : G.Walk u v}, p.length = 1 → G.Adj u v
  
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}
Goal: p.length = 1 → G.Adj u v
-- SimpleGraph.Walk.exists_length_eq_zero_iff
@[simp]
theorem exists_length_eq_zero_iff {u v : V} : (∃ p : G.Walk u v, p.length = 0) ↔ u = v 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V}
Goal: (∃ p, p.length = 0) ↔ u = v
-- SimpleGraph.Walk.length_eq_zero_iff
@[simp]
theorem length_eq_zero_iff {u : V} {p : G.Walk u u} : p.length = 0 ↔ p = nil 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}
Goal: p.length = 0 ↔ p = SimpleGraph.Walk.nil
-- SimpleGraph.Walk.getVert_append
theorem getVert_append {u v w : V} (p : G.Walk u v) (q : G.Walk v w) (i : ℕ) :
    (p.append q).getVert i = if i < p.length then p.getVert i else q.getVert (i - p.length) 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (q : G.Walk v w) (i : ℕ)
Goal: (p.append q).getVert i = if i < p.length then p.getVert i else q.getVert (i - p.length)
-- SimpleGraph.Walk.getVert_reverse
theorem getVert_reverse {u v : V} (p : G.Walk u v) (i : ℕ) :
    p.reverse.getVert i = p.getVert (p.length - i) 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (i : ℕ)
Goal: p.reverse.getVert i = p.getVert (p.length - i)
-- SimpleGraph.Walk.concatRec_nil
@[simp]
theorem concatRec_nil (u : V) :
    @concatRec _ _ motive @Hnil @Hconcat _ _ (nil : G.Walk u u) = Hnil 
Arguments: {V : Type u} {G : SimpleGraph V} {motive : (u v : V) → G.Walk u v → Sort u_1} (Hnil : {u : V} → motive u u SimpleGraph.Walk.nil) (Hconcat : {u v w : V} → (p : G.Walk u v) → (h : G.Adj v w) → motive u v p → motive u w (p.concat h)) (u : V)
Goal: SimpleGraph.Walk.concatRec Hnil Hconcat SimpleGraph.Walk.nil = Hnil
-- SimpleGraph.Walk.concatRec_concat
@[simp]
theorem concatRec_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    @concatRec _ _ motive @Hnil @Hconcat _ _ (p.concat h) =
      Hconcat p h (concatRec @Hnil @Hconcat p) 
Arguments: {V : Type u} {G : SimpleGraph V} {motive : (u v : V) → G.Walk u v → Sort u_1} (Hnil : {u : V} → motive u u SimpleGraph.Walk.nil) (Hconcat : {u v w : V} → (p : G.Walk u v) → (h : G.Adj v w) → motive u v p → motive u w (p.concat h)) {u v w : V} (p : G.Walk u v) (h : G.Adj v w)
Goal: SimpleGraph.Walk.concatRec Hnil Hconcat (p.concat h) = Hconcat p h (SimpleGraph.Walk.concatRec Hnil Hconcat p)
-- SimpleGraph.Walk.concat_ne_nil
theorem concat_ne_nil {u v : V} (p : G.Walk u v) (h : G.Adj v u) : p.concat h ≠ nil 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (h : G.Adj v u)
Goal: p.concat h ≠ SimpleGraph.Walk.nil
-- SimpleGraph.Walk.concat_inj
theorem concat_inj {u v v' w : V} {p : G.Walk u v} {h : G.Adj v w} {p' : G.Walk u v'}
    {h' : G.Adj v' w} (he : p.concat h = p'.concat h') : ∃ hv : v = v', p.copy rfl hv = p' 
Arguments: {V : Type u} {G : SimpleGraph V} {u v v' w : V} {p : G.Walk u v} {h : G.Adj v w} {p' : G.Walk u v'} {h' : G.Adj v' w} (he : p.concat h = p'.concat h')
Goal: ∃ (hv : v = v'), p.copy ⋯ hv = p'
-- SimpleGraph.Walk.support_nil
@[simp]
theorem support_nil {u : V} : (nil : G.Walk u u).support = [u] 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: SimpleGraph.Walk.nil.support = [u]
-- SimpleGraph.Walk.support_cons
@[simp]
theorem support_cons {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).support = u :: p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (h : G.Adj u v) (p : G.Walk v w)
Goal: (SimpleGraph.Walk.cons h p).support = u :: p.support
-- SimpleGraph.Walk.support_concat
@[simp]
theorem support_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    (p.concat h).support = p.support.concat w 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w)
Goal: (p.concat h).support = p.support.concat w
-- SimpleGraph.Walk.support_copy
@[simp]
theorem support_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).support = p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v u' v' : V} (p : G.Walk u v) (hu : u = u') (hv : v = v')
Goal: (p.copy hu hv).support = p.support
-- SimpleGraph.Walk.support_append
theorem support_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    (p.append p').support = p.support ++ p'.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: (p.append p').support = p.support ++ p'.support.tail
-- SimpleGraph.Walk.support_reverse
@[simp]
theorem support_reverse {u v : V} (p : G.Walk u v) : p.reverse.support = p.support.reverse 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.reverse.support = p.support.reverse
-- SimpleGraph.Walk.support_ne_nil
@[simp]
theorem support_ne_nil {u v : V} (p : G.Walk u v) : p.support ≠ [] 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.support ≠ []
-- SimpleGraph.Walk.tail_support_append
theorem tail_support_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    (p.append p').support.tail = p.support.tail ++ p'.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: (p.append p').support.tail = p.support.tail ++ p'.support.tail
-- SimpleGraph.Walk.support_eq_cons
theorem support_eq_cons {u v : V} (p : G.Walk u v) : p.support = u :: p.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.support = u :: p.support.tail
-- SimpleGraph.Walk.start_mem_support
@[simp]
theorem start_mem_support {u v : V} (p : G.Walk u v) : u ∈ p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: u ∈ p.support
-- SimpleGraph.Walk.end_mem_support
@[simp]
theorem end_mem_support {u v : V} (p : G.Walk u v) : v ∈ p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: v ∈ p.support
-- SimpleGraph.Walk.support_nonempty
@[simp]
theorem support_nonempty {u v : V} (p : G.Walk u v) : { w | w ∈ p.support }.Nonempty 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: {w | w ∈ p.support}.Nonempty
-- SimpleGraph.Walk.mem_support_iff
theorem mem_support_iff {u v w : V} (p : G.Walk u v) :
    w ∈ p.support ↔ w = u ∨ w ∈ p.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v)
Goal: w ∈ p.support ↔ w = u ∨ w ∈ p.support.tail
-- SimpleGraph.Walk.mem_support_nil_iff
theorem mem_support_nil_iff {u v : V} : u ∈ (nil : G.Walk v v).support ↔ u = v 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V}
Goal: u ∈ SimpleGraph.Walk.nil.support ↔ u = v
-- SimpleGraph.Walk.mem_tail_support_append_iff
@[simp]
theorem mem_tail_support_append_iff {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    t ∈ (p.append p').support.tail ↔ t ∈ p.support.tail ∨ t ∈ p'.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: t ∈ (p.append p').support.tail ↔ t ∈ p.support.tail ∨ t ∈ p'.support.tail
-- SimpleGraph.Walk.end_mem_tail_support_of_ne
@[simp]
theorem end_mem_tail_support_of_ne {u v : V} (h : u ≠ v) (p : G.Walk u v) : v ∈ p.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (h : u ≠ v) (p : G.Walk u v)
Goal: v ∈ p.support.tail
-- SimpleGraph.Walk.mem_support_append_iff
@[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 
Arguments: {V : Type u} {G : SimpleGraph V} {t u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: t ∈ (p.append p').support ↔ t ∈ p.support ∨ t ∈ p'.support
-- SimpleGraph.Walk.subset_support_append_left
@[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 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (q : G.Walk v w)
Goal: p.support ⊆ (p.append q).support
-- SimpleGraph.Walk.subset_support_append_right
@[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 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (q : G.Walk v w)
Goal: q.support ⊆ (p.append q).support
-- SimpleGraph.Walk.coe_support
theorem coe_support {u v : V} (p : G.Walk u v) :
    (p.support : Multiset V) = {u} + p.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: ↑p.support = {u} + ↑p.support.tail
-- SimpleGraph.Walk.coe_support_append
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 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: ↑(p.append p').support = {u} + ↑p.support.tail + ↑p'.support.tail
-- SimpleGraph.Walk.coe_support_append'
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} 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: ↑(p.append p').support = ↑p.support + ↑p'.support - {v}
-- SimpleGraph.Walk.chain_adj_support
theorem chain_adj_support {u v w : V} (h : G.Adj u v) :
    ∀ (p : G.Walk v w), List.Chain G.Adj u p.support
  
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (h : G.Adj u v) (p : G.Walk v w)
Goal: List.Chain G.Adj u p.support
-- SimpleGraph.Walk.chain'_adj_support
theorem chain'_adj_support {u v : V} : ∀ (p : G.Walk u v), List.Chain' G.Adj p.support
  
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: List.Chain' G.Adj p.support
-- SimpleGraph.Walk.chain_dartAdj_darts
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 
Arguments: {V : Type u} {G : SimpleGraph V} {d : G.Dart} {v w : V} (h : d.toProd.2 = v) (p : G.Walk v w)
Goal: List.Chain G.DartAdj d p.darts
-- SimpleGraph.Walk.chain'_dartAdj_darts
theorem chain'_dartAdj_darts {u v : V} : ∀ (p : G.Walk u v), List.Chain' G.DartAdj p.darts
  
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: List.Chain' G.DartAdj p.darts
-- SimpleGraph.Walk.edges_subset_edgeSet
theorem edges_subset_edgeSet {u v : V} :
    ∀ (p : G.Walk u v) ⦃e : Sym2 V⦄, e ∈ p.edges → e ∈ G.edgeSet
  
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) ⦃e : Sym2 V⦄
Goal: e ∈ p.edges → e ∈ G.edgeSet
-- SimpleGraph.Walk.adj_of_mem_edges
theorem adj_of_mem_edges {u v x y : V} (p : G.Walk u v) (h : s(x, y) ∈ p.edges) : G.Adj x y 
Arguments: {V : Type u} {G : SimpleGraph V} {u v x y : V} (p : G.Walk u v) (h : s(x, y) ∈ p.edges)
Goal: G.Adj x y
-- SimpleGraph.Walk.darts_nil
@[simp]
theorem darts_nil {u : V} : (nil : G.Walk u u).darts = [] 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: SimpleGraph.Walk.nil.darts = []
-- SimpleGraph.Walk.darts_cons
@[simp]
theorem darts_cons {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).darts = ⟨(u, v), h⟩ :: p.darts 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (h : G.Adj u v) (p : G.Walk v w)
Goal: (SimpleGraph.Walk.cons h p).darts = { toProd := (u, v), adj := h } :: p.darts
-- SimpleGraph.Walk.darts_concat
@[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⟩ 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w)
Goal: (p.concat h).darts = p.darts.concat { toProd := (v, w), adj := h }
-- SimpleGraph.Walk.darts_copy
@[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 
Arguments: {V : Type u} {G : SimpleGraph V} {u v u' v' : V} (p : G.Walk u v) (hu : u = u') (hv : v = v')
Goal: (p.copy hu hv).darts = p.darts
-- SimpleGraph.Walk.darts_append
@[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 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: (p.append p').darts = p.darts ++ p'.darts
-- SimpleGraph.Walk.darts_reverse
@[simp]
theorem darts_reverse {u v : V} (p : G.Walk u v) :
    p.reverse.darts = (p.darts.map Dart.symm).reverse 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.reverse.darts = (List.map SimpleGraph.Dart.symm p.darts).reverse
-- SimpleGraph.Walk.mem_darts_reverse
theorem mem_darts_reverse {u v : V} {d : G.Dart} {p : G.Walk u v} :
    d ∈ p.reverse.darts ↔ d.symm ∈ p.darts 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {d : G.Dart} {p : G.Walk u v}
Goal: d ∈ p.reverse.darts ↔ d.symm ∈ p.darts
-- SimpleGraph.Walk.cons_map_snd_darts
theorem cons_map_snd_darts {u v : V} (p : G.Walk u v) : (u :: p.darts.map (·.snd)) = p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: u :: List.map (fun x => x.toProd.2) p.darts = p.support
-- SimpleGraph.Walk.map_snd_darts
theorem map_snd_darts {u v : V} (p : G.Walk u v) : p.darts.map (·.snd) = p.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: List.map (fun x => x.toProd.2) p.darts = p.support.tail
-- SimpleGraph.Walk.map_fst_darts_append
theorem map_fst_darts_append {u v : V} (p : G.Walk u v) :
    p.darts.map (·.fst) ++ [v] = p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: List.map (fun x => x.toProd.1) p.darts ++ [v] = p.support
-- SimpleGraph.Walk.map_fst_darts
theorem map_fst_darts {u v : V} (p : G.Walk u v) : p.darts.map (·.fst) = p.support.dropLast 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: List.map (fun x => x.toProd.1) p.darts = p.support.dropLast
-- SimpleGraph.Walk.edges_nil
@[simp]
theorem edges_nil {u : V} : (nil : G.Walk u u).edges = [] 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: SimpleGraph.Walk.nil.edges = []
-- SimpleGraph.Walk.edges_cons
@[simp]
theorem edges_cons {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).edges = s(u, v) :: p.edges 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (h : G.Adj u v) (p : G.Walk v w)
Goal: (SimpleGraph.Walk.cons h p).edges = s(u, v) :: p.edges
-- SimpleGraph.Walk.edges_concat
@[simp]
theorem edges_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    (p.concat h).edges = p.edges.concat s(v, w) 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w)
Goal: (p.concat h).edges = p.edges.concat s(v, w)
-- SimpleGraph.Walk.edges_copy
@[simp]
theorem edges_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).edges = p.edges 
Arguments: {V : Type u} {G : SimpleGraph V} {u v u' v' : V} (p : G.Walk u v) (hu : u = u') (hv : v = v')
Goal: (p.copy hu hv).edges = p.edges
-- SimpleGraph.Walk.edges_append
@[simp]
theorem edges_append {u v w : V} (p : G.Walk u v) (p' : G.Walk v w) :
    (p.append p').edges = p.edges ++ p'.edges 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (p' : G.Walk v w)
Goal: (p.append p').edges = p.edges ++ p'.edges
-- SimpleGraph.Walk.edges_reverse
@[simp]
theorem edges_reverse {u v : V} (p : G.Walk u v) : p.reverse.edges = p.edges.reverse 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.reverse.edges = p.edges.reverse
-- SimpleGraph.Walk.length_support
@[simp]
theorem length_support {u v : V} (p : G.Walk u v) : p.support.length = p.length + 1 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.support.length = p.length + 1
-- SimpleGraph.Walk.length_darts
@[simp]
theorem length_darts {u v : V} (p : G.Walk u v) : p.darts.length = p.length 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.darts.length = p.length
-- SimpleGraph.Walk.length_edges
@[simp]
theorem length_edges {u v : V} (p : G.Walk u v) : p.edges.length = p.length 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.edges.length = p.length
-- SimpleGraph.Walk.dart_fst_mem_support_of_mem_darts
theorem dart_fst_mem_support_of_mem_darts {u v : V} :
    ∀ (p : G.Walk u v) {d : G.Dart}, d ∈ p.darts → d.fst ∈ p.support
  
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {d : G.Dart}
Goal: d ∈ p.darts → d.toProd.1 ∈ p.support
-- SimpleGraph.Walk.dart_snd_mem_support_of_mem_darts
theorem dart_snd_mem_support_of_mem_darts {u v : V} (p : G.Walk u v) {d : G.Dart}
    (h : d ∈ p.darts) : d.snd ∈ p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {d : G.Dart} (h : d ∈ p.darts)
Goal: d.toProd.2 ∈ p.support
-- SimpleGraph.Walk.fst_mem_support_of_mem_edges
theorem fst_mem_support_of_mem_edges {t u v w : V} (p : G.Walk v w) (he : s(t, u) ∈ p.edges) :
    t ∈ p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {t u v w : V} (p : G.Walk v w) (he : s(t, u) ∈ p.edges)
Goal: t ∈ p.support
-- SimpleGraph.Walk.snd_mem_support_of_mem_edges
theorem snd_mem_support_of_mem_edges {t u v w : V} (p : G.Walk v w) (he : s(t, u) ∈ p.edges) :
    u ∈ p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {t u v w : V} (p : G.Walk v w) (he : s(t, u) ∈ p.edges)
Goal: u ∈ p.support
-- SimpleGraph.Walk.darts_nodup_of_support_nodup
theorem darts_nodup_of_support_nodup {u v : V} {p : G.Walk u v} (h : p.support.Nodup) :
    p.darts.Nodup 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (h : p.support.Nodup)
Goal: p.darts.Nodup
-- SimpleGraph.Walk.edges_nodup_of_support_nodup
theorem edges_nodup_of_support_nodup {u v : V} {p : G.Walk u v} (h : p.support.Nodup) :
    p.edges.Nodup 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (h : p.support.Nodup)
Goal: p.edges.Nodup
-- SimpleGraph.Walk.nil_nil
@[simp] lemma nil_nil : (nil : G.Walk u u).Nil 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: SimpleGraph.Walk.nil.Nil
-- SimpleGraph.Walk.not_nil_cons
@[simp] lemma not_nil_cons {h : G.Adj u v} {p : G.Walk v w} : ¬ (cons h p).Nil 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {h : G.Adj u v} {p : G.Walk v w}
Goal: ¬(SimpleGraph.Walk.cons h p).Nil
-- SimpleGraph.Walk.Nil.eq
protected lemma Nil.eq {p : G.Walk v w} : p.Nil → v = w 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}
Goal: p.Nil → v = w
-- SimpleGraph.Walk.not_nil_of_ne
lemma not_nil_of_ne {p : G.Walk v w} : v ≠ w → ¬ p.Nil 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}
Goal: v ≠ w → ¬p.Nil
-- SimpleGraph.Walk.nil_iff_support_eq
lemma nil_iff_support_eq {p : G.Walk v w} : p.Nil ↔ p.support = [v] 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}
Goal: p.Nil ↔ p.support = [v]
-- SimpleGraph.Walk.nil_iff_length_eq
lemma nil_iff_length_eq {p : G.Walk v w} : p.Nil ↔ p.length = 0 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}
Goal: p.Nil ↔ p.length = 0
-- SimpleGraph.Walk.not_nil_iff
lemma not_nil_iff {p : G.Walk v w} :
    ¬ p.Nil ↔ ∃ (u : V) (h : G.Adj v u) (q : G.Walk u w), p = cons h q 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}
Goal: ¬p.Nil ↔ ∃ u, ∃ (h : G.Adj v u), ∃ q, p = SimpleGraph.Walk.cons h q
-- SimpleGraph.Walk.nil_iff_eq_nil
lemma nil_iff_eq_nil : ∀ {p : G.Walk v v}, p.Nil ↔ p = nil
  
Arguments: {V : Type u} {G : SimpleGraph V} {v : V} {p : G.Walk v v}
Goal: p.Nil ↔ p = SimpleGraph.Walk.nil
-- SimpleGraph.Walk.notNilRec_cons
@[simp]
lemma notNilRec_cons {motive : {u w : V} → (p : G.Walk u w) → ¬ p.Nil → Sort*}
    (cons : {u v w : V} → (h : G.Adj u v) → (q : G.Walk v w) →
    motive (q.cons h) Walk.not_nil_cons) (h' : G.Adj u v) (q' : G.Walk v w) :
    @Walk.notNilRec _ _ _ _ _ cons _ _ = cons h' q' 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {motive : {u w : V} → (p : G.Walk u w) → ¬p.Nil → Sort u_1} (cons : {u v w : V} → (h : G.Adj u v) → (q : G.Walk v w) → motive (SimpleGraph.Walk.cons h q) ⋯) (h' : G.Adj u v) (q' : G.Walk v w)
Goal: SimpleGraph.Walk.notNilRec (fun {u v w} => cons) (SimpleGraph.Walk.cons h' q') ⋯ = cons h' q'
-- SimpleGraph.Walk.adj_sndOfNotNil
@[simp] lemma adj_sndOfNotNil {p : G.Walk v w} (hp : ¬ p.Nil) :
    G.Adj v (p.sndOfNotNil hp) 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w} (hp : ¬p.Nil)
Goal: G.Adj v (p.sndOfNotNil hp)
-- SimpleGraph.Walk.firstDart_toProd
@[simps]
def firstDart (p : G.Walk v w) (hp : ¬ p.Nil) : G.Dart 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} (p : G.Walk v w) (hp : ¬p.Nil)
Goal: (p.firstDart hp).toProd = (v, p.sndOfNotNil hp)
-- SimpleGraph.Walk.edge_firstDart
lemma edge_firstDart (p : G.Walk v w) (hp : ¬ p.Nil) :
    (p.firstDart hp).edge = s(v, p.sndOfNotNil hp) 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} (p : G.Walk v w) (hp : ¬p.Nil)
Goal: (p.firstDart hp).edge = s(v, p.sndOfNotNil hp)
-- SimpleGraph.Walk.cons_tail_eq
@[simp] lemma cons_tail_eq (p : G.Walk x y) (hp : ¬ p.Nil) :
    cons (p.adj_sndOfNotNil hp) (p.tail hp) = p 
Arguments: {V : Type u} {G : SimpleGraph V} {x y : V} (p : G.Walk x y) (hp : ¬p.Nil)
Goal: SimpleGraph.Walk.cons ⋯ (p.tail hp) = p
-- SimpleGraph.Walk.cons_support_tail
@[simp] lemma cons_support_tail (p : G.Walk x y) (hp : ¬p.Nil) :
    x :: (p.tail hp).support = p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {x y : V} (p : G.Walk x y) (hp : ¬p.Nil)
Goal: x :: (p.tail hp).support = p.support
-- SimpleGraph.Walk.length_tail_add_one
@[simp] lemma length_tail_add_one {p : G.Walk x y} (hp : ¬ p.Nil) :
    (p.tail hp).length + 1 = p.length 
Arguments: {V : Type u} {G : SimpleGraph V} {x y : V} {p : G.Walk x y} (hp : ¬p.Nil)
Goal: (p.tail hp).length + 1 = p.length
-- SimpleGraph.Walk.nil_copy
@[simp] lemma nil_copy {x' y' : V} {p : G.Walk x y} (hx : x = x') (hy : y = y') :
    (p.copy hx hy).Nil = p.Nil 
Arguments: {V : Type u} {G : SimpleGraph V} {x y x' y' : V} {p : G.Walk x y} (hx : x = x') (hy : y = y')
Goal: (p.copy hx hy).Nil = p.Nil
-- SimpleGraph.Walk.support_tail
@[simp] lemma support_tail (p : G.Walk v v) (hp) :
    (p.tail hp).support = p.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {v : V} (p : G.Walk v v) (hp : ¬p.Nil)
Goal: (p.tail hp).support = p.support.tail
-- SimpleGraph.Walk.tail_cons
@[simp]
lemma tail_cons {t u v} (p : G.Walk u v) (h : G.Adj t u) :
    (p.cons h).tail not_nil_cons = p 
Arguments: {V : Type u} {G : SimpleGraph V} {t u v : V} (p : G.Walk u v) (h : G.Adj t u)
Goal: (SimpleGraph.Walk.cons h p).tail ⋯ = p
-- SimpleGraph.Walk.tail_support_eq_support_tail
lemma tail_support_eq_support_tail (p : G.Walk u v) (hnp : ¬p.Nil) :
    (p.tail hnp).support = p.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (hnp : ¬p.Nil)
Goal: (p.tail hnp).support = p.support.tail
-- SimpleGraph.Walk.take_spec
@[simp]
theorem take_spec {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).append (p.dropUntil u h) = p 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support)
Goal: (p.takeUntil u h).append (p.dropUntil u h) = p