ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.truncatedInf_sups_of_not_mem
lemma truncatedInf_sups_of_not_mem (ha : a ∉ upperClosure s ⊔ upperClosure t) :
    truncatedInf (s ⊻ t) a = ⊥ 
Arguments: {α : Type u_1} [DistribLattice α] [BoundedOrder α] [DecidableEq α] [DecidableRel fun x x_1 => x ≤ x_1] {s t : Finset α} {a : α} (ha : a ∉ upperClosure ↑s ⊔ upperClosure ↑t)
Goal: (s ⊻ t).truncatedInf a = ⊥
-- Finset.compl_truncatedSup
@[simp] lemma compl_truncatedSup (s : Finset α) (a : α) :
    (truncatedSup s a)ᶜ = truncatedInf sᶜˢ aᶜ 
Arguments: {α : Type u_1} [BooleanAlgebra α] [DecidableRel fun x x_1 => x ≤ x_1] (s : Finset α) (a : α)
Goal: (s.truncatedSup a)ᶜ = sᶜˢ.truncatedInf aᶜ
-- Finset.compl_truncatedInf
@[simp] lemma compl_truncatedInf (s : Finset α) (a : α) :
    (truncatedInf s a)ᶜ = truncatedSup sᶜˢ aᶜ 
Arguments: {α : Type u_1} [BooleanAlgebra α] [DecidableRel fun x x_1 => x ≤ x_1] (s : Finset α) (a : α)
Goal: (s.truncatedInf a)ᶜ = sᶜˢ.truncatedSup aᶜ
-- Finset.card_truncatedSup_union_add_card_truncatedSup_infs
lemma card_truncatedSup_union_add_card_truncatedSup_infs (𝒜 ℬ : Finset (Finset α)) (s : Finset α) :
    (truncatedSup (𝒜 ∪ ℬ) s).card + (truncatedSup (𝒜 ⊼ ℬ) s).card =
      (truncatedSup 𝒜 s).card + (truncatedSup ℬ s).card 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (𝒜 ℬ : Finset (Finset α)) (s : Finset α)
Goal: ((𝒜 ∪ ℬ).truncatedSup s).card + ((𝒜 ⊼ ℬ).truncatedSup s).card = (𝒜.truncatedSup s).card + (ℬ.truncatedSup s).card
-- Finset.card_truncatedInf_union_add_card_truncatedInf_sups
lemma card_truncatedInf_union_add_card_truncatedInf_sups (𝒜 ℬ : Finset (Finset α)) (s : Finset α) :
    (truncatedInf (𝒜 ∪ ℬ) s).card + (truncatedInf (𝒜 ⊻ ℬ) s).card =
      (truncatedInf 𝒜 s).card + (truncatedInf ℬ s).card 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (𝒜 ℬ : Finset (Finset α)) (s : Finset α)
Goal: ((𝒜 ∪ ℬ).truncatedInf s).card + ((𝒜 ⊻ ℬ).truncatedInf s).card = (𝒜.truncatedInf s).card + (ℬ.truncatedInf s).card
-- AhlswedeZhang.supSum_union_add_supSum_infs
lemma supSum_union_add_supSum_infs (𝒜 ℬ : Finset (Finset α)) :
    supSum (𝒜 ∪ ℬ) + supSum (𝒜 ⊼ ℬ) = supSum 𝒜 + supSum ℬ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (𝒜 ℬ : Finset (Finset α))
Goal: AhlswedeZhang.supSum (𝒜 ∪ ℬ) + AhlswedeZhang.supSum (𝒜 ⊼ ℬ) = AhlswedeZhang.supSum 𝒜 + AhlswedeZhang.supSum ℬ
-- AhlswedeZhang.infSum_union_add_infSum_sups
lemma infSum_union_add_infSum_sups (𝒜 ℬ : Finset (Finset α)) :
    infSum (𝒜 ∪ ℬ) + infSum (𝒜 ⊻ ℬ) = infSum 𝒜 + infSum ℬ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (𝒜 ℬ : Finset (Finset α))
Goal: AhlswedeZhang.infSum (𝒜 ∪ ℬ) + AhlswedeZhang.infSum (𝒜 ⊻ ℬ) = AhlswedeZhang.infSum 𝒜 + AhlswedeZhang.infSum ℬ
-- AhlswedeZhang.IsAntichain.le_infSum
lemma IsAntichain.le_infSum (h𝒜 : IsAntichain (· ⊆ ·) (𝒜 : Set (Finset α))) (h𝒜₀ : ∅ ∉ 𝒜) :
    ∑ s ∈ 𝒜, ((card α).choose s.card : ℚ)⁻¹ ≤ infSum 𝒜 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {𝒜 : Finset (Finset α)} (h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜) (h𝒜₀ : ∅ ∉ 𝒜)
Goal: ∑ s ∈ 𝒜, (↑((Fintype.card α).choose s.card))⁻¹ ≤ AhlswedeZhang.infSum 𝒜
-- AhlswedeZhang.supSum_singleton
@[simp] lemma supSum_singleton (hs : s ≠ univ) :
    supSum ({s} : Finset (Finset α)) = card α * ∑ k ∈ range (card α), (k : ℚ)⁻¹ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {s : Finset α} [Nonempty α] (hs : s ≠ Finset.univ)
Goal: AhlswedeZhang.supSum {s} = ↑(Fintype.card α) * ∑ k ∈ Finset.range (Fintype.card α), (↑k)⁻¹
-- AhlswedeZhang.infSum_compls_add_supSum
lemma infSum_compls_add_supSum (𝒜 : Finset (Finset α)) :
    infSum 𝒜ᶜˢ + supSum 𝒜 = card α * ∑ k ∈ range (card α), (k : ℚ)⁻¹ + 1 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] [Nonempty α] (𝒜 : Finset (Finset α))
Goal: AhlswedeZhang.infSum 𝒜ᶜˢ + AhlswedeZhang.supSum 𝒜 = ↑(Fintype.card α) * ∑ k ∈ Finset.range (Fintype.card α), (↑k)⁻¹ + 1
-- AhlswedeZhang.supSum_of_not_univ_mem
lemma supSum_of_not_univ_mem (h𝒜₁ : 𝒜.Nonempty) (h𝒜₂ : univ ∉ 𝒜) :
    supSum 𝒜 = card α * ∑ k ∈ range (card α), (k : ℚ)⁻¹ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {𝒜 : Finset (Finset α)} [Nonempty α] (h𝒜₁ : 𝒜.Nonempty) (h𝒜₂ : Finset.univ ∉ 𝒜)
Goal: AhlswedeZhang.supSum 𝒜 = ↑(Fintype.card α) * ∑ k ∈ Finset.range (Fintype.card α), (↑k)⁻¹
-- AhlswedeZhang.infSum_eq_one
lemma infSum_eq_one (h𝒜₁ : 𝒜.Nonempty) (h𝒜₀ : ∅ ∉ 𝒜) : infSum 𝒜 = 1 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {𝒜 : Finset (Finset α)} [Nonempty α] (h𝒜₁ : 𝒜.Nonempty) (h𝒜₀ : ∅ ∉ 𝒜)
Goal: AhlswedeZhang.infSum 𝒜 = 1
-- szemeredi_regularity
theorem szemeredi_regularity (hε : 0 < ε) (hl : l ≤ card α) :
    ∃ P : Finpartition univ,
      P.IsEquipartition ∧ l ≤ P.parts.card ∧ P.parts.card ≤ bound ε l ∧ P.IsUniform G ε 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (G : SimpleGraph α) [DecidableRel G.Adj] {ε : ℝ} {l : ℕ} (hε : 0 < ε) (hl : l ≤ Fintype.card α)
Goal: ∃ P, P.IsEquipartition ∧ l ≤ P.parts.card ∧ P.parts.card ≤ SzemerediRegularity.bound ε l ∧ P.IsUniform G ε
-- SimpleGraph.Walk.IsTrail.even_countP_edges_iff
theorem IsTrail.even_countP_edges_iff {u v : V} {p : G.Walk u v} (ht : p.IsTrail) (x : V) :
    Even (p.edges.countP fun e => x ∈ e) ↔ u ≠ v → x ≠ u ∧ x ≠ v 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] {u v : V} {p : G.Walk u v} (ht : p.IsTrail) (x : V)
Goal: Even (List.countP (fun e => decide (x ∈ e)) p.edges) ↔ u ≠ v → x ≠ u ∧ x ≠ v
-- SimpleGraph.Walk.IsEulerian.isTrail
theorem IsEulerian.isTrail {u v : V} {p : G.Walk u v} (h : p.IsEulerian) : p.IsTrail 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsEulerian)
Goal: p.IsTrail
-- SimpleGraph.Walk.IsEulerian.mem_edges_iff
theorem IsEulerian.mem_edges_iff {u v : V} {p : G.Walk u v} (h : p.IsEulerian) {e : Sym2 V} :
    e ∈ p.edges ↔ e ∈ G.edgeSet 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsEulerian) {e : Sym2 V}
Goal: e ∈ p.edges ↔ e ∈ G.edgeSet
-- SimpleGraph.Walk.IsTrail.isEulerian_of_forall_mem
theorem IsTrail.isEulerian_of_forall_mem {u v : V} {p : G.Walk u v} (h : p.IsTrail)
    (hc : ∀ e, e ∈ G.edgeSet → e ∈ p.edges) : p.IsEulerian 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsTrail) (hc : ∀ e ∈ G.edgeSet, e ∈ p.edges)
Goal: p.IsEulerian
-- SimpleGraph.Walk.isEulerian_iff
theorem isEulerian_iff {u v : V} (p : G.Walk u v) :
    p.IsEulerian ↔ p.IsTrail ∧ ∀ e, e ∈ G.edgeSet → e ∈ p.edges 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] {u v : V} (p : G.Walk u v)
Goal: p.IsEulerian ↔ p.IsTrail ∧ ∀ e ∈ G.edgeSet, e ∈ p.edges
-- SimpleGraph.Walk.IsEulerian.edgesFinset_eq
theorem IsEulerian.edgesFinset_eq [Fintype G.edgeSet] {u v : V} {p : G.Walk u v}
    (h : p.IsEulerian) : h.isTrail.edgesFinset = G.edgeFinset 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] [Fintype ↑G.edgeSet] {u v : V} {p : G.Walk u v} (h : p.IsEulerian)
Goal: ⋯.edgesFinset = G.edgeFinset
-- SimpleGraph.Walk.IsEulerian.even_degree_iff
theorem IsEulerian.even_degree_iff {x u v : V} {p : G.Walk u v} (ht : p.IsEulerian) [Fintype V]
    [DecidableRel G.Adj] : Even (G.degree x) ↔ u ≠ v → x ≠ u ∧ x ≠ v 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] {x u v : V} {p : G.Walk u v} (ht : p.IsEulerian) [Fintype V] [DecidableRel G.Adj]
Goal: Even (G.degree x) ↔ u ≠ v → x ≠ u ∧ x ≠ v
-- SimpleGraph.Walk.IsEulerian.card_filter_odd_degree
theorem IsEulerian.card_filter_odd_degree [Fintype V] [DecidableRel G.Adj] {u v : V}
    {p : G.Walk u v} (ht : p.IsEulerian) {s}
    (h : s = (Finset.univ : Finset V).filter fun v => Odd (G.degree v)) :
    s.card = 0 ∨ s.card = 2 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] [Fintype V] [DecidableRel G.Adj] {u v : V} {p : G.Walk u v} (ht : p.IsEulerian) {s : Finset V} (h : s = Finset.filter (fun v => Odd (G.degree v)) Finset.univ)
Goal: s.card = 0 ∨ s.card = 2
-- SimpleGraph.Walk.IsEulerian.card_odd_degree
theorem IsEulerian.card_odd_degree [Fintype V] [DecidableRel G.Adj] {u v : V} {p : G.Walk u v}
    (ht : p.IsEulerian) : Fintype.card { v : V | Odd (G.degree v) } = 0 ∨
      Fintype.card { v : V | Odd (G.degree v) } = 2 
Arguments: {V : Type u_1} {G : SimpleGraph V} [DecidableEq V] [Fintype V] [DecidableRel G.Adj] {u v : V} {p : G.Walk u v} (ht : p.IsEulerian)
Goal: Fintype.card ↑{v | Odd (G.degree v)} = 0 ∨ Fintype.card ↑{v | Odd (G.degree v)} = 2
-- SimpleGraph.Walk.IsTrail.edges_nodup
@[mk_iff isTrail_def]
structure IsTrail {u v : V} (p : G.Walk u v) : Prop where
  edges_nodup : p.edges.Nodup
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (self : p.IsTrail)
Goal: p.edges.Nodup
-- SimpleGraph.Walk.isTrail_def
@[mk_iff isTrail_def]
structure IsTrail {u v : V} (p : G.Walk u v) : Prop where
  edges_nodup : p.edges.Nodup
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.IsTrail ↔ p.edges.Nodup
-- SimpleGraph.Walk.IsPath.support_nodup
structure IsPath {u v : V} (p : G.Walk u v) extends IsTrail p : Prop where
  support_nodup : p.support.Nodup
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (self : p.IsPath)
Goal: p.support.Nodup
-- SimpleGraph.Walk.IsPath.isTrail
protected lemma IsPath.isTrail {p : Walk G u v}(h : IsPath p) : IsTrail p 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (h : p.IsPath)
Goal: p.IsTrail
-- SimpleGraph.Walk.isCircuit_def
@[mk_iff isCircuit_def]
structure IsCircuit {u : V} (p : G.Walk u u) extends IsTrail p : Prop where
  ne_nil : p ≠ nil
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} (p : G.Walk u u)
Goal: p.IsCircuit ↔ p.IsTrail ∧ p ≠ SimpleGraph.Walk.nil
-- SimpleGraph.Walk.IsCircuit.ne_nil
@[mk_iff isCircuit_def]
structure IsCircuit {u : V} (p : G.Walk u u) extends IsTrail p : Prop where
  ne_nil : p ≠ nil
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u} (self : p.IsCircuit)
Goal: p ≠ SimpleGraph.Walk.nil
-- SimpleGraph.Walk.IsCircuit.isTrail
protected lemma IsCircuit.isTrail {p : Walk G u u} (h : IsCircuit p) : IsTrail p 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u} (h : p.IsCircuit)
Goal: p.IsTrail
-- SimpleGraph.Walk.IsCycle.support_nodup
structure IsCycle {u : V} (p : G.Walk u u) extends IsCircuit p : Prop where
  support_nodup : p.support.tail.Nodup
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u} (self : p.IsCycle)
Goal: p.support.tail.Nodup
-- SimpleGraph.Walk.IsCycle.isCircuit
protected lemma IsCycle.isCircuit {p : Walk G u u} (h : IsCycle p) : IsCircuit p 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u} (h : p.IsCycle)
Goal: p.IsCircuit
-- SimpleGraph.Walk.isTrail_copy
@[simp]
theorem isTrail_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).IsTrail ↔ p.IsTrail 
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).IsTrail ↔ p.IsTrail
-- SimpleGraph.Walk.IsPath.mk'
theorem IsPath.mk' {u v : V} {p : G.Walk u v} (h : p.support.Nodup) : p.IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (h : p.support.Nodup)
Goal: p.IsPath
-- SimpleGraph.Walk.isPath_def
theorem isPath_def {u v : V} (p : G.Walk u v) : p.IsPath ↔ p.support.Nodup 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.IsPath ↔ p.support.Nodup
-- SimpleGraph.Walk.isPath_copy
@[simp]
theorem isPath_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).IsPath ↔ p.IsPath 
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).IsPath ↔ p.IsPath
-- SimpleGraph.Walk.isCircuit_copy
@[simp]
theorem isCircuit_copy {u u'} (p : G.Walk u u) (hu : u = u') :
    (p.copy hu hu).IsCircuit ↔ p.IsCircuit 
Arguments: {V : Type u} {G : SimpleGraph V} {u u' : V} (p : G.Walk u u) (hu : u = u')
Goal: (p.copy hu hu).IsCircuit ↔ p.IsCircuit
-- SimpleGraph.Walk.IsCircuit.not_nil
lemma IsCircuit.not_nil {p : G.Walk v v} (hp : IsCircuit p) : ¬ p.Nil 
Arguments: {V : Type u} {G : SimpleGraph V} {v : V} {p : G.Walk v v} (hp : p.IsCircuit)
Goal: ¬p.Nil
-- SimpleGraph.Walk.isCycle_def
theorem isCycle_def {u : V} (p : G.Walk u u) :
    p.IsCycle ↔ p.IsTrail ∧ p ≠ nil ∧ p.support.tail.Nodup 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} (p : G.Walk u u)
Goal: p.IsCycle ↔ p.IsTrail ∧ p ≠ SimpleGraph.Walk.nil ∧ p.support.tail.Nodup
-- SimpleGraph.Walk.isCycle_copy
@[simp]
theorem isCycle_copy {u u'} (p : G.Walk u u) (hu : u = u') :
    (p.copy hu hu).IsCycle ↔ p.IsCycle 
Arguments: {V : Type u} {G : SimpleGraph V} {u u' : V} (p : G.Walk u u) (hu : u = u')
Goal: (p.copy hu hu).IsCycle ↔ p.IsCycle
-- SimpleGraph.Walk.IsCycle.not_nil
lemma IsCycle.not_nil {p : G.Walk v v} (hp : IsCycle p) : ¬ p.Nil 
Arguments: {V : Type u} {G : SimpleGraph V} {v : V} {p : G.Walk v v} (hp : p.IsCycle)
Goal: ¬p.Nil
-- SimpleGraph.Walk.IsTrail.nil
@[simp]
theorem IsTrail.nil {u : V} : (nil : G.Walk u u).IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: SimpleGraph.Walk.nil.IsTrail
-- SimpleGraph.Walk.IsTrail.of_cons
theorem IsTrail.of_cons {u v w : V} {h : G.Adj u v} {p : G.Walk v w} :
    (cons h p).IsTrail → p.IsTrail 
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).IsTrail → p.IsTrail
-- SimpleGraph.Walk.cons_isTrail_iff
@[simp]
theorem cons_isTrail_iff {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).IsTrail ↔ p.IsTrail ∧ 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).IsTrail ↔ p.IsTrail ∧ s(u, v) ∉ p.edges
-- SimpleGraph.Walk.IsTrail.reverse
theorem IsTrail.reverse {u v : V} (p : G.Walk u v) (h : p.IsTrail) : p.reverse.IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (h : p.IsTrail)
Goal: p.reverse.IsTrail
-- SimpleGraph.Walk.reverse_isTrail_iff
@[simp]
theorem reverse_isTrail_iff {u v : V} (p : G.Walk u v) : p.reverse.IsTrail ↔ p.IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.reverse.IsTrail ↔ p.IsTrail
-- SimpleGraph.Walk.IsTrail.of_append_left
theorem IsTrail.of_append_left {u v w : V} {p : G.Walk u v} {q : G.Walk v w}
    (h : (p.append q).IsTrail) : p.IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w} (h : (p.append q).IsTrail)
Goal: p.IsTrail
-- SimpleGraph.Walk.IsTrail.of_append_right
theorem IsTrail.of_append_right {u v w : V} {p : G.Walk u v} {q : G.Walk v w}
    (h : (p.append q).IsTrail) : q.IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w} (h : (p.append q).IsTrail)
Goal: q.IsTrail
-- SimpleGraph.Walk.IsTrail.count_edges_le_one
theorem IsTrail.count_edges_le_one [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsTrail)
    (e : Sym2 V) : p.edges.count e ≤ 1 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsTrail) (e : Sym2 V)
Goal: List.count e p.edges ≤ 1
-- SimpleGraph.Walk.IsTrail.count_edges_eq_one
theorem IsTrail.count_edges_eq_one [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsTrail)
    {e : Sym2 V} (he : e ∈ p.edges) : p.edges.count e = 1 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsTrail) {e : Sym2 V} (he : e ∈ p.edges)
Goal: List.count e p.edges = 1
-- SimpleGraph.Walk.IsPath.nil
theorem IsPath.nil {u : V} : (nil : G.Walk u u).IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: SimpleGraph.Walk.nil.IsPath
-- SimpleGraph.Walk.IsPath.of_cons
theorem IsPath.of_cons {u v w : V} {h : G.Adj u v} {p : G.Walk v w} :
    (cons h p).IsPath → p.IsPath 
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).IsPath → p.IsPath
-- SimpleGraph.Walk.cons_isPath_iff
@[simp]
theorem cons_isPath_iff {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).IsPath ↔ p.IsPath ∧ 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).IsPath ↔ p.IsPath ∧ u ∉ p.support
-- SimpleGraph.Walk.IsPath.cons
protected lemma IsPath.cons {p : Walk G v w} (hp : p.IsPath) (hu : u ∉ p.support) {h : G.Adj u v} :
    (cons h p).IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk v w} (hp : p.IsPath) (hu : u ∉ p.support) {h : G.Adj u v}
Goal: (SimpleGraph.Walk.cons h p).IsPath
-- SimpleGraph.Walk.isPath_iff_eq_nil
@[simp]
theorem isPath_iff_eq_nil {u : V} (p : G.Walk u u) : p.IsPath ↔ p = nil 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} (p : G.Walk u u)
Goal: p.IsPath ↔ p = SimpleGraph.Walk.nil
-- SimpleGraph.Walk.IsPath.reverse
theorem IsPath.reverse {u v : V} {p : G.Walk u v} (h : p.IsPath) : p.reverse.IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (h : p.IsPath)
Goal: p.reverse.IsPath
-- SimpleGraph.Walk.isPath_reverse_iff
@[simp]
theorem isPath_reverse_iff {u v : V} (p : G.Walk u v) : p.reverse.IsPath ↔ p.IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.reverse.IsPath ↔ p.IsPath
-- SimpleGraph.Walk.IsPath.of_append_left
theorem IsPath.of_append_left {u v w : V} {p : G.Walk u v} {q : G.Walk v w} :
    (p.append q).IsPath → p.IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w}
Goal: (p.append q).IsPath → p.IsPath
-- SimpleGraph.Walk.IsPath.of_append_right
theorem IsPath.of_append_right {u v w : V} {p : G.Walk u v} {q : G.Walk v w}
    (h : (p.append q).IsPath) : q.IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w} (h : (p.append q).IsPath)
Goal: q.IsPath
-- SimpleGraph.Walk.IsCycle.not_of_nil
@[simp]
theorem IsCycle.not_of_nil {u : V} : ¬(nil : G.Walk u u).IsCycle 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: ¬SimpleGraph.Walk.nil.IsCycle
-- SimpleGraph.Walk.IsCycle.ne_bot
lemma IsCycle.ne_bot : ∀ {p : G.Walk u u}, p.IsCycle → G ≠ ⊥
  
Arguments: {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}
Goal: p.IsCycle → G ≠ ⊥
-- SimpleGraph.Walk.IsCycle.three_le_length
lemma IsCycle.three_le_length {v : V} {p : G.Walk v v} (hp : p.IsCycle) : 3 ≤ p.length 
Arguments: {V : Type u} {G : SimpleGraph V} {v : V} {p : G.Walk v v} (hp : p.IsCycle)
Goal: 3 ≤ p.length
-- SimpleGraph.Walk.cons_isCycle_iff
theorem cons_isCycle_iff {u v : V} (p : G.Walk v u) (h : G.Adj u v) :
    (Walk.cons h p).IsCycle ↔ p.IsPath ∧ ¬s(u, v) ∈ p.edges 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk v u) (h : G.Adj u v)
Goal: (SimpleGraph.Walk.cons h p).IsCycle ↔ p.IsPath ∧ s(u, v) ∉ p.edges
-- SimpleGraph.Walk.IsPath.tail
lemma IsPath.tail {p : G.Walk u v} (hp : p.IsPath) (hp' : ¬ p.Nil) : (p.tail hp').IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (hp : p.IsPath) (hp' : ¬p.Nil)
Goal: (p.tail hp').IsPath
-- SimpleGraph.Walk.IsPath.length_lt
theorem IsPath.length_lt [Fintype V] {u v : V} {p : G.Walk u v} (hp : p.IsPath) :
    p.length < Fintype.card V 
Arguments: {V : Type u} {G : SimpleGraph V} [Fintype V] {u v : V} {p : G.Walk u v} (hp : p.IsPath)
Goal: p.length < Fintype.card V
-- SimpleGraph.Walk.IsTrail.takeUntil
protected theorem IsTrail.takeUntil {u v w : V} {p : G.Walk v w} (hc : p.IsTrail)
    (h : u ∈ p.support) : (p.takeUntil u h).IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} {p : G.Walk v w} (hc : p.IsTrail) (h : u ∈ p.support)
Goal: (p.takeUntil u h).IsTrail
-- SimpleGraph.Walk.IsTrail.dropUntil
protected theorem IsTrail.dropUntil {u v w : V} {p : G.Walk v w} (hc : p.IsTrail)
    (h : u ∈ p.support) : (p.dropUntil u h).IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} {p : G.Walk v w} (hc : p.IsTrail) (h : u ∈ p.support)
Goal: (p.dropUntil u h).IsTrail
-- SimpleGraph.Walk.IsPath.takeUntil
protected theorem IsPath.takeUntil {u v w : V} {p : G.Walk v w} (hc : p.IsPath)
    (h : u ∈ p.support) : (p.takeUntil u h).IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} {p : G.Walk v w} (hc : p.IsPath) (h : u ∈ p.support)
Goal: (p.takeUntil u h).IsPath
-- SimpleGraph.Walk.IsPath.dropUntil
protected theorem IsPath.dropUntil {u v w : V} {p : G.Walk v w} (hc : p.IsPath)
    (h : u ∈ p.support) : (p.dropUntil u h).IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} {p : G.Walk v w} (hc : p.IsPath) (h : u ∈ p.support)
Goal: (p.dropUntil u h).IsPath
-- SimpleGraph.Walk.IsTrail.rotate
protected theorem IsTrail.rotate {u v : V} {c : G.Walk v v} (hc : c.IsTrail) (h : u ∈ c.support) :
    (c.rotate h).IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} {c : G.Walk v v} (hc : c.IsTrail) (h : u ∈ c.support)
Goal: (c.rotate h).IsTrail
-- SimpleGraph.Walk.IsCircuit.rotate
protected theorem IsCircuit.rotate {u v : V} {c : G.Walk v v} (hc : c.IsCircuit)
    (h : u ∈ c.support) : (c.rotate h).IsCircuit 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} {c : G.Walk v v} (hc : c.IsCircuit) (h : u ∈ c.support)
Goal: (c.rotate h).IsCircuit
-- SimpleGraph.Walk.IsCycle.rotate
protected theorem IsCycle.rotate {u v : V} {c : G.Walk v v} (hc : c.IsCycle) (h : u ∈ c.support) :
    (c.rotate h).IsCycle 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} {c : G.Walk v v} (hc : c.IsCycle) (h : u ∈ c.support)
Goal: (c.rotate h).IsCycle
-- SimpleGraph.Path.isPath
@[simp]
protected theorem isPath {u v : V} (p : G.Path u v) : (p : G.Walk u v).IsPath 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Path u v)
Goal: (↑p).IsPath
-- SimpleGraph.Path.isTrail
@[simp]
protected theorem isTrail {u v : V} (p : G.Path u v) : (p : G.Walk u v).IsTrail 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Path u v)
Goal: (↑p).IsTrail
-- SimpleGraph.Path.nil_coe
@[refl, simps]
protected def nil {u : V} : G.Path u u 
Arguments: {V : Type u} {G : SimpleGraph V} {u : V}
Goal: ↑SimpleGraph.Path.nil = SimpleGraph.Walk.nil
-- SimpleGraph.Path.singleton_coe
@[simps]
def singleton {u v : V} (h : G.Adj u v) : G.Path u v 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (h : G.Adj u v)
Goal: ↑(SimpleGraph.Path.singleton h) = SimpleGraph.Walk.cons h SimpleGraph.Walk.nil
-- SimpleGraph.Path.mk'_mem_edges_singleton
theorem mk'_mem_edges_singleton {u v : V} (h : G.Adj u v) :
    s(u, v) ∈ (singleton h : G.Walk u v).edges 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (h : G.Adj u v)
Goal: s(u, v) ∈ (↑(SimpleGraph.Path.singleton h)).edges
-- SimpleGraph.Path.reverse_coe
@[symm, simps]
def reverse {u v : V} (p : G.Path u v) : G.Path v u 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Path u v)
Goal: ↑p.reverse = (↑p).reverse
-- SimpleGraph.Path.count_support_eq_one
theorem count_support_eq_one [DecidableEq V] {u v w : V} {p : G.Path u v}
    (hw : w ∈ (p : G.Walk u v).support) : (p : G.Walk u v).support.count w = 1 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} {p : G.Path u v} (hw : w ∈ (↑p).support)
Goal: List.count w (↑p).support = 1
-- SimpleGraph.Path.count_edges_eq_one
theorem count_edges_eq_one [DecidableEq V] {u v : V} {p : G.Path u v} (e : Sym2 V)
    (hw : e ∈ (p : G.Walk u v).edges) : (p : G.Walk u v).edges.count e = 1 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} {p : G.Path u v} (e : Sym2 V) (hw : e ∈ (↑p).edges)
Goal: List.count e (↑p).edges = 1
-- SimpleGraph.Path.nodup_support
@[simp]
theorem nodup_support {u v : V} (p : G.Path u v) : (p : G.Walk u v).support.Nodup 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Path u v)
Goal: (↑p).support.Nodup
-- SimpleGraph.Path.loop_eq
theorem loop_eq {v : V} (p : G.Path v v) : p = Path.nil 
Arguments: {V : Type u} {G : SimpleGraph V} {v : V} (p : G.Path v v)
Goal: p = SimpleGraph.Path.nil
-- SimpleGraph.Path.not_mem_edges_of_loop
theorem not_mem_edges_of_loop {v : V} {e : Sym2 V} {p : G.Path v v} :
    ¬e ∈ (p : G.Walk v v).edges 
Arguments: {V : Type u} {G : SimpleGraph V} {v : V} {e : Sym2 V} {p : G.Path v v}
Goal: e ∉ (↑p).edges