l3lab/ntp-mathlib huggingface dataset:
theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  simp only [SimpleGraph.deleteEdges_adj, coe_adj, deleteEdges_adj, Set.mem_image, not_exists,
    not_and, and_congr_right_iff]
  intro
  constructor
  · intro hs
    refine' Sym2.ind _
    rintro ⟨v', hv'⟩ ⟨w', hw'⟩
    

Proof state:
case Adj.h.mk.h.mk.a.mp.mk.mk
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ : Set (Sym2 V)
s : Set (Sym2 ↑G'.verts)
v : V
hv : v ∈ G'.verts
w : V
hw : w ∈ G'.verts
a✝ : Adj G' v w
hs : ⟦({ val := v, property := hv }, { val := w, property := hw })⟧ ∉ s
v' : V
hv' : v' ∈ G'.verts
w' : V
hw' : w' ∈ G'.verts
⊢ ⟦({ val := v', property := hv' }, { val := w', property := hw' })⟧ ∈ s →
    ¬Sym2.map Subtype.val ⟦({ val := v', property := hv' }, { val := w', property := hw' })⟧ = ⟦(v, w)⟧

Next tactic:
simp only [Sym2.map_pair_eq, Quotient.eq]
theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  simp only [SimpleGraph.deleteEdges_adj, coe_adj, deleteEdges_adj, Set.mem_image, not_exists,
    not_and, and_congr_right_iff]
  intro
  constructor
  · intro hs
    refine' Sym2.ind _
    rintro ⟨v', hv'⟩ ⟨w', hw'⟩
    simp only [Sym2.map_pair_eq, Quotient.eq]
    

Proof state:
case Adj.h.mk.h.mk.a.mp.mk.mk
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ : Set (Sym2 V)
s : Set (Sym2 ↑G'.verts)
v : V
hv : v ∈ G'.verts
w : V
hw : w ∈ G'.verts
a✝ : Adj G' v w
hs : ⟦({ val := v, property := hv }, { val := w, property := hw })⟧ ∉ s
v' : V
hv' : v' ∈ G'.verts
w' : V
hw' : w' ∈ G'.verts
⊢ ⟦({ val := v', property := hv' }, { val := w', property := hw' })⟧ ∈ s → ¬(v', w') ≈ (v, w)

Next tactic:
contrapose!
theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  simp only [SimpleGraph.deleteEdges_adj, coe_adj, deleteEdges_adj, Set.mem_image, not_exists,
    not_and, and_congr_right_iff]
  intro
  constructor
  · intro hs
    refine' Sym2.ind _
    rintro ⟨v', hv'⟩ ⟨w', hw'⟩
    simp only [Sym2.map_pair_eq, Quotient.eq]
    contrapose!
    

Proof state:
case Adj.h.mk.h.mk.a.mp.mk.mk
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ : Set (Sym2 V)
s : Set (Sym2 ↑G'.verts)
v : V
hv : v ∈ G'.verts
w : V
hw : w ∈ G'.verts
a✝ : Adj G' v w
hs : ⟦({ val := v, property := hv }, { val := w, property := hw })⟧ ∉ s
v' : V
hv' : v' ∈ G'.verts
w' : V
hw' : w' ∈ G'.verts
⊢ (v', w') ≈ (v, w) → ⟦({ val := v', property := hv' }, { val := w', property := hw' })⟧ ∉ s

Next tactic:
rintro (_ | _)
theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  simp only [SimpleGraph.deleteEdges_adj, coe_adj, deleteEdges_adj, Set.mem_image, not_exists,
    not_and, and_congr_right_iff]
  intro
  constructor
  · intro hs
    refine' Sym2.ind _
    rintro ⟨v', hv'⟩ ⟨w', hw'⟩
    simp only [Sym2.map_pair_eq, Quotient.eq]
    contrapose!
    rintro (_ | _) <;> 

Proof state:
case Adj.h.mk.h.mk.a.mp.mk.mk.refl
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ : Set (Sym2 V)
s : Set (Sym2 ↑G'.verts)
v : V
hv : v ∈ G'.verts
w : V
hw : w ∈ G'.verts
a✝ : Adj G' v w
hs : ⟦({ val := v, property := hv }, { val := w, property := hw })⟧ ∉ s
hv' : v ∈ G'.verts
hw' : w ∈ G'.verts
⊢ ⟦({ val := v, property := hv' }, { val := w, property := hw' })⟧ ∉ s

Next tactic:
simpa only [Sym2.eq_swap]
theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  simp only [SimpleGraph.deleteEdges_adj, coe_adj, deleteEdges_adj, Set.mem_image, not_exists,
    not_and, and_congr_right_iff]
  intro
  constructor
  · intro hs
    refine' Sym2.ind _
    rintro ⟨v', hv'⟩ ⟨w', hw'⟩
    simp only [Sym2.map_pair_eq, Quotient.eq]
    contrapose!
    rintro (_ | _) <;> 

Proof state:
case Adj.h.mk.h.mk.a.mp.mk.mk.swap
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ : Set (Sym2 V)
s : Set (Sym2 ↑G'.verts)
v : V
hv : v ∈ G'.verts
w : V
hw : w ∈ G'.verts
a✝ : Adj G' v w
hs : ⟦({ val := v, property := hv }, { val := w, property := hw })⟧ ∉ s
hw' : v ∈ G'.verts
hv' : w ∈ G'.verts
⊢ ⟦({ val := w, property := hv' }, { val := v, property := hw' })⟧ ∉ s

Next tactic:
simpa only [Sym2.eq_swap]
theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  simp only [SimpleGraph.deleteEdges_adj, coe_adj, deleteEdges_adj, Set.mem_image, not_exists,
    not_and, and_congr_right_iff]
  intro
  constructor
  · intro hs
    refine' Sym2.ind _
    rintro ⟨v', hv'⟩ ⟨w', hw'⟩
    simp only [Sym2.map_pair_eq, Quotient.eq]
    contrapose!
    rintro (_ | _) <;> simpa only [Sym2.eq_swap]
  · 

Proof state:
case Adj.h.mk.h.mk.a.mpr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ : Set (Sym2 V)
s : Set (Sym2 ↑G'.verts)
v : V
hv : v ∈ G'.verts
w : V
hw : w ∈ G'.verts
a✝ : Adj G' v w
⊢ (∀ x ∈ s, ¬Sym2.map Subtype.val x = ⟦(v, w)⟧) → ⟦({ val := v, property := hv }, { val := w, property := hw })⟧ ∉ s

Next tactic:
intro h' hs
theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  simp only [SimpleGraph.deleteEdges_adj, coe_adj, deleteEdges_adj, Set.mem_image, not_exists,
    not_and, and_congr_right_iff]
  intro
  constructor
  · intro hs
    refine' Sym2.ind _
    rintro ⟨v', hv'⟩ ⟨w', hw'⟩
    simp only [Sym2.map_pair_eq, Quotient.eq]
    contrapose!
    rintro (_ | _) <;> simpa only [Sym2.eq_swap]
  · intro h' hs
    

Proof state:
case Adj.h.mk.h.mk.a.mpr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ : Set (Sym2 V)
s : Set (Sym2 ↑G'.verts)
v : V
hv : v ∈ G'.verts
w : V
hw : w ∈ G'.verts
a✝ : Adj G' v w
h' : ∀ x ∈ s, ¬Sym2.map Subtype.val x = ⟦(v, w)⟧
hs : ⟦({ val := v, property := hv }, { val := w, property := hw })⟧ ∈ s
⊢ False

Next tactic:
exact h' _ hs rfl
theorem coe_deleteEdges_eq (s : Set (Sym2 V)) :
    (G'.deleteEdges s).coe = G'.coe.deleteEdges (Sym2.map (↑) ⁻¹' s) := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s : Set (Sym2 V)
⊢ Subgraph.coe (deleteEdges G' s) = SimpleGraph.deleteEdges (Subgraph.coe G') (Sym2.map Subtype.val ⁻¹' s)

Next tactic:
ext ⟨v, hv⟩ ⟨w, hw⟩
theorem coe_deleteEdges_eq (s : Set (Sym2 V)) :
    (G'.deleteEdges s).coe = G'.coe.deleteEdges (Sym2.map (↑) ⁻¹' s) := by
  ext ⟨v, hv⟩ ⟨w, hw⟩
  

Proof state:
case Adj.h.mk.h.mk.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s : Set (Sym2 V)
v : V
hv : v ∈ (deleteEdges G' s).verts
w : V
hw : w ∈ (deleteEdges G' s).verts
⊢ SimpleGraph.Adj (Subgraph.coe (deleteEdges G' s)) { val := v, property := hv } { val := w, property := hw } ↔
    SimpleGraph.Adj (SimpleGraph.deleteEdges (Subgraph.coe G') (Sym2.map Subtype.val ⁻¹' s))
      { val := v, property := hv } { val := w, property := hw }

Next tactic:
simp
theorem deleteEdges_le : G'.deleteEdges s ≤ G' := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ deleteEdges G' s ≤ G'

Next tactic:
constructor
theorem deleteEdges_le : G'.deleteEdges s ≤ G' := by
  constructor <;> 

Proof state:
case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ (deleteEdges G' s).verts ⊆ G'.verts

Next tactic:
simp (config := { contextual := true }) [subset_rfl]
theorem deleteEdges_le : G'.deleteEdges s ≤ G' := by
  constructor <;> 

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ ∀ ⦃v w : V⦄, Adj (deleteEdges G' s) v w → Adj G' v w

Next tactic:
simp (config := { contextual := true }) [subset_rfl]
theorem deleteEdges_le_of_le {s s' : Set (Sym2 V)} (h : s ⊆ s') :
    G'.deleteEdges s' ≤ G'.deleteEdges s := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s s' : Set (Sym2 V)
h : s ⊆ s'
⊢ deleteEdges G' s' ≤ deleteEdges G' s

Next tactic:
constructor
theorem deleteEdges_le_of_le {s s' : Set (Sym2 V)} (h : s ⊆ s') :
    G'.deleteEdges s' ≤ G'.deleteEdges s := by
  constructor <;> 

Proof state:
case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s s' : Set (Sym2 V)
h : s ⊆ s'
⊢ (deleteEdges G' s').verts ⊆ (deleteEdges G' s).verts

Next tactic:
simp (config := { contextual := true }) only [deleteEdges_verts, deleteEdges_adj,
    true_and_iff, and_imp, subset_rfl]
theorem deleteEdges_le_of_le {s s' : Set (Sym2 V)} (h : s ⊆ s') :
    G'.deleteEdges s' ≤ G'.deleteEdges s := by
  constructor <;> 

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s s' : Set (Sym2 V)
h : s ⊆ s'
⊢ ∀ ⦃v w : V⦄, Adj (deleteEdges G' s') v w → Adj (deleteEdges G' s) v w

Next tactic:
simp (config := { contextual := true }) only [deleteEdges_verts, deleteEdges_adj,
    true_and_iff, and_imp, subset_rfl]
theorem deleteEdges_le_of_le {s s' : Set (Sym2 V)} (h : s ⊆ s') :
    G'.deleteEdges s' ≤ G'.deleteEdges s := by
  constructor <;> simp (config := { contextual := true }) only [deleteEdges_verts, deleteEdges_adj,
    true_and_iff, and_imp, subset_rfl]
  

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s s' : Set (Sym2 V)
h : s ⊆ s'
⊢ ∀ ⦃v w : V⦄, Adj G' v w → ⟦(v, w)⟧ ∉ s' → ⟦(v, w)⟧ ∉ s

Next tactic:
exact fun _ _ _ hs' hs ↦ hs' (h hs)
@[simp]
theorem deleteEdges_inter_edgeSet_left_eq :
    G'.deleteEdges (G'.edgeSet ∩ s) = G'.deleteEdges s := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ deleteEdges G' (edgeSet G' ∩ s) = deleteEdges G' s

Next tactic:
ext
@[simp]
theorem deleteEdges_inter_edgeSet_left_eq :
    G'.deleteEdges (G'.edgeSet ∩ s) = G'.deleteEdges s := by
  ext <;> 

Proof state:
case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
x✝ : V
⊢ x✝ ∈ (deleteEdges G' (edgeSet G' ∩ s)).verts ↔ x✝ ∈ (deleteEdges G' s).verts

Next tactic:
simp (config := { contextual := true }) [imp_false]
@[simp]
theorem deleteEdges_inter_edgeSet_left_eq :
    G'.deleteEdges (G'.edgeSet ∩ s) = G'.deleteEdges s := by
  ext <;> 

Proof state:
case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
x✝¹ x✝ : V
⊢ Adj (deleteEdges G' (edgeSet G' ∩ s)) x✝¹ x✝ ↔ Adj (deleteEdges G' s) x✝¹ x✝

Next tactic:
simp (config := { contextual := true }) [imp_false]
@[simp]
theorem deleteEdges_inter_edgeSet_right_eq :
    G'.deleteEdges (s ∩ G'.edgeSet) = G'.deleteEdges s := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ deleteEdges G' (s ∩ edgeSet G') = deleteEdges G' s

Next tactic:
ext
@[simp]
theorem deleteEdges_inter_edgeSet_right_eq :
    G'.deleteEdges (s ∩ G'.edgeSet) = G'.deleteEdges s := by
  ext <;> 

Proof state:
case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
x✝ : V
⊢ x✝ ∈ (deleteEdges G' (s ∩ edgeSet G')).verts ↔ x✝ ∈ (deleteEdges G' s).verts

Next tactic:
simp (config := { contextual := true }) [imp_false]
@[simp]
theorem deleteEdges_inter_edgeSet_right_eq :
    G'.deleteEdges (s ∩ G'.edgeSet) = G'.deleteEdges s := by
  ext <;> 

Proof state:
case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
x✝¹ x✝ : V
⊢ Adj (deleteEdges G' (s ∩ edgeSet G')) x✝¹ x✝ ↔ Adj (deleteEdges G' s) x✝¹ x✝

Next tactic:
simp (config := { contextual := true }) [imp_false]
theorem coe_deleteEdges_le : (G'.deleteEdges s).coe ≤ (G'.coe : SimpleGraph G'.verts) := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ Subgraph.coe (deleteEdges G' s) ≤ Subgraph.coe G'

Next tactic:
intro v w
theorem coe_deleteEdges_le : (G'.deleteEdges s).coe ≤ (G'.coe : SimpleGraph G'.verts) := by
  intro v w
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
v w : ↑(deleteEdges G' s).verts
⊢ SimpleGraph.Adj (Subgraph.coe (deleteEdges G' s)) v w → SimpleGraph.Adj (Subgraph.coe G') v w

Next tactic:
simp (config := { contextual := true })
theorem _root_.SimpleGraph.induce_eq_coe_induce_top (s : Set V) :
    G.induce s = ((⊤ : G.Subgraph).induce s).coe := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
s : Set V
⊢ SimpleGraph.induce s G = Subgraph.coe (induce ⊤ s)

Next tactic:
ext
theorem _root_.SimpleGraph.induce_eq_coe_induce_top (s : Set V) :
    G.induce s = ((⊤ : G.Subgraph).induce s).coe := by
  ext
  

Proof state:
case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
s : Set V
x✝¹ x✝ : ↑s
⊢ SimpleGraph.Adj (SimpleGraph.induce s G) x✝¹ x✝ ↔ SimpleGraph.Adj (Subgraph.coe (induce ⊤ s)) x✝¹ x✝

Next tactic:
simp
theorem induce_mono (hg : G' ≤ G'') (hs : s ⊆ s') : G'.induce s ≤ G''.induce s' := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ induce G' s ≤ induce G'' s'

Next tactic:
constructor
theorem induce_mono (hg : G' ≤ G'') (hs : s ⊆ s') : G'.induce s ≤ G''.induce s' := by
  constructor
  · 

Proof state:
case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ (induce G' s).verts ⊆ (induce G'' s').verts

Next tactic:
simp [hs]
theorem induce_mono (hg : G' ≤ G'') (hs : s ⊆ s') : G'.induce s ≤ G''.induce s' := by
  constructor
  · simp [hs]
  · 

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ ∀ ⦃v w : V⦄, Adj (induce G' s) v w → Adj (induce G'' s') v w

Next tactic:
simp (config := { contextual := true }) only [induce_adj, true_and_iff, and_imp]
theorem induce_mono (hg : G' ≤ G'') (hs : s ⊆ s') : G'.induce s ≤ G''.induce s' := by
  constructor
  · simp [hs]
  · simp (config := { contextual := true }) only [induce_adj, true_and_iff, and_imp]
    

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ ∀ ⦃v w : V⦄, v ∈ s → w ∈ s → Adj G' v w → v ∈ s' ∧ w ∈ s' ∧ Adj G'' v w

Next tactic:
intro v w hv hw ha
theorem induce_mono (hg : G' ≤ G'') (hs : s ⊆ s') : G'.induce s ≤ G''.induce s' := by
  constructor
  · simp [hs]
  · simp (config := { contextual := true }) only [induce_adj, true_and_iff, and_imp]
    intro v w hv hw ha
    

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
v w : V
hv : v ∈ s
hw : w ∈ s
ha : Adj G' v w
⊢ v ∈ s' ∧ w ∈ s' ∧ Adj G'' v w

Next tactic:
exact ⟨hs hv, hs hw, hg.2 ha⟩
@[simp]
theorem induce_empty : G'.induce ∅ = ⊥ := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ induce G' ∅ = ⊥

Next tactic:
ext
@[simp]
theorem induce_empty : G'.induce ∅ = ⊥ := by
  ext <;> 

Proof state:
case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝ : V
⊢ x✝ ∈ (induce G' ∅).verts ↔ x✝ ∈ ⊥.verts

Next tactic:
simp
@[simp]
theorem induce_empty : G'.induce ∅ = ⊥ := by
  ext <;> 

Proof state:
case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝¹ x✝ : V
⊢ Adj (induce G' ∅) x✝¹ x✝ ↔ Adj ⊥ x✝¹ x✝

Next tactic:
simp
@[simp]
theorem induce_self_verts : G'.induce G'.verts = G' := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ induce G' G'.verts = G'

Next tactic:
ext
@[simp]
theorem induce_self_verts : G'.induce G'.verts = G' := by
  ext
  · 

Proof state:
case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝ : V
⊢ x✝ ∈ (induce G' G'.verts).verts ↔ x✝ ∈ G'.verts

Next tactic:
simp
@[simp]
theorem induce_self_verts : G'.induce G'.verts = G' := by
  ext
  · simp
  · 

Proof state:
case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝¹ x✝ : V
⊢ Adj (induce G' G'.verts) x✝¹ x✝ ↔ Adj G' x✝¹ x✝

Next tactic:
constructor
@[simp]
theorem induce_self_verts : G'.induce G'.verts = G' := by
  ext
  · simp
  · constructor <;>
      

Proof state:
case Adj.h.h.a.mp
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝¹ x✝ : V
⊢ Adj (induce G' G'.verts) x✝¹ x✝ → Adj G' x✝¹ x✝

Next tactic:
simp (config := { contextual := true }) only [induce_adj, imp_true_iff, and_true_iff]
@[simp]
theorem induce_self_verts : G'.induce G'.verts = G' := by
  ext
  · simp
  · constructor <;>
      

Proof state:
case Adj.h.h.a.mpr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝¹ x✝ : V
⊢ Adj G' x✝¹ x✝ → Adj (induce G' G'.verts) x✝¹ x✝

Next tactic:
simp (config := { contextual := true }) only [induce_adj, imp_true_iff, and_true_iff]
@[simp]
theorem induce_self_verts : G'.induce G'.verts = G' := by
  ext
  · simp
  · constructor <;>
      simp (config := { contextual := true }) only [induce_adj, imp_true_iff, and_true_iff]
    

Proof state:
case Adj.h.h.a.mpr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝¹ x✝ : V
⊢ Adj G' x✝¹ x✝ → x✝¹ ∈ G'.verts ∧ x✝ ∈ G'.verts

Next tactic:
exact fun ha ↦ ⟨G'.edge_vert ha, G'.edge_vert ha.symm⟩
lemma le_induce_union : G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s') := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ induce G' s ⊔ induce G' s' ≤ induce G' (s ∪ s')

Next tactic:
constructor
lemma le_induce_union : G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s') := by
  constructor
  · 

Proof state:
case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ (induce G' s ⊔ induce G' s').verts ⊆ (induce G' (s ∪ s')).verts

Next tactic:
simp only [verts_sup, induce_verts, Set.Subset.rfl]
lemma le_induce_union : G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s') := by
  constructor
  · simp only [verts_sup, induce_verts, Set.Subset.rfl]
  · 

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ ∀ ⦃v w : V⦄, Adj (induce G' s ⊔ induce G' s') v w → Adj (induce G' (s ∪ s')) v w

Next tactic:
simp only [sup_adj, induce_adj, Set.mem_union]
lemma le_induce_union : G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s') := by
  constructor
  · simp only [verts_sup, induce_verts, Set.Subset.rfl]
  · simp only [sup_adj, induce_adj, Set.mem_union]
    

Proof state:
case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ ∀ ⦃v w : V⦄,
    v ∈ s ∧ w ∈ s ∧ Adj G' v w ∨ v ∈ s' ∧ w ∈ s' ∧ Adj G' v w → (v ∈ s ∨ v ∈ s') ∧ (w ∈ s ∨ w ∈ s') ∧ Adj G' v w

Next tactic:
rintro v w (h | h)
lemma le_induce_union : G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s') := by
  constructor
  · simp only [verts_sup, induce_verts, Set.Subset.rfl]
  · simp only [sup_adj, induce_adj, Set.mem_union]
    rintro v w (h | h) <;> 

Proof state:
case right.inl
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
h : v ∈ s ∧ w ∈ s ∧ Adj G' v w
⊢ (v ∈ s ∨ v ∈ s') ∧ (w ∈ s ∨ w ∈ s') ∧ Adj G' v w

Next tactic:
simp [h]
lemma le_induce_union : G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s') := by
  constructor
  · simp only [verts_sup, induce_verts, Set.Subset.rfl]
  · simp only [sup_adj, induce_adj, Set.mem_union]
    rintro v w (h | h) <;> 

Proof state:
case right.inr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
h : v ∈ s' ∧ w ∈ s' ∧ Adj G' v w
⊢ (v ∈ s ∨ v ∈ s') ∧ (w ∈ s ∨ w ∈ s') ∧ Adj G' v w

Next tactic:
simp [h]
lemma le_induce_union_left : G'.induce s ≤ G'.induce (s ∪ s') := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ induce G' s ≤ induce G' (s ∪ s')

Next tactic:
exact (sup_le_iff.mp le_induce_union).1
lemma le_induce_union_right : G'.induce s' ≤ G'.induce (s ∪ s') := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ induce G' s' ≤ induce G' (s ∪ s')

Next tactic:
exact (sup_le_iff.mp le_induce_union).2
theorem singletonSubgraph_eq_induce {v : V} : G.singletonSubgraph v = (⊤ : G.Subgraph).induce {v} :=
  by 

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v : V
⊢ SimpleGraph.singletonSubgraph G v = induce ⊤ {v}

Next tactic:
ext
theorem singletonSubgraph_eq_induce {v : V} : G.singletonSubgraph v = (⊤ : G.Subgraph).induce {v} :=
  by ext <;> 

Proof state:
case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v x✝ : V
⊢ x✝ ∈ (SimpleGraph.singletonSubgraph G v).verts ↔ x✝ ∈ (induce ⊤ {v}).verts

Next tactic:
simp (config := { contextual := true }) [-Set.bot_eq_empty, Prop.bot_eq_false]
theorem singletonSubgraph_eq_induce {v : V} : G.singletonSubgraph v = (⊤ : G.Subgraph).induce {v} :=
  by ext <;> 

Proof state:
case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v x✝¹ x✝ : V
⊢ Adj (SimpleGraph.singletonSubgraph G v) x✝¹ x✝ ↔ Adj (induce ⊤ {v}) x✝¹ x✝

Next tactic:
simp (config := { contextual := true }) [-Set.bot_eq_empty, Prop.bot_eq_false]
theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w} := by
  

Proof state:
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
⊢ subgraphOfAdj G hvw = induce ⊤ {v, w}

Next tactic:
ext
theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w} := by
  ext
  · 

Proof state:
case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝ : V
⊢ x✝ ∈ (subgraphOfAdj G hvw).verts ↔ x✝ ∈ (induce ⊤ {v, w}).verts

Next tactic:
simp
theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w} := by
  ext
  · simp
  · 

Proof state:
case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
⊢ Adj (subgraphOfAdj G hvw) x✝¹ x✝ ↔ Adj (induce ⊤ {v, w}) x✝¹ x✝

Next tactic:
constructor
theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w} := by
  ext
  · simp
  · constructor
    · 

Proof state:
case Adj.h.h.a.mp
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
⊢ Adj (subgraphOfAdj G hvw) x✝¹ x✝ → Adj (induce ⊤ {v, w}) x✝¹ x✝

Next tactic:
intro h
theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w} := by
  ext
  · simp
  · constructor
    · intro h
      

Proof state:
case Adj.h.h.a.mp
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
h : Adj (subgraphOfAdj G hvw) x✝¹ x✝
⊢ Adj (induce ⊤ {v, w}) x✝¹ x✝

Next tactic:
simp only [subgraphOfAdj_adj, Quotient.eq, Sym2.rel_iff] at h
theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w} := by
  ext
  · simp
  · constructor
    · intro h
      simp only [subgraphOfAdj_adj, Quotient.eq, Sym2.rel_iff] at h
      

Proof state:
case Adj.h.h.a.mp
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
h : v = x✝¹ ∧ w = x✝ ∨ v = x✝ ∧ w = x✝¹
⊢ Adj (induce ⊤ {v, w}) x✝¹ x✝

Next tactic:
obtain ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ := h