ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SimpleGraph.Walk.mem_support_iff_exists_append
theorem mem_support_iff_exists_append {V : Type u} {G : SimpleGraph V} {u v w : V}
    {p : G.Walk u v} : w ∈ p.support ↔ ∃ (q : G.Walk u w) (r : G.Walk w v), p = q.append r 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v}
Goal: w ∈ p.support ↔ ∃ q r, p = q.append r
-- SimpleGraph.Walk.count_support_takeUntil_eq_one
@[simp]
theorem count_support_takeUntil_eq_one {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).support.count u = 1 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support)
Goal: List.count u (p.takeUntil u h).support = 1
-- SimpleGraph.Walk.count_edges_takeUntil_le_one
theorem count_edges_takeUntil_le_one {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) (x : V) :
    (p.takeUntil u h).edges.count s(u, x) ≤ 1 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) (x : V)
Goal: List.count s(u, x) (p.takeUntil u h).edges ≤ 1
-- SimpleGraph.Walk.takeUntil_copy
@[simp]
theorem takeUntil_copy {u v w v' w'} (p : G.Walk v w) (hv : v = v') (hw : w = w')
    (h : u ∈ (p.copy hv hw).support) :
    (p.copy hv hw).takeUntil u h = (p.takeUntil u (by subst_vars; exact h)).copy hv rfl 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w v' w' : V} (p : G.Walk v w) (hv : v = v') (hw : w = w') (h : u ∈ (p.copy hv hw).support)
Goal: (p.copy hv hw).takeUntil u h = (p.takeUntil u ⋯).copy hv ⋯
-- SimpleGraph.Walk.dropUntil_copy
@[simp]
theorem dropUntil_copy {u v w v' w'} (p : G.Walk v w) (hv : v = v') (hw : w = w')
    (h : u ∈ (p.copy hv hw).support) :
    (p.copy hv hw).dropUntil u h = (p.dropUntil u (by subst_vars; exact h)).copy rfl hw 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w v' w' : V} (p : G.Walk v w) (hv : v = v') (hw : w = w') (h : u ∈ (p.copy hv hw).support)
Goal: (p.copy hv hw).dropUntil u h = (p.dropUntil u ⋯).copy ⋯ hw
-- SimpleGraph.Walk.support_takeUntil_subset
theorem support_takeUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).support ⊆ p.support 
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).support ⊆ p.support
-- SimpleGraph.Walk.support_dropUntil_subset
theorem support_dropUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.dropUntil u h).support ⊆ p.support 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support)
Goal: (p.dropUntil u h).support ⊆ p.support
-- SimpleGraph.Walk.darts_takeUntil_subset
theorem darts_takeUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).darts ⊆ p.darts 
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).darts ⊆ p.darts
-- SimpleGraph.Walk.darts_dropUntil_subset
theorem darts_dropUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.dropUntil u h).darts ⊆ p.darts 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support)
Goal: (p.dropUntil u h).darts ⊆ p.darts
-- SimpleGraph.Walk.edges_takeUntil_subset
theorem edges_takeUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).edges ⊆ p.edges 
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).edges ⊆ p.edges
-- SimpleGraph.Walk.edges_dropUntil_subset
theorem edges_dropUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.dropUntil u h).edges ⊆ p.edges 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support)
Goal: (p.dropUntil u h).edges ⊆ p.edges
-- SimpleGraph.Walk.length_takeUntil_le
theorem length_takeUntil_le {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.takeUntil u h).length ≤ p.length 
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).length ≤ p.length
-- SimpleGraph.Walk.length_dropUntil_le
theorem length_dropUntil_le {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.dropUntil u h).length ≤ p.length 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support)
Goal: (p.dropUntil u h).length ≤ p.length
-- SimpleGraph.Walk.support_rotate
@[simp]
theorem support_rotate {u v : V} (c : G.Walk v v) (h : u ∈ c.support) :
    (c.rotate h).support.tail ~r c.support.tail 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} (c : G.Walk v v) (h : u ∈ c.support)
Goal: (c.rotate h).support.tail ~r c.support.tail
-- SimpleGraph.Walk.rotate_darts
theorem rotate_darts {u v : V} (c : G.Walk v v) (h : u ∈ c.support) :
    (c.rotate h).darts ~r c.darts 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} (c : G.Walk v v) (h : u ∈ c.support)
Goal: (c.rotate h).darts ~r c.darts
-- SimpleGraph.Walk.rotate_edges
theorem rotate_edges {u v : V} (c : G.Walk v v) (h : u ∈ c.support) :
    (c.rotate h).edges ~r c.edges 
Arguments: {V : Type u} {G : SimpleGraph V} [DecidableEq V] {u v : V} (c : G.Walk v v) (h : u ∈ c.support)
Goal: (c.rotate h).edges ~r c.edges
-- SimpleGraph.Walk.exists_boundary_dart
theorem exists_boundary_dart {u v : V} (p : G.Walk u v) (S : Set V) (uS : u ∈ S) (vS : v ∉ S) :
    ∃ d : G.Dart, d ∈ p.darts ∧ d.fst ∈ S ∧ d.snd ∉ S 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (S : Set V) (uS : u ∈ S) (vS : v ∉ S)
Goal: ∃ d ∈ p.darts, d.toProd.1 ∈ S ∧ d.toProd.2 ∉ S
-- SimpleGraph.Walk.getVert_tail
lemma getVert_tail {u v n} (p : G.Walk u v) (hnp: ¬ p.Nil) :
    (p.tail hnp).getVert n = p.getVert (n + 1) 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} {n : ℕ} (p : G.Walk u v) (hnp : ¬p.Nil)
Goal: (p.tail hnp).getVert n = p.getVert (n + 1)
-- SimpleGraph.Walk.cons_sndOfNotNil
@[simp]
lemma cons_sndOfNotNil (q : G.Walk v w) (hadj : G.Adj u v) :
    (q.cons hadj).sndOfNotNil not_nil_cons = v 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} (q : G.Walk v w) (hadj : G.Adj u v)
Goal: (SimpleGraph.Walk.cons hadj q).sndOfNotNil ⋯ = v
-- SimpleGraph.Walk.getVert_one
lemma getVert_one (p : G.Walk u v) (hnp : ¬ p.Nil) : p.getVert 1 = p.sndOfNotNil hnp 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (hnp : ¬p.Nil)
Goal: p.getVert 1 = p.sndOfNotNil hnp
-- SimpleGraph.Walk.mem_support_iff_exists_getVert
theorem mem_support_iff_exists_getVert {u v w : V} {p : G.Walk v w} :
    u ∈ p.support ↔ ∃ n, p.getVert n = u ∧ n ≤ p.length 
Arguments: {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk v w}
Goal: u ∈ p.support ↔ ∃ n, p.getVert n = u ∧ n ≤ p.length
-- SimpleGraph.Walk.map_nil
@[simp]
theorem map_nil : (nil : G.Walk u u).map f = nil 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u : V}
Goal: SimpleGraph.Walk.map f SimpleGraph.Walk.nil = SimpleGraph.Walk.nil
-- SimpleGraph.Walk.map_cons
@[simp]
theorem map_cons {w : V} (h : G.Adj w u) : (cons h p).map f = cons (f.map_adj h) (p.map f) 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v : V} (p : G.Walk u v) {w : V} (h : G.Adj w u)
Goal: SimpleGraph.Walk.map f (SimpleGraph.Walk.cons h p) = SimpleGraph.Walk.cons ⋯ (SimpleGraph.Walk.map f p)
-- SimpleGraph.Walk.map_copy
@[simp]
theorem map_copy (hu : u = u') (hv : v = v') :
    (p.copy hu hv).map f = (p.map f).copy (hu ▸ rfl) (hv ▸ rfl) 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v u' v' : V} (p : G.Walk u v) (hu : u = u') (hv : v = v')
Goal: SimpleGraph.Walk.map f (p.copy hu hv) = (SimpleGraph.Walk.map f p).copy ⋯ ⋯
-- SimpleGraph.Walk.map_id
@[simp]
theorem map_id (p : G.Walk u v) : p.map Hom.id = p 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: ∀ (p : G.Walk u v), SimpleGraph.Walk.map SimpleGraph.Hom.id p = p
-- SimpleGraph.Walk.map_map
@[simp]
theorem map_map : (p.map f).map f' = p.map (f'.comp f) 
Arguments: {V : Type u} {V' : Type v} {V'' : Type w} {G : SimpleGraph V} {G' : SimpleGraph V'} {G'' : SimpleGraph V''} (f : G →g G') (f' : G' →g G'') {u v : V} (p : G.Walk u v)
Goal: SimpleGraph.Walk.map f' (SimpleGraph.Walk.map f p) = SimpleGraph.Walk.map (f'.comp f) p
-- SimpleGraph.Walk.map_eq_of_eq
theorem map_eq_of_eq {f : G →g G'} (f' : G →g G') (h : f = f') :
    p.map f = (p.map f').copy (h ▸ rfl) (h ▸ rfl) 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} {u v : V} (p : G.Walk u v) {f : G →g G'} (f' : G →g G') (h : f = f')
Goal: SimpleGraph.Walk.map f p = (SimpleGraph.Walk.map f' p).copy ⋯ ⋯
-- SimpleGraph.Walk.map_eq_nil_iff
@[simp]
theorem map_eq_nil_iff {p : G.Walk u u} : p.map f = nil ↔ p = nil 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u : V} {p : G.Walk u u}
Goal: SimpleGraph.Walk.map f p = SimpleGraph.Walk.nil ↔ p = SimpleGraph.Walk.nil
-- SimpleGraph.Walk.length_map
@[simp]
theorem length_map : (p.map f).length = p.length 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v : V} (p : G.Walk u v)
Goal: (SimpleGraph.Walk.map f p).length = p.length
-- SimpleGraph.Walk.map_append
theorem map_append {u v w : V} (p : G.Walk u v) (q : G.Walk v w) :
    (p.append q).map f = (p.map f).append (q.map f) 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v w : V} (p : G.Walk u v) (q : G.Walk v w)
Goal: SimpleGraph.Walk.map f (p.append q) = (SimpleGraph.Walk.map f p).append (SimpleGraph.Walk.map f q)
-- SimpleGraph.Walk.reverse_map
@[simp]
theorem reverse_map : (p.map f).reverse = p.reverse.map f 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v : V} (p : G.Walk u v)
Goal: (SimpleGraph.Walk.map f p).reverse = SimpleGraph.Walk.map f p.reverse
-- SimpleGraph.Walk.support_map
@[simp]
theorem support_map : (p.map f).support = p.support.map f 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v : V} (p : G.Walk u v)
Goal: (SimpleGraph.Walk.map f p).support = List.map (⇑f) p.support
-- SimpleGraph.Walk.darts_map
@[simp]
theorem darts_map : (p.map f).darts = p.darts.map f.mapDart 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v : V} (p : G.Walk u v)
Goal: (SimpleGraph.Walk.map f p).darts = List.map f.mapDart p.darts
-- SimpleGraph.Walk.edges_map
@[simp]
theorem edges_map : (p.map f).edges = p.edges.map (Sym2.map f) 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (f : G →g G') {u v : V} (p : G.Walk u v)
Goal: (SimpleGraph.Walk.map f p).edges = List.map (Sym2.map ⇑f) p.edges
-- SimpleGraph.Walk.map_injective_of_injective
theorem map_injective_of_injective {f : G →g G'} (hinj : Function.Injective f) (u v : V) :
    Function.Injective (Walk.map f : G.Walk u v → G'.Walk (f u) (f v)) 
Arguments: {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} {f : G →g G'} (hinj : Function.Injective ⇑f) (u v : V)
Goal: Function.Injective (SimpleGraph.Walk.map f)
-- SimpleGraph.Walk.transfer_self
theorem transfer_self : p.transfer G p.edges_subset_edgeSet = p 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v)
Goal: p.transfer G ⋯ = p
-- SimpleGraph.Walk.transfer_eq_map_of_le
theorem transfer_eq_map_of_le (hp) (GH : G ≤ H) :
    p.transfer H hp = p.map (SimpleGraph.Hom.mapSpanningSubgraphs GH) 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {H : SimpleGraph V} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet) (GH : G ≤ H)
Goal: p.transfer H hp = SimpleGraph.Walk.map (SimpleGraph.Hom.mapSpanningSubgraphs GH) p
-- SimpleGraph.Walk.edges_transfer
@[simp]
theorem edges_transfer (hp) : (p.transfer H hp).edges = p.edges 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {H : SimpleGraph V} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet)
Goal: (p.transfer H hp).edges = p.edges
-- SimpleGraph.Walk.support_transfer
@[simp]
theorem support_transfer (hp) : (p.transfer H hp).support = p.support 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {H : SimpleGraph V} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet)
Goal: (p.transfer H hp).support = p.support
-- SimpleGraph.Walk.length_transfer
@[simp]
theorem length_transfer (hp) : (p.transfer H hp).length = p.length 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {H : SimpleGraph V} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet)
Goal: (p.transfer H hp).length = p.length
-- SimpleGraph.Walk.transfer_transfer
@[simp]
theorem transfer_transfer (hp) {K : SimpleGraph V} (hp') :
    (p.transfer H hp).transfer K hp' = p.transfer K (p.edges_transfer hp ▸ hp') 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {H : SimpleGraph V} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet) {K : SimpleGraph V} (hp' : ∀ e ∈ (p.transfer H hp).edges, e ∈ K.edgeSet)
Goal: (p.transfer H hp).transfer K hp' = p.transfer K ⋯
-- SimpleGraph.Walk.transfer_append
@[simp]
theorem transfer_append {w : V} (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by simp [he])).append
        (q.transfer H fun e he => hpq _ (by simp [he])) 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {H : SimpleGraph V} {w : V} (q : G.Walk v w) (hpq : ∀ e ∈ (p.append q).edges, e ∈ H.edgeSet)
Goal: (p.append q).transfer H hpq = (p.transfer H ⋯).append (q.transfer H ⋯)
-- SimpleGraph.Walk.reverse_transfer
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by simp only [edges_reverse, List.mem_reverse]; exact hp) 
Arguments: {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) {H : SimpleGraph V} (hp : ∀ e ∈ p.edges, e ∈ H.edgeSet)
Goal: (p.transfer H hp).reverse = p.reverse.transfer H ⋯
-- SimpleGraph.Walk.toDeleteEdges_nil
@[simp]
theorem toDeleteEdges_nil (s : Set (Sym2 V)) {v : V} (hp) :
    (Walk.nil : G.Walk v v).toDeleteEdges s hp = Walk.nil 
Arguments: {V : Type u} {G : SimpleGraph V} (s : Set (Sym2 V)) {v : V} (hp : ∀ e ∈ SimpleGraph.Walk.nil.edges, e ∉ s)
Goal: SimpleGraph.Walk.toDeleteEdges s SimpleGraph.Walk.nil hp = SimpleGraph.Walk.nil
-- SimpleGraph.Walk.toDeleteEdges_cons
@[simp]
theorem toDeleteEdges_cons (s : Set (Sym2 V)) {u v w : V} (h : G.Adj u v) (p : G.Walk v w) (hp) :
    (Walk.cons h p).toDeleteEdges s hp =
      Walk.cons (deleteEdges_adj.mpr ⟨h, hp _ (List.Mem.head _)⟩)
        (p.toDeleteEdges s fun _ he => hp _ <| List.Mem.tail _ he) 
Arguments: {V : Type u} {G : SimpleGraph V} (s : Set (Sym2 V)) {u v w : V} (h : G.Adj u v) (p : G.Walk v w) (hp : ∀ e ∈ (SimpleGraph.Walk.cons h p).edges, e ∉ s)
Goal: SimpleGraph.Walk.toDeleteEdges s (SimpleGraph.Walk.cons h p) hp =
  SimpleGraph.Walk.cons ⋯ (SimpleGraph.Walk.toDeleteEdges s p ⋯)
-- SimpleGraph.Walk.map_toDeleteEdges_eq
@[simp]
theorem map_toDeleteEdges_eq (s : Set (Sym2 V)) {p : G.Walk v w} (hp) :
    Walk.map (Hom.mapSpanningSubgraphs (G.deleteEdges_le s)) (p.toDeleteEdges s hp) = p 
Arguments: {V : Type u} {G : SimpleGraph V} {v w : V} (s : Set (Sym2 V)) {p : G.Walk v w} (hp : ∀ e ∈ p.edges, e ∉ s)
Goal: SimpleGraph.Walk.map (SimpleGraph.Hom.mapSpanningSubgraphs ⋯) (SimpleGraph.Walk.toDeleteEdges s p hp) = p
-- SimpleGraph.coe_edgeFinset
@[norm_cast]
theorem coe_edgeFinset : (G.edgeFinset : Set (Sym2 V)) = G.edgeSet 
Arguments: {V : Type u_1} (G : SimpleGraph V) [Fintype ↑G.edgeSet]
Goal: ↑G.edgeFinset = G.edgeSet
-- SimpleGraph.mem_edgeFinset
theorem mem_edgeFinset : e ∈ G.edgeFinset ↔ e ∈ G.edgeSet 
Arguments: {V : Type u_1} {G : SimpleGraph V} {e : Sym2 V} [Fintype ↑G.edgeSet]
Goal: e ∈ G.edgeFinset ↔ e ∈ G.edgeSet
-- SimpleGraph.not_isDiag_of_mem_edgeFinset
theorem not_isDiag_of_mem_edgeFinset : e ∈ G.edgeFinset → ¬e.IsDiag 
Arguments: {V : Type u_1} {G : SimpleGraph V} {e : Sym2 V} [Fintype ↑G.edgeSet]
Goal: e ∈ G.edgeFinset → ¬e.IsDiag
-- SimpleGraph.edgeFinset_inj
theorem edgeFinset_inj : G₁.edgeFinset = G₂.edgeFinset ↔ G₁ = G₂ 
Arguments: {V : Type u_1} {G₁ G₂ : SimpleGraph V} [Fintype ↑G₁.edgeSet] [Fintype ↑G₂.edgeSet]
Goal: G₁.edgeFinset = G₂.edgeFinset ↔ G₁ = G₂
-- SimpleGraph.edgeFinset_subset_edgeFinset
theorem edgeFinset_subset_edgeFinset : G₁.edgeFinset ⊆ G₂.edgeFinset ↔ G₁ ≤ G₂ 
Arguments: {V : Type u_1} {G₁ G₂ : SimpleGraph V} [Fintype ↑G₁.edgeSet] [Fintype ↑G₂.edgeSet]
Goal: G₁.edgeFinset ⊆ G₂.edgeFinset ↔ G₁ ≤ G₂
-- SimpleGraph.edgeFinset_ssubset_edgeFinset
theorem edgeFinset_ssubset_edgeFinset : G₁.edgeFinset ⊂ G₂.edgeFinset ↔ G₁ < G₂ 
Arguments: {V : Type u_1} {G₁ G₂ : SimpleGraph V} [Fintype ↑G₁.edgeSet] [Fintype ↑G₂.edgeSet]
Goal: G₁.edgeFinset ⊂ G₂.edgeFinset ↔ G₁ < G₂
-- SimpleGraph.edgeFinset_bot
@[simp]
theorem edgeFinset_bot : (⊥ : SimpleGraph V).edgeFinset = ∅ 
Arguments: {V : Type u_1}
Goal: ⊥.edgeFinset = ∅
-- SimpleGraph.edgeFinset_sup
@[simp]
theorem edgeFinset_sup [Fintype (edgeSet (G₁ ⊔ G₂))] [DecidableEq V] :
    (G₁ ⊔ G₂).edgeFinset = G₁.edgeFinset ∪ G₂.edgeFinset 
Arguments: {V : Type u_1} {G₁ G₂ : SimpleGraph V} [Fintype ↑G₁.edgeSet] [Fintype ↑G₂.edgeSet] [Fintype ↑(G₁ ⊔ G₂).edgeSet] [DecidableEq V]
Goal: (G₁ ⊔ G₂).edgeFinset = G₁.edgeFinset ∪ G₂.edgeFinset
-- SimpleGraph.edgeFinset_inf
@[simp]
theorem edgeFinset_inf [DecidableEq V] : (G₁ ⊓ G₂).edgeFinset = G₁.edgeFinset ∩ G₂.edgeFinset 
Arguments: {V : Type u_1} {G₁ G₂ : SimpleGraph V} [Fintype ↑G₁.edgeSet] [Fintype ↑G₂.edgeSet] [DecidableEq V]
Goal: (G₁ ⊓ G₂).edgeFinset = G₁.edgeFinset ∩ G₂.edgeFinset
-- SimpleGraph.edgeFinset_sdiff
@[simp]
theorem edgeFinset_sdiff [DecidableEq V] :
    (G₁ \ G₂).edgeFinset = G₁.edgeFinset \ G₂.edgeFinset 
Arguments: {V : Type u_1} {G₁ G₂ : SimpleGraph V} [Fintype ↑G₁.edgeSet] [Fintype ↑G₂.edgeSet] [DecidableEq V]
Goal: (G₁ \ G₂).edgeFinset = G₁.edgeFinset \ G₂.edgeFinset
-- SimpleGraph.edgeFinset_card
theorem edgeFinset_card : G.edgeFinset.card = Fintype.card G.edgeSet 
Arguments: {V : Type u_1} {G : SimpleGraph V} [Fintype ↑G.edgeSet]
Goal: G.edgeFinset.card = Fintype.card ↑G.edgeSet
-- SimpleGraph.edgeSet_univ_card
@[simp]
theorem edgeSet_univ_card : (univ : Finset G.edgeSet).card = G.edgeFinset.card 
Arguments: {V : Type u_1} {G : SimpleGraph V} [Fintype ↑G.edgeSet]
Goal: Finset.univ.card = G.edgeFinset.card
-- SimpleGraph.edgeFinset_top
@[simp]
theorem edgeFinset_top [DecidableEq V] :
    (⊤ : SimpleGraph V).edgeFinset = univ.filter fun e => ¬e.IsDiag 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V]
Goal: ⊤.edgeFinset = Finset.filter (fun e => ¬e.IsDiag) Finset.univ
-- SimpleGraph.card_edgeFinset_top_eq_card_choose_two
theorem card_edgeFinset_top_eq_card_choose_two [DecidableEq V] :
    (⊤ : SimpleGraph V).edgeFinset.card = (Fintype.card V).choose 2 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V]
Goal: ⊤.edgeFinset.card = (Fintype.card V).choose 2
-- SimpleGraph.card_edgeFinset_le_card_choose_two
theorem card_edgeFinset_le_card_choose_two : G.edgeFinset.card ≤ (Fintype.card V).choose 2 
Arguments: {V : Type u_1} {G : SimpleGraph V} [Fintype ↑G.edgeSet] [Fintype V]
Goal: G.edgeFinset.card ≤ (Fintype.card V).choose 2
-- SimpleGraph.edgeFinset_deleteEdges
theorem edgeFinset_deleteEdges [DecidableEq V] [Fintype G.edgeSet] (s : Finset (Sym2 V))
    [Fintype (G.deleteEdges s).edgeSet] :
    (G.deleteEdges s).edgeFinset = G.edgeFinset \ s 
Arguments: {V : Type u_1} (G : SimpleGraph V) [DecidableEq V] [Fintype ↑G.edgeSet] (s : Finset (Sym2 V)) [Fintype ↑(G.deleteEdges ↑s).edgeSet]
Goal: (G.deleteEdges ↑s).edgeFinset = G.edgeFinset \ s
-- SimpleGraph.deleteFar_iff
theorem deleteFar_iff :
    G.DeleteFar p r ↔ ∀ ⦃H : SimpleGraph _⦄ [DecidableRel H.Adj],
      H ≤ G → p H → r ≤ G.edgeFinset.card - H.edgeFinset.card 
Arguments: {V : Type u_1} {G : SimpleGraph V} {𝕜 : Type u_2} [OrderedRing 𝕜] [Fintype (Sym2 V)] [Fintype ↑G.edgeSet] {p : SimpleGraph V → Prop} {r : 𝕜}
Goal: G.DeleteFar p r ↔
  ∀ ⦃H : SimpleGraph V⦄ [inst : DecidableRel H.Adj], H ≤ G → p H → r ≤ ↑G.edgeFinset.card - ↑H.edgeFinset.card
-- SimpleGraph.DeleteFar.mono
theorem DeleteFar.mono (h : G.DeleteFar p r₂) (hr : r₁ ≤ r₂) : G.DeleteFar p r₁ 
Arguments: {V : Type u_1} {G : SimpleGraph V} {𝕜 : Type u_2} [OrderedRing 𝕜] [Fintype ↑G.edgeSet] {p : SimpleGraph V → Prop} {r₁ r₂ : 𝕜} (h : G.DeleteFar p r₂) (hr : r₁ ≤ r₂)
Goal: G.DeleteFar p r₁
-- SimpleGraph.neighborFinset_def
theorem neighborFinset_def : G.neighborFinset v = (G.neighborSet v).toFinset 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)]
Goal: G.neighborFinset v = (G.neighborSet v).toFinset
-- SimpleGraph.mem_neighborFinset
@[simp]
theorem mem_neighborFinset (w : V) : w ∈ G.neighborFinset v ↔ G.Adj v w 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)] (w : V)
Goal: w ∈ G.neighborFinset v ↔ G.Adj v w
-- SimpleGraph.not_mem_neighborFinset_self
theorem not_mem_neighborFinset_self : v ∉ G.neighborFinset v 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)]
Goal: v ∉ G.neighborFinset v
-- SimpleGraph.neighborFinset_disjoint_singleton
theorem neighborFinset_disjoint_singleton : Disjoint (G.neighborFinset v) {v} 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)]
Goal: Disjoint (G.neighborFinset v) {v}
-- SimpleGraph.singleton_disjoint_neighborFinset
theorem singleton_disjoint_neighborFinset : Disjoint {v} (G.neighborFinset v) 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)]
Goal: Disjoint {v} (G.neighborFinset v)
-- SimpleGraph.card_neighborFinset_eq_degree
@[simp]
theorem card_neighborFinset_eq_degree : (G.neighborFinset v).card = G.degree v 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)]
Goal: (G.neighborFinset v).card = G.degree v
-- SimpleGraph.card_neighborSet_eq_degree
@[simp]
theorem card_neighborSet_eq_degree : Fintype.card (G.neighborSet v) = G.degree v 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)]
Goal: Fintype.card ↑(G.neighborSet v) = G.degree v
-- SimpleGraph.degree_pos_iff_exists_adj
theorem degree_pos_iff_exists_adj : 0 < G.degree v ↔ ∃ w, G.Adj v w 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)]
Goal: 0 < G.degree v ↔ ∃ w, G.Adj v w
-- SimpleGraph.degree_compl
theorem degree_compl [Fintype (Gᶜ.neighborSet v)] [Fintype V] :
    Gᶜ.degree v = Fintype.card V - 1 - G.degree v 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)] [Fintype ↑(Gᶜ.neighborSet v)] [Fintype V]
Goal: Gᶜ.degree v = Fintype.card V - 1 - G.degree v
-- SimpleGraph.card_incidenceSet_eq_degree
@[simp]
theorem card_incidenceSet_eq_degree [DecidableEq V] :
    Fintype.card (G.incidenceSet v) = G.degree v 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)] [DecidableEq V]
Goal: Fintype.card ↑(G.incidenceSet v) = G.degree v
-- SimpleGraph.card_incidenceFinset_eq_degree
@[simp]
theorem card_incidenceFinset_eq_degree [DecidableEq V] :
    (G.incidenceFinset v).card = G.degree v 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)] [DecidableEq V]
Goal: (G.incidenceFinset v).card = G.degree v
-- SimpleGraph.mem_incidenceFinset
@[simp]
theorem mem_incidenceFinset [DecidableEq V] (e : Sym2 V) :
    e ∈ G.incidenceFinset v ↔ e ∈ G.incidenceSet v 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)] [DecidableEq V] (e : Sym2 V)
Goal: e ∈ G.incidenceFinset v ↔ e ∈ G.incidenceSet v
-- SimpleGraph.incidenceFinset_eq_filter
theorem incidenceFinset_eq_filter [DecidableEq V] [Fintype G.edgeSet] :
    G.incidenceFinset v = G.edgeFinset.filter (Membership.mem v) 
Arguments: {V : Type u_1} (G : SimpleGraph V) (v : V) [Fintype ↑(G.neighborSet v)] [DecidableEq V] [Fintype ↑G.edgeSet]
Goal: G.incidenceFinset v = Finset.filter (Membership.mem v) G.edgeFinset