File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

full_name: SimpleGraph.Subgraph.edge_vert
code: /-- A subgraph of a `SimpleGraph` is a subset of vertices along with a restriction of the adjacency
relation that is symmetric and is supported by the vertex subset.  They also form a bounded lattice.

Thinking of `V → V → Prop` as `Set (V × V)`, a set of darts (i.e., half-edges), then
`Subgraph.adj_sub` is that the darts of a subgraph are a subset of the darts of `G`. -/
@[ext]
structure Subgraph {V : Type u} (G : SimpleGraph V) where
  verts : Set V
  Adj : V → V → Prop
  adj_sub : ∀ {v w : V}, Adj v w → G.Adj v w
  edge_vert : ∀ {v w : V}, Adj v w → v ∈ verts
  symm : Symmetric Adj := by aesop_graph
goal: self.Adj v w → v ∈ self.verts

full_name: SimpleGraph.Subgraph.verts
code: /-- A subgraph of a `SimpleGraph` is a subset of vertices along with a restriction of the adjacency
relation that is symmetric and is supported by the vertex subset.  They also form a bounded lattice.

Thinking of `V → V → Prop` as `Set (V × V)`, a set of darts (i.e., half-edges), then
`Subgraph.adj_sub` is that the darts of a subgraph are a subset of the darts of `G`. -/
@[ext]
structure Subgraph {V : Type u} (G : SimpleGraph V) where
  verts : Set V
  Adj : V → V → Prop
  adj_sub : ∀ {v w : V}, Adj v w → G.Adj v w
  edge_vert : ∀ {v w : V}, Adj v w → v ∈ verts
  symm : Symmetric Adj := by aesop_graph
goal: Set V

full_name: SimpleGraph.Subgraph.symm
code: /-- A subgraph of a `SimpleGraph` is a subset of vertices along with a restriction of the adjacency
relation that is symmetric and is supported by the vertex subset.  They also form a bounded lattice.

Thinking of `V → V → Prop` as `Set (V × V)`, a set of darts (i.e., half-edges), then
`Subgraph.adj_sub` is that the darts of a subgraph are a subset of the darts of `G`. -/
@[ext]
structure Subgraph {V : Type u} (G : SimpleGraph V) where
  verts : Set V
  Adj : V → V → Prop
  adj_sub : ∀ {v w : V}, Adj v w → G.Adj v w
  edge_vert : ∀ {v w : V}, Adj v w → v ∈ verts
  symm : Symmetric Adj := by aesop_graph
goal: Symmetric self.Adj

full_name: SimpleGraph.Subgraph
code: /-- A subgraph of a `SimpleGraph` is a subset of vertices along with a restriction of the adjacency
relation that is symmetric and is supported by the vertex subset.  They also form a bounded lattice.

Thinking of `V → V → Prop` as `Set (V × V)`, a set of darts (i.e., half-edges), then
`Subgraph.adj_sub` is that the darts of a subgraph are a subset of the darts of `G`. -/
@[ext]
structure Subgraph {V : Type u} (G : SimpleGraph V) where
  verts : Set V
  Adj : V → V → Prop
  adj_sub : ∀ {v w : V}, Adj v w → G.Adj v w
  edge_vert : ∀ {v w : V}, Adj v w → v ∈ verts
  symm : Symmetric Adj := by aesop_graph
goal: Type u

full_name: SimpleGraph.Subgraph.Adj
code: /-- A subgraph of a `SimpleGraph` is a subset of vertices along with a restriction of the adjacency
relation that is symmetric and is supported by the vertex subset.  They also form a bounded lattice.

Thinking of `V → V → Prop` as `Set (V × V)`, a set of darts (i.e., half-edges), then
`Subgraph.adj_sub` is that the darts of a subgraph are a subset of the darts of `G`. -/
@[ext]
structure Subgraph {V : Type u} (G : SimpleGraph V) where
  verts : Set V
  Adj : V → V → Prop
  adj_sub : ∀ {v w : V}, Adj v w → G.Adj v w
  edge_vert : ∀ {v w : V}, Adj v w → v ∈ verts
  symm : Symmetric Adj := by aesop_graph
goal: V → V → Prop

full_name: SimpleGraph.Subgraph.adj_sub
code: /-- A subgraph of a `SimpleGraph` is a subset of vertices along with a restriction of the adjacency
relation that is symmetric and is supported by the vertex subset.  They also form a bounded lattice.

Thinking of `V → V → Prop` as `Set (V × V)`, a set of darts (i.e., half-edges), then
`Subgraph.adj_sub` is that the darts of a subgraph are a subset of the darts of `G`. -/
@[ext]
structure Subgraph {V : Type u} (G : SimpleGraph V) where
  verts : Set V
  Adj : V → V → Prop
  adj_sub : ∀ {v w : V}, Adj v w → G.Adj v w
  edge_vert : ∀ {v w : V}, Adj v w → v ∈ verts
  symm : Symmetric Adj := by aesop_graph
goal: self.Adj v w → G.Adj v w

full_name: SimpleGraph.singletonSubgraph_verts
code: /-- The one-vertex subgraph. -/
@[simps]
protected def singletonSubgraph (G : SimpleGraph V) (v : V) : G.Subgraph 
goal: (G.singletonSubgraph v).verts = {v}

full_name: SimpleGraph.singletonSubgraph
code: /-- The one-vertex subgraph. -/
@[simps]
protected def singletonSubgraph (G : SimpleGraph V) (v : V) : G.Subgraph 
goal: G.Subgraph

full_name: SimpleGraph.singletonSubgraph_adj
code: /-- The one-vertex subgraph. -/
@[simps]
protected def singletonSubgraph (G : SimpleGraph V) (v : V) : G.Subgraph 
goal: ∀ (a a_1 : V), (G.singletonSubgraph v).Adj a a_1 = ⊥ a a_1

full_name: SimpleGraph.subgraphOfAdj_verts
code: /-- The one-edge subgraph. -/
@[simps]
def subgraphOfAdj (G : SimpleGraph V) {v w : V} (hvw : G.Adj v w) : G.Subgraph 
goal: (G.subgraphOfAdj hvw).verts = {v, w}

full_name: SimpleGraph.subgraphOfAdj
code: /-- The one-edge subgraph. -/
@[simps]
def subgraphOfAdj (G : SimpleGraph V) {v w : V} (hvw : G.Adj v w) : G.Subgraph 
goal: G.Subgraph

full_name: SimpleGraph.subgraphOfAdj_adj
code: /-- The one-edge subgraph. -/
@[simps]
def subgraphOfAdj (G : SimpleGraph V) {v w : V} (hvw : G.Adj v w) : G.Subgraph 
goal: (G.subgraphOfAdj hvw).Adj a b = (s(v, w) = s(a, b))

full_name: SimpleGraph.Subgraph.loopless
code: protected theorem loopless (G' : Subgraph G) : Irreflexive G'.Adj 
goal: Irreflexive G'.Adj

full_name: SimpleGraph.Subgraph.adj_comm
code: theorem adj_comm (G' : Subgraph G) (v w : V) : G'.Adj v w ↔ G'.Adj w v 
goal: G'.Adj v w ↔ G'.Adj w v

full_name: SimpleGraph.Subgraph.adj_symm
code: @[symm]
theorem adj_symm (G' : Subgraph G) {u v : V} (h : G'.Adj u v) : G'.Adj v u 
goal: G'.Adj v u

full_name: SimpleGraph.Subgraph.Adj.symm
code: protected theorem Adj.symm {G' : Subgraph G} {u v : V} (h : G'.Adj u v) : G'.Adj v u 
goal: G'.Adj v u

full_name: SimpleGraph.Subgraph.Adj.adj_sub
code: protected theorem Adj.adj_sub {H : G.Subgraph} {u v : V} (h : H.Adj u v) : G.Adj u v 
goal: G.Adj u v

full_name: SimpleGraph.Subgraph.Adj.fst_mem
code: protected theorem Adj.fst_mem {H : G.Subgraph} {u v : V} (h : H.Adj u v) : u ∈ H.verts 
goal: u ∈ H.verts

full_name: SimpleGraph.Subgraph.Adj.snd_mem
code: protected theorem Adj.snd_mem {H : G.Subgraph} {u v : V} (h : H.Adj u v) : v ∈ H.verts 
goal: v ∈ H.verts

full_name: SimpleGraph.Subgraph.Adj.ne
code: protected theorem Adj.ne {H : G.Subgraph} {u v : V} (h : H.Adj u v) : u ≠ v 
goal: u ≠ v

full_name: SimpleGraph.Subgraph.coe_adj
code: /-- Coercion from `G' : Subgraph G` to a `SimpleGraph G'.verts`. -/
@[simps]
protected def coe (G' : Subgraph G) : SimpleGraph G'.verts 
goal: G'.coe.Adj v w = G'.Adj ↑v ↑w

full_name: SimpleGraph.Subgraph.coe
code: /-- Coercion from `G' : Subgraph G` to a `SimpleGraph G'.verts`. -/
@[simps]
protected def coe (G' : Subgraph G) : SimpleGraph G'.verts 
goal: SimpleGraph ↑G'.verts

full_name: SimpleGraph.Subgraph.coe_adj_sub
code: @[simp]
theorem coe_adj_sub (G' : Subgraph G) (u v : G'.verts) (h : G'.coe.Adj u v) : G.Adj u v 
goal: G.Adj ↑u ↑v

full_name: SimpleGraph.Subgraph.Adj.coe
code: protected theorem Adj.coe {H : G.Subgraph} {u v : V} (h : H.Adj u v) :
    H.coe.Adj ⟨u, H.edge_vert h⟩ ⟨v, H.edge_vert h.symm⟩ 
goal: H.coe.Adj ⟨u, ⋯⟩ ⟨v, ⋯⟩

full_name: SimpleGraph.Subgraph.IsSpanning
code: /-- A subgraph is called a *spanning subgraph* if it contains all the vertices of `G`. -/
def IsSpanning (G' : Subgraph G) : Prop 
goal: Prop

full_name: SimpleGraph.Subgraph.isSpanning_iff
code: theorem isSpanning_iff {G' : Subgraph G} : G'.IsSpanning ↔ G'.verts = Set.univ 
goal: G'.IsSpanning ↔ G'.verts = Set.univ

full_name: SimpleGraph.Subgraph.spanningCoe_adj
code: /-- Coercion from `Subgraph G` to `SimpleGraph V`.  If `G'` is a spanning
subgraph, then `G'.spanningCoe` yields an isomorphic graph.
In general, this adds in all vertices from `V` as isolated vertices. -/
@[simps]
protected def spanningCoe (G' : Subgraph G) : SimpleGraph V 
goal: ∀ (a a_1 : V), G'.spanningCoe.Adj a a_1 = G'.Adj a a_1

full_name: SimpleGraph.Subgraph.spanningCoe
code: /-- Coercion from `Subgraph G` to `SimpleGraph V`.  If `G'` is a spanning
subgraph, then `G'.spanningCoe` yields an isomorphic graph.
In general, this adds in all vertices from `V` as isolated vertices. -/
@[simps]
protected def spanningCoe (G' : Subgraph G) : SimpleGraph V 
goal: SimpleGraph V

full_name: SimpleGraph.Subgraph.Adj.of_spanningCoe
code: @[simp]
theorem Adj.of_spanningCoe {G' : Subgraph G} {u v : G'.verts} (h : G'.spanningCoe.Adj u v) :
    G.Adj u v 
goal: G.Adj ↑u ↑v

full_name: SimpleGraph.Subgraph.spanningCoe_inj
code: theorem spanningCoe_inj : G₁.spanningCoe = G₂.spanningCoe ↔ G₁.Adj = G₂.Adj 
goal: G₁.spanningCoe = G₂.spanningCoe ↔ G₁.Adj = G₂.Adj

full_name: SimpleGraph.Subgraph.spanningCoeEquivCoeOfSpanning
code: /-- `spanningCoe` is equivalent to `coe` for a subgraph that `IsSpanning`. -/
@[simps]
def spanningCoeEquivCoeOfSpanning (G' : Subgraph G) (h : G'.IsSpanning) :
    G'.spanningCoe ≃g G'.coe 
goal: G'.spanningCoe ≃g G'.coe

full_name: SimpleGraph.Subgraph.spanningCoeEquivCoeOfSpanning_apply_coe
code: /-- `spanningCoe` is equivalent to `coe` for a subgraph that `IsSpanning`. -/
@[simps]
def spanningCoeEquivCoeOfSpanning (G' : Subgraph G) (h : G'.IsSpanning) :
    G'.spanningCoe ≃g G'.coe 
goal: ↑((G'.spanningCoeEquivCoeOfSpanning h) v) = v

full_name: SimpleGraph.Subgraph.spanningCoeEquivCoeOfSpanning_symm_apply
code: /-- `spanningCoe` is equivalent to `coe` for a subgraph that `IsSpanning`. -/
@[simps]
def spanningCoeEquivCoeOfSpanning (G' : Subgraph G) (h : G'.IsSpanning) :
    G'.spanningCoe ≃g G'.coe 
goal: (RelIso.symm (G'.spanningCoeEquivCoeOfSpanning h)) v = ↑v

full_name: SimpleGraph.Subgraph.IsInduced
code: /-- A subgraph is called an *induced subgraph* if vertices of `G'` are adjacent if
they are adjacent in `G`. -/
def IsInduced (G' : Subgraph G) : Prop 
goal: Prop

full_name: SimpleGraph.Subgraph.support
code: /-- `H.support` is the set of vertices that form edges in the subgraph `H`. -/
def support (H : Subgraph G) : Set V 
goal: Set V

full_name: SimpleGraph.Subgraph.mem_support
code: theorem mem_support (H : Subgraph G) {v : V} : v ∈ H.support ↔ ∃ w, H.Adj v w 
goal: v ∈ H.support ↔ ∃ w, H.Adj v w

full_name: SimpleGraph.Subgraph.support_subset_verts
code: theorem support_subset_verts (H : Subgraph G) : H.support ⊆ H.verts 
goal: H.support ⊆ H.verts

full_name: SimpleGraph.Subgraph.neighborSet
code: /-- `G'.neighborSet v` is the set of vertices adjacent to `v` in `G'`. -/
def neighborSet (G' : Subgraph G) (v : V) : Set V 
goal: Set V

full_name: SimpleGraph.Subgraph.neighborSet_subset
code: theorem neighborSet_subset (G' : Subgraph G) (v : V) : G'.neighborSet v ⊆ G.neighborSet v 
goal: G'.neighborSet v ⊆ G.neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet_subset_verts
code: theorem neighborSet_subset_verts (G' : Subgraph G) (v : V) : G'.neighborSet v ⊆ G'.verts 
goal: G'.neighborSet v ⊆ G'.verts

full_name: SimpleGraph.Subgraph.mem_neighborSet
code: @[simp]
theorem mem_neighborSet (G' : Subgraph G) (v w : V) : w ∈ G'.neighborSet v ↔ G'.Adj v w 
goal: w ∈ G'.neighborSet v ↔ G'.Adj v w

full_name: SimpleGraph.Subgraph.coeNeighborSetEquiv
code: /-- A subgraph as a graph has equivalent neighbor sets. -/
def coeNeighborSetEquiv {G' : Subgraph G} (v : G'.verts) :
    G'.coe.neighborSet v ≃ G'.neighborSet v 
goal: ↑(G'.coe.neighborSet v) ≃ ↑(G'.neighborSet ↑v)

full_name: SimpleGraph.Subgraph.edgeSet
code: /-- The edge set of `G'` consists of a subset of edges of `G`. -/
def edgeSet (G' : Subgraph G) : Set (Sym2 V) 
goal: Set (Sym2 V)

full_name: SimpleGraph.Subgraph.edgeSet_subset
code: theorem edgeSet_subset (G' : Subgraph G) : G'.edgeSet ⊆ G.edgeSet 
goal: G'.edgeSet ⊆ G.edgeSet

full_name: SimpleGraph.Subgraph.mem_edgeSet
code: @[simp]
theorem mem_edgeSet {G' : Subgraph G} {v w : V} : s(v, w) ∈ G'.edgeSet ↔ G'.Adj v w 
goal: s(v, w) ∈ G'.edgeSet ↔ G'.Adj v w

full_name: SimpleGraph.Subgraph.mem_verts_if_mem_edge
code: theorem mem_verts_if_mem_edge {G' : Subgraph G} {e : Sym2 V} {v : V} (he : e ∈ G'.edgeSet)
    (hv : v ∈ e) : v ∈ G'.verts 
goal: v ∈ G'.verts

full_name: SimpleGraph.Subgraph.incidenceSet
code: /-- The `incidenceSet` is the set of edges incident to a given vertex. -/
def incidenceSet (G' : Subgraph G) (v : V) : Set (Sym2 V) 
goal: Set (Sym2 V)

full_name: SimpleGraph.Subgraph.incidenceSet_subset_incidenceSet
code: theorem incidenceSet_subset_incidenceSet (G' : Subgraph G) (v : V) :
    G'.incidenceSet v ⊆ G.incidenceSet v 
goal: G'.incidenceSet v ⊆ G.incidenceSet v

full_name: SimpleGraph.Subgraph.incidenceSet_subset
code: theorem incidenceSet_subset (G' : Subgraph G) (v : V) : G'.incidenceSet v ⊆ G'.edgeSet 
goal: G'.incidenceSet v ⊆ G'.edgeSet

full_name: SimpleGraph.Subgraph.vert
code: /-- Give a vertex as an element of the subgraph's vertex type. -/
abbrev vert (G' : Subgraph G) (v : V) (h : v ∈ G'.verts) : G'.verts 
goal: ↑G'.verts

full_name: SimpleGraph.Subgraph.copy
code: /--
Create an equal copy of a subgraph (see `copy_eq`) with possibly different definitional equalities.
See Note [range copy pattern].
-/
def copy (G' : Subgraph G) (V'' : Set V) (hV : V'' = G'.verts)
    (adj' : V → V → Prop) (hadj : adj' = G'.Adj) : Subgraph G 
goal: G.Subgraph

full_name: SimpleGraph.Subgraph.copy_eq
code: theorem copy_eq (G' : Subgraph G) (V'' : Set V) (hV : V'' = G'.verts)
    (adj' : V → V → Prop) (hadj : adj' = G'.Adj) : G'.copy V'' hV adj' hadj = G' 
goal: G'.copy V'' hV adj' hadj = G'

full_name: SimpleGraph.Subgraph.instSup
code: /-- The union of two subgraphs. -/
instance : Sup G.Subgraph 
goal: Sup G.Subgraph

full_name: SimpleGraph.Subgraph.instInf
code: /-- The intersection of two subgraphs. -/
instance : Inf G.Subgraph 
goal: Inf G.Subgraph

full_name: SimpleGraph.Subgraph.instTop
code: /-- The `top` subgraph is `G` as a subgraph of itself. -/
instance : Top G.Subgraph 
goal: Top G.Subgraph

full_name: SimpleGraph.Subgraph.instBot
code: /-- The `bot` subgraph is the subgraph with no vertices or edges. -/
instance : Bot G.Subgraph 
goal: Bot G.Subgraph

full_name: SimpleGraph.Subgraph.instSupSet
code: instance : SupSet G.Subgraph 
goal: SupSet G.Subgraph

full_name: SimpleGraph.Subgraph.instInfSet
code: instance : InfSet G.Subgraph 
goal: InfSet G.Subgraph

full_name: SimpleGraph.Subgraph.sup_adj
code: @[simp]
theorem sup_adj : (G₁ ⊔ G₂).Adj a b ↔ G₁.Adj a b ∨ G₂.Adj a b 
goal: (G₁ ⊔ G₂).Adj a b ↔ G₁.Adj a b ∨ G₂.Adj a b

full_name: SimpleGraph.Subgraph.inf_adj
code: @[simp]
theorem inf_adj : (G₁ ⊓ G₂).Adj a b ↔ G₁.Adj a b ∧ G₂.Adj a b 
goal: (G₁ ⊓ G₂).Adj a b ↔ G₁.Adj a b ∧ G₂.Adj a b

full_name: SimpleGraph.Subgraph.top_adj
code: @[simp]
theorem top_adj : (⊤ : Subgraph G).Adj a b ↔ G.Adj a b 
goal: ⊤.Adj a b ↔ G.Adj a b

full_name: SimpleGraph.Subgraph.not_bot_adj
code: @[simp]
theorem not_bot_adj : ¬ (⊥ : Subgraph G).Adj a b 
goal: ¬⊥.Adj a b

full_name: SimpleGraph.Subgraph.verts_sup
code: @[simp]
theorem verts_sup (G₁ G₂ : G.Subgraph) : (G₁ ⊔ G₂).verts = G₁.verts ∪ G₂.verts 
goal: (G₁ ⊔ G₂).verts = G₁.verts ∪ G₂.verts

full_name: SimpleGraph.Subgraph.verts_inf
code: @[simp]
theorem verts_inf (G₁ G₂ : G.Subgraph) : (G₁ ⊓ G₂).verts = G₁.verts ∩ G₂.verts 
goal: (G₁ ⊓ G₂).verts = G₁.verts ∩ G₂.verts

full_name: SimpleGraph.Subgraph.verts_top
code: @[simp]
theorem verts_top : (⊤ : G.Subgraph).verts = Set.univ 
goal: ⊤.verts = Set.univ

full_name: SimpleGraph.Subgraph.verts_bot
code: @[simp]
theorem verts_bot : (⊥ : G.Subgraph).verts = ∅ 
goal: ⊥.verts = ∅

full_name: SimpleGraph.Subgraph.sSup_adj
code: @[simp]
theorem sSup_adj {s : Set G.Subgraph} : (sSup s).Adj a b ↔ ∃ G ∈ s, Adj G a b 
goal: (sSup s).Adj a b ↔ ∃ G_1 ∈ s, G_1.Adj a b

full_name: SimpleGraph.Subgraph.sInf_adj
code: @[simp]
theorem sInf_adj {s : Set G.Subgraph} : (sInf s).Adj a b ↔ (∀ G' ∈ s, Adj G' a b) ∧ G.Adj a b 
goal: (sInf s).Adj a b ↔ (∀ G' ∈ s, G'.Adj a b) ∧ G.Adj a b

full_name: SimpleGraph.Subgraph.iSup_adj
code: @[simp]
theorem iSup_adj {f : ι → G.Subgraph} : (⨆ i, f i).Adj a b ↔ ∃ i, (f i).Adj a b 
goal: (⨆ i, f i).Adj a b ↔ ∃ i, (f i).Adj a b

full_name: SimpleGraph.Subgraph.iInf_adj
code: @[simp]
theorem iInf_adj {f : ι → G.Subgraph} : (⨅ i, f i).Adj a b ↔ (∀ i, (f i).Adj a b) ∧ G.Adj a b 
goal: (⨅ i, f i).Adj a b ↔ (∀ (i : ι), (f i).Adj a b) ∧ G.Adj a b

full_name: SimpleGraph.Subgraph.sInf_adj_of_nonempty
code: theorem sInf_adj_of_nonempty {s : Set G.Subgraph} (hs : s.Nonempty) :
    (sInf s).Adj a b ↔ ∀ G' ∈ s, Adj G' a b 
goal: (sInf s).Adj a b ↔ ∀ G' ∈ s, G'.Adj a b

full_name: SimpleGraph.Subgraph.iInf_adj_of_nonempty
code: theorem iInf_adj_of_nonempty [Nonempty ι] {f : ι → G.Subgraph} :
    (⨅ i, f i).Adj a b ↔ ∀ i, (f i).Adj a b 
goal: (⨅ i, f i).Adj a b ↔ ∀ (i : ι), (f i).Adj a b

full_name: SimpleGraph.Subgraph.verts_sSup
code: @[simp]
theorem verts_sSup (s : Set G.Subgraph) : (sSup s).verts = ⋃ G' ∈ s, verts G' 
goal: (sSup s).verts = ⋃ G' ∈ s, G'.verts

full_name: SimpleGraph.Subgraph.verts_sInf
code: @[simp]
theorem verts_sInf (s : Set G.Subgraph) : (sInf s).verts = ⋂ G' ∈ s, verts G' 
goal: (sInf s).verts = ⋂ G' ∈ s, G'.verts

full_name: SimpleGraph.Subgraph.verts_iSup
code: @[simp]
theorem verts_iSup {f : ι → G.Subgraph} : (⨆ i, f i).verts = ⋃ i, (f i).verts 
goal: (⨆ i, f i).verts = ⋃ i, (f i).verts

full_name: SimpleGraph.Subgraph.verts_iInf
code: @[simp]
theorem verts_iInf {f : ι → G.Subgraph} : (⨅ i, f i).verts = ⋂ i, (f i).verts 
goal: (⨅ i, f i).verts = ⋂ i, (f i).verts

full_name: SimpleGraph.Subgraph.verts_spanningCoe_injective
code: theorem verts_spanningCoe_injective :
    (fun G' : Subgraph G => (G'.verts, G'.spanningCoe)).Injective 
goal: Function.Injective fun G' => (G'.verts, G'.spanningCoe)

full_name: SimpleGraph.Subgraph.distribLattice
code: /-- For subgraphs `G₁`, `G₂`, `G₁ ≤ G₂` iff `G₁.verts ⊆ G₂.verts` and
`∀ a b, G₁.adj a b → G₂.adj a b`. -/
instance distribLattice : DistribLattice G.Subgraph 
goal: DistribLattice G.Subgraph

full_name: SimpleGraph.Subgraph.instBoundedOrder
code: instance : BoundedOrder (Subgraph G) 
goal: BoundedOrder G.Subgraph

full_name: SimpleGraph.Subgraph.completelyDistribLatticeMinimalAxioms
code: /-- Note that subgraphs do not form a Boolean algebra, because of `verts`. -/
def completelyDistribLatticeMinimalAxioms : CompletelyDistribLattice.MinimalAxioms G.Subgraph 
goal: CompletelyDistribLattice.MinimalAxioms G.Subgraph

full_name: SimpleGraph.Subgraph.instCompletelyDistribLattice
code: instance : CompletelyDistribLattice G.Subgraph 
goal: CompletelyDistribLattice G.Subgraph

full_name: SimpleGraph.Subgraph.verts_mono
code: @[gcongr] lemma verts_mono {H H' : G.Subgraph} (h : H ≤ H') : H.verts ⊆ H'.verts 
goal: H.verts ⊆ H'.verts

full_name: SimpleGraph.Subgraph.verts_monotone
code: lemma verts_monotone : Monotone (verts : G.Subgraph → Set V) 
goal: Monotone SimpleGraph.Subgraph.verts

full_name: SimpleGraph.Subgraph.subgraphInhabited_default
code: @[simps]
instance subgraphInhabited : Inhabited (Subgraph G) 
goal: default = ⊥

full_name: SimpleGraph.Subgraph.subgraphInhabited
code: @[simps]
instance subgraphInhabited : Inhabited (Subgraph G) 
goal: Inhabited G.Subgraph

full_name: SimpleGraph.Subgraph.neighborSet_sup
code: @[simp]
theorem neighborSet_sup {H H' : G.Subgraph} (v : V) :
    (H ⊔ H').neighborSet v = H.neighborSet v ∪ H'.neighborSet v 
goal: (H ⊔ H').neighborSet v = H.neighborSet v ∪ H'.neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet_inf
code: @[simp]
theorem neighborSet_inf {H H' : G.Subgraph} (v : V) :
    (H ⊓ H').neighborSet v = H.neighborSet v ∩ H'.neighborSet v 
goal: (H ⊓ H').neighborSet v = H.neighborSet v ∩ H'.neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet_top
code: @[simp]
theorem neighborSet_top (v : V) : (⊤ : G.Subgraph).neighborSet v = G.neighborSet v 
goal: ⊤.neighborSet v = G.neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet_bot
code: @[simp]
theorem neighborSet_bot (v : V) : (⊥ : G.Subgraph).neighborSet v = ∅ 
goal: ⊥.neighborSet v = ∅

full_name: SimpleGraph.Subgraph.neighborSet_sSup
code: @[simp]
theorem neighborSet_sSup (s : Set G.Subgraph) (v : V) :
    (sSup s).neighborSet v = ⋃ G' ∈ s, neighborSet G' v 
goal: (sSup s).neighborSet v = ⋃ G' ∈ s, G'.neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet_sInf
code: @[simp]
theorem neighborSet_sInf (s : Set G.Subgraph) (v : V) :
    (sInf s).neighborSet v = (⋂ G' ∈ s, neighborSet G' v) ∩ G.neighborSet v 
goal: (sInf s).neighborSet v = (⋂ G' ∈ s, G'.neighborSet v) ∩ G.neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet_iSup
code: @[simp]
theorem neighborSet_iSup (f : ι → G.Subgraph) (v : V) :
    (⨆ i, f i).neighborSet v = ⋃ i, (f i).neighborSet v 
goal: (⨆ i, f i).neighborSet v = ⋃ i, (f i).neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet_iInf
code: @[simp]
theorem neighborSet_iInf (f : ι → G.Subgraph) (v : V) :
    (⨅ i, f i).neighborSet v = (⋂ i, (f i).neighborSet v) ∩ G.neighborSet v 
goal: (⨅ i, f i).neighborSet v = (⋂ i, (f i).neighborSet v) ∩ G.neighborSet v

full_name: SimpleGraph.Subgraph.edgeSet_top
code: @[simp]
theorem edgeSet_top : (⊤ : Subgraph G).edgeSet = G.edgeSet 
goal: ⊤.edgeSet = G.edgeSet

full_name: SimpleGraph.Subgraph.edgeSet_bot
code: @[simp]
theorem edgeSet_bot : (⊥ : Subgraph G).edgeSet = ∅ 
goal: ⊥.edgeSet = ∅

full_name: SimpleGraph.Subgraph.edgeSet_inf
code: @[simp]
theorem edgeSet_inf {H₁ H₂ : Subgraph G} : (H₁ ⊓ H₂).edgeSet = H₁.edgeSet ∩ H₂.edgeSet 
goal: (H₁ ⊓ H₂).edgeSet = H₁.edgeSet ∩ H₂.edgeSet

full_name: SimpleGraph.Subgraph.edgeSet_sup
code: @[simp]
theorem edgeSet_sup {H₁ H₂ : Subgraph G} : (H₁ ⊔ H₂).edgeSet = H₁.edgeSet ∪ H₂.edgeSet 
goal: (H₁ ⊔ H₂).edgeSet = H₁.edgeSet ∪ H₂.edgeSet

full_name: SimpleGraph.Subgraph.edgeSet_sSup
code: @[simp]
theorem edgeSet_sSup (s : Set G.Subgraph) : (sSup s).edgeSet = ⋃ G' ∈ s, edgeSet G' 
goal: (sSup s).edgeSet = ⋃ G' ∈ s, G'.edgeSet

full_name: SimpleGraph.Subgraph.edgeSet_sInf
code: @[simp]
theorem edgeSet_sInf (s : Set G.Subgraph) :
    (sInf s).edgeSet = (⋂ G' ∈ s, edgeSet G') ∩ G.edgeSet 
goal: (sInf s).edgeSet = (⋂ G' ∈ s, G'.edgeSet) ∩ G.edgeSet

full_name: SimpleGraph.Subgraph.edgeSet_iSup
code: @[simp]
theorem edgeSet_iSup (f : ι → G.Subgraph) :
    (⨆ i, f i).edgeSet = ⋃ i, (f i).edgeSet 
goal: (⨆ i, f i).edgeSet = ⋃ i, (f i).edgeSet

full_name: SimpleGraph.Subgraph.edgeSet_iInf
code: @[simp]
theorem edgeSet_iInf (f : ι → G.Subgraph) :
    (⨅ i, f i).edgeSet = (⋂ i, (f i).edgeSet) ∩ G.edgeSet 
goal: (⨅ i, f i).edgeSet = (⋂ i, (f i).edgeSet) ∩ G.edgeSet

full_name: SimpleGraph.Subgraph.spanningCoe_top
code: @[simp]
theorem spanningCoe_top : (⊤ : Subgraph G).spanningCoe = G 
goal: ⊤.spanningCoe = G

full_name: SimpleGraph.Subgraph.spanningCoe_bot
code: @[simp]
theorem spanningCoe_bot : (⊥ : Subgraph G).spanningCoe = ⊥ 
goal: ⊥.spanningCoe = ⊥

full_name: SimpleGraph.toSubgraph
code: /-- Turn a subgraph of a `SimpleGraph` into a member of its subgraph type. -/
@[simps]
def _root_.SimpleGraph.toSubgraph (H : SimpleGraph V) (h : H ≤ G) : G.Subgraph 
goal: G.Subgraph

full_name: SimpleGraph.toSubgraph_verts
code: /-- Turn a subgraph of a `SimpleGraph` into a member of its subgraph type. -/
@[simps]
def _root_.SimpleGraph.toSubgraph (H : SimpleGraph V) (h : H ≤ G) : G.Subgraph 
goal: (SimpleGraph.toSubgraph H h).verts = Set.univ

full_name: SimpleGraph.toSubgraph_adj
code: /-- Turn a subgraph of a `SimpleGraph` into a member of its subgraph type. -/
@[simps]
def _root_.SimpleGraph.toSubgraph (H : SimpleGraph V) (h : H ≤ G) : G.Subgraph 
goal: ∀ (a a_1 : V), (SimpleGraph.toSubgraph H h).Adj a a_1 = H.Adj a a_1

full_name: SimpleGraph.Subgraph.support_mono
code: theorem support_mono {H H' : Subgraph G} (h : H ≤ H') : H.support ⊆ H'.support 
goal: H.support ⊆ H'.support

full_name: SimpleGraph.toSubgraph.isSpanning
code: theorem _root_.SimpleGraph.toSubgraph.isSpanning (H : SimpleGraph V) (h : H ≤ G) :
    (toSubgraph H h).IsSpanning 
goal: (SimpleGraph.toSubgraph H h).IsSpanning

full_name: SimpleGraph.Subgraph.spanningCoe_le_of_le
code: theorem spanningCoe_le_of_le {H H' : Subgraph G} (h : H ≤ H') : H.spanningCoe ≤ H'.spanningCoe 
goal: H.spanningCoe ≤ H'.spanningCoe

full_name: SimpleGraph.Subgraph.topEquiv
code: /-- The top of the `Subgraph G` lattice is equivalent to the graph itself. -/
def topEquiv : (⊤ : Subgraph G).coe ≃g G 
goal: ⊤.coe ≃g G

full_name: SimpleGraph.Subgraph.botEquiv
code: /-- The bottom of the `Subgraph G` lattice is equivalent to the empty graph on the empty
vertex type. -/
def botEquiv : (⊥ : Subgraph G).coe ≃g (⊥ : SimpleGraph Empty) 
goal: ⊥.coe ≃g ⊥

full_name: SimpleGraph.Subgraph.edgeSet_mono
code: theorem edgeSet_mono {H₁ H₂ : Subgraph G} (h : H₁ ≤ H₂) : H₁.edgeSet ≤ H₂.edgeSet 
goal: H₁.edgeSet ≤ H₂.edgeSet

full_name: Disjoint.edgeSet
code: theorem _root_.Disjoint.edgeSet {H₁ H₂ : Subgraph G} (h : Disjoint H₁ H₂) :
    Disjoint H₁.edgeSet H₂.edgeSet 
goal: Disjoint H₁.edgeSet H₂.edgeSet

full_name: SimpleGraph.Subgraph.map_adj
code: /-- Graph homomorphisms induce a covariant function on subgraphs. -/
@[simps]
protected def map {G' : SimpleGraph W} (f : G →g G') (H : G.Subgraph) : G'.Subgraph 
goal: ∀ (a a_1 : W), (SimpleGraph.Subgraph.map f H).Adj a a_1 = Relation.Map H.Adj (⇑f) (⇑f) a a_1

full_name: SimpleGraph.Subgraph.map
code: /-- Graph homomorphisms induce a covariant function on subgraphs. -/
@[simps]
protected def map {G' : SimpleGraph W} (f : G →g G') (H : G.Subgraph) : G'.Subgraph 
goal: G'.Subgraph

full_name: SimpleGraph.Subgraph.map_verts
code: /-- Graph homomorphisms induce a covariant function on subgraphs. -/
@[simps]
protected def map {G' : SimpleGraph W} (f : G →g G') (H : G.Subgraph) : G'.Subgraph 
goal: (SimpleGraph.Subgraph.map f H).verts = ⇑f '' H.verts

full_name: SimpleGraph.Subgraph.map_monotone
code: theorem map_monotone {G' : SimpleGraph W} (f : G →g G') : Monotone (Subgraph.map f) 
goal: Monotone (SimpleGraph.Subgraph.map f)

full_name: SimpleGraph.Subgraph.map_sup
code: theorem map_sup {G : SimpleGraph V} {G' : SimpleGraph W} (f : G →g G') {H H' : G.Subgraph} :
    (H ⊔ H').map f = H.map f ⊔ H'.map f 
goal: SimpleGraph.Subgraph.map f (H ⊔ H') = SimpleGraph.Subgraph.map f H ⊔ SimpleGraph.Subgraph.map f H'

full_name: SimpleGraph.Subgraph.comap_adj
code: /-- Graph homomorphisms induce a contravariant function on subgraphs. -/
@[simps]
protected def comap {G' : SimpleGraph W} (f : G →g G') (H : G'.Subgraph) : G.Subgraph 
goal: (SimpleGraph.Subgraph.comap f H).Adj u v = (G.Adj u v ∧ H.Adj (f u) (f v))

full_name: SimpleGraph.Subgraph.comap_verts
code: /-- Graph homomorphisms induce a contravariant function on subgraphs. -/
@[simps]
protected def comap {G' : SimpleGraph W} (f : G →g G') (H : G'.Subgraph) : G.Subgraph 
goal: (SimpleGraph.Subgraph.comap f H).verts = ⇑f ⁻¹' H.verts

full_name: SimpleGraph.Subgraph.comap
code: /-- Graph homomorphisms induce a contravariant function on subgraphs. -/
@[simps]
protected def comap {G' : SimpleGraph W} (f : G →g G') (H : G'.Subgraph) : G.Subgraph 
goal: G.Subgraph

full_name: SimpleGraph.Subgraph.comap_monotone
code: theorem comap_monotone {G' : SimpleGraph W} (f : G →g G') : Monotone (Subgraph.comap f) 
goal: Monotone (SimpleGraph.Subgraph.comap f)

full_name: SimpleGraph.Subgraph.map_le_iff_le_comap
code: theorem map_le_iff_le_comap {G' : SimpleGraph W} (f : G →g G') (H : G.Subgraph) (H' : G'.Subgraph) :
    H.map f ≤ H' ↔ H ≤ H'.comap f 
goal: SimpleGraph.Subgraph.map f H ≤ H' ↔ H ≤ SimpleGraph.Subgraph.comap f H'

full_name: SimpleGraph.Subgraph.inclusion
code: /-- Given two subgraphs, one a subgraph of the other, there is an induced injective homomorphism of
the subgraphs as graphs. -/
@[simps]
def inclusion {x y : Subgraph G} (h : x ≤ y) : x.coe →g y.coe 
goal: x.coe →g y.coe

full_name: SimpleGraph.Subgraph.inclusion_apply_coe
code: /-- Given two subgraphs, one a subgraph of the other, there is an induced injective homomorphism of
the subgraphs as graphs. -/
@[simps]
def inclusion {x y : Subgraph G} (h : x ≤ y) : x.coe →g y.coe 
goal: ↑((SimpleGraph.Subgraph.inclusion h) v) = ↑v

full_name: SimpleGraph.Subgraph.inclusion.injective
code: theorem inclusion.injective {x y : Subgraph G} (h : x ≤ y) : Function.Injective (inclusion h) 
goal: Function.Injective ⇑(SimpleGraph.Subgraph.inclusion h)

full_name: SimpleGraph.Subgraph.hom_apply
code: /-- There is an induced injective homomorphism of a subgraph of `G` into `G`. -/
@[simps]
protected def hom (x : Subgraph G) : x.coe →g G 
goal: x.hom v = ↑v

full_name: SimpleGraph.Subgraph.hom
code: /-- There is an induced injective homomorphism of a subgraph of `G` into `G`. -/
@[simps]
protected def hom (x : Subgraph G) : x.coe →g G 
goal: x.coe →g G

full_name: SimpleGraph.Subgraph.coe_hom
code: @[simp] lemma coe_hom (x : Subgraph G) :
    (x.hom : x.verts → V) = (fun (v : x.verts) => (v : V)) 
goal: ⇑x.hom = fun v => ↑v

full_name: SimpleGraph.Subgraph.hom.injective
code: theorem hom.injective {x : Subgraph G} : Function.Injective x.hom 
goal: Function.Injective ⇑x.hom

full_name: SimpleGraph.Subgraph.spanningHom_apply
code: /-- There is an induced injective homomorphism of a subgraph of `G` as
a spanning subgraph into `G`. -/
@[simps]
def spanningHom (x : Subgraph G) : x.spanningCoe →g G 
goal: x.spanningHom a = id a

full_name: SimpleGraph.Subgraph.spanningHom
code: /-- There is an induced injective homomorphism of a subgraph of `G` as
a spanning subgraph into `G`. -/
@[simps]
def spanningHom (x : Subgraph G) : x.spanningCoe →g G 
goal: x.spanningCoe →g G

full_name: SimpleGraph.Subgraph.spanningHom.injective
code: theorem spanningHom.injective {x : Subgraph G} : Function.Injective x.spanningHom 
goal: Function.Injective ⇑x.spanningHom

full_name: SimpleGraph.Subgraph.neighborSet_subset_of_subgraph
code: theorem neighborSet_subset_of_subgraph {x y : Subgraph G} (h : x ≤ y) (v : V) :
    x.neighborSet v ⊆ y.neighborSet v 
goal: x.neighborSet v ⊆ y.neighborSet v

full_name: SimpleGraph.Subgraph.neighborSet.decidablePred
code: instance neighborSet.decidablePred (G' : Subgraph G) [h : DecidableRel G'.Adj] (v : V) :
    DecidablePred (· ∈ G'.neighborSet v) 
goal: DecidablePred fun x => x ∈ G'.neighborSet v

full_name: SimpleGraph.Subgraph.finiteAt
code: /-- If a graph is locally finite at a vertex, then so is a subgraph of that graph. -/
instance finiteAt {G' : Subgraph G} (v : G'.verts) [DecidableRel G'.Adj]
    [Fintype (G.neighborSet v)] : Fintype (G'.neighborSet v) 
goal: Fintype ↑(G'.neighborSet ↑v)

full_name: SimpleGraph.Subgraph.finiteAtOfSubgraph
code: /-- If a subgraph is locally finite at a vertex, then so are subgraphs of that subgraph.

This is not an instance because `G''` cannot be inferred. -/
def finiteAtOfSubgraph {G' G'' : Subgraph G} [DecidableRel G'.Adj] (h : G' ≤ G'') (v : G'.verts)
    [Fintype (G''.neighborSet v)] : Fintype (G'.neighborSet v) 
goal: Fintype ↑(G'.neighborSet ↑v)

full_name: SimpleGraph.Subgraph.instFintypeElemNeighborSetOfVertsOfDecidablePredMemSet
code: instance (G' : Subgraph G) [Fintype G'.verts] (v : V) [DecidablePred (· ∈ G'.neighborSet v)] :
    Fintype (G'.neighborSet v) 
goal: Fintype ↑(G'.neighborSet v)

full_name: SimpleGraph.Subgraph.coeFiniteAt
code: instance coeFiniteAt {G' : Subgraph G} (v : G'.verts) [Fintype (G'.neighborSet v)] :
    Fintype (G'.coe.neighborSet v) 
goal: Fintype ↑(G'.coe.neighborSet v)

full_name: SimpleGraph.Subgraph.IsSpanning.card_verts
code: theorem IsSpanning.card_verts [Fintype V] {G' : Subgraph G} [Fintype G'.verts] (h : G'.IsSpanning) :
    G'.verts.toFinset.card = Fintype.card V 
goal: G'.verts.toFinset.card = Fintype.card V

full_name: SimpleGraph.Subgraph.degree
code: /-- The degree of a vertex in a subgraph. It's zero for vertices outside the subgraph. -/
def degree (G' : Subgraph G) (v : V) [Fintype (G'.neighborSet v)] : ℕ 
goal: ℕ

full_name: SimpleGraph.Subgraph.finset_card_neighborSet_eq_degree
code: theorem finset_card_neighborSet_eq_degree {G' : Subgraph G} {v : V} [Fintype (G'.neighborSet v)] :
    (G'.neighborSet v).toFinset.card = G'.degree v 
goal: (G'.neighborSet v).toFinset.card = G'.degree v

full_name: SimpleGraph.Subgraph.degree_le
code: theorem degree_le (G' : Subgraph G) (v : V) [Fintype (G'.neighborSet v)]
    [Fintype (G.neighborSet v)] : G'.degree v ≤ G.degree v 
goal: G'.degree v ≤ G.degree v

full_name: SimpleGraph.Subgraph.degree_le'
code: theorem degree_le' (G' G'' : Subgraph G) (h : G' ≤ G'') (v : V) [Fintype (G'.neighborSet v)]
    [Fintype (G''.neighborSet v)] : G'.degree v ≤ G''.degree v 
goal: G'.degree v ≤ G''.degree v

full_name: SimpleGraph.Subgraph.coe_degree
code: @[simp]
theorem coe_degree (G' : Subgraph G) (v : G'.verts) [Fintype (G'.coe.neighborSet v)]
    [Fintype (G'.neighborSet v)] : G'.coe.degree v = G'.degree v 
goal: G'.coe.degree v = G'.degree ↑v

full_name: SimpleGraph.Subgraph.degree_spanningCoe
code: @[simp]
theorem degree_spanningCoe {G' : G.Subgraph} (v : V) [Fintype (G'.neighborSet v)]
    [Fintype (G'.spanningCoe.neighborSet v)] : G'.spanningCoe.degree v = G'.degree v 
goal: G'.spanningCoe.degree v = G'.degree v

full_name: SimpleGraph.Subgraph.degree_eq_one_iff_unique_adj
code: theorem degree_eq_one_iff_unique_adj {G' : Subgraph G} {v : V} [Fintype (G'.neighborSet v)] :
    G'.degree v = 1 ↔ ∃! w : V, G'.Adj v w 
goal: G'.degree v = 1 ↔ ∃! w, G'.Adj v w

full_name: SimpleGraph.nonempty_singletonSubgraph_verts
code: instance nonempty_singletonSubgraph_verts (v : V) : Nonempty (G.singletonSubgraph v).verts 
goal: Nonempty ↑(G.singletonSubgraph v).verts

full_name: SimpleGraph.singletonSubgraph_le_iff
code: @[simp]
theorem singletonSubgraph_le_iff (v : V) (H : G.Subgraph) :
    G.singletonSubgraph v ≤ H ↔ v ∈ H.verts 
goal: G.singletonSubgraph v ≤ H ↔ v ∈ H.verts

full_name: SimpleGraph.map_singletonSubgraph
code: @[simp]
theorem map_singletonSubgraph (f : G →g G') {v : V} :
    Subgraph.map f (G.singletonSubgraph v) = G'.singletonSubgraph (f v) 
goal: SimpleGraph.Subgraph.map f (G.singletonSubgraph v) = G'.singletonSubgraph (f v)

full_name: SimpleGraph.neighborSet_singletonSubgraph
code: @[simp]
theorem neighborSet_singletonSubgraph (v w : V) : (G.singletonSubgraph v).neighborSet w = ∅ 
goal: (G.singletonSubgraph v).neighborSet w = ∅

full_name: SimpleGraph.edgeSet_singletonSubgraph
code: @[simp]
theorem edgeSet_singletonSubgraph (v : V) : (G.singletonSubgraph v).edgeSet = ∅ 
goal: (G.singletonSubgraph v).edgeSet = ∅

full_name: SimpleGraph.eq_singletonSubgraph_iff_verts_eq
code: theorem eq_singletonSubgraph_iff_verts_eq (H : G.Subgraph) {v : V} :
    H = G.singletonSubgraph v ↔ H.verts = {v} 
goal: H = G.singletonSubgraph v ↔ H.verts = {v}

full_name: SimpleGraph.nonempty_subgraphOfAdj_verts
code: instance nonempty_subgraphOfAdj_verts {v w : V} (hvw : G.Adj v w) :
    Nonempty (G.subgraphOfAdj hvw).verts 
goal: Nonempty ↑(G.subgraphOfAdj hvw).verts

full_name: SimpleGraph.edgeSet_subgraphOfAdj
code: @[simp]
theorem edgeSet_subgraphOfAdj {v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).edgeSet = {s(v, w)} 
goal: (G.subgraphOfAdj hvw).edgeSet = {s(v, w)}

full_name: SimpleGraph.subgraphOfAdj_le_of_adj
code: lemma subgraphOfAdj_le_of_adj {v w : V} (H : G.Subgraph) (h : H.Adj v w) :
    G.subgraphOfAdj (H.adj_sub h) ≤ H 
goal: G.subgraphOfAdj ⋯ ≤ H

full_name: SimpleGraph.subgraphOfAdj_symm
code: theorem subgraphOfAdj_symm {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw.symm = G.subgraphOfAdj hvw 
goal: G.subgraphOfAdj ⋯ = G.subgraphOfAdj hvw

full_name: SimpleGraph.map_subgraphOfAdj
code: @[simp]
theorem map_subgraphOfAdj (f : G →g G') {v w : V} (hvw : G.Adj v w) :
    Subgraph.map f (G.subgraphOfAdj hvw) = G'.subgraphOfAdj (f.map_adj hvw) 
goal: SimpleGraph.Subgraph.map f (G.subgraphOfAdj hvw) = G'.subgraphOfAdj ⋯

full_name: SimpleGraph.neighborSet_subgraphOfAdj_subset
code: theorem neighborSet_subgraphOfAdj_subset {u v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).neighborSet u ⊆ {v, w} 
goal: (G.subgraphOfAdj hvw).neighborSet u ⊆ {v, w}

full_name: SimpleGraph.neighborSet_fst_subgraphOfAdj
code: @[simp]
theorem neighborSet_fst_subgraphOfAdj {v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).neighborSet v = {w} 
goal: (G.subgraphOfAdj hvw).neighborSet v = {w}

full_name: SimpleGraph.neighborSet_snd_subgraphOfAdj
code: @[simp]
theorem neighborSet_snd_subgraphOfAdj {v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).neighborSet w = {v} 
goal: (G.subgraphOfAdj hvw).neighborSet w = {v}

full_name: SimpleGraph.neighborSet_subgraphOfAdj_of_ne_of_ne
code: @[simp]
theorem neighborSet_subgraphOfAdj_of_ne_of_ne {u v w : V} (hvw : G.Adj v w) (hv : u ≠ v)
    (hw : u ≠ w) : (G.subgraphOfAdj hvw).neighborSet u = ∅ 
goal: (G.subgraphOfAdj hvw).neighborSet u = ∅

full_name: SimpleGraph.neighborSet_subgraphOfAdj
code: theorem neighborSet_subgraphOfAdj [DecidableEq V] {u v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).neighborSet u =
    (if u = v then {w} else ∅) ∪ if u = w then {v} else ∅ 
goal: (G.subgraphOfAdj hvw).neighborSet u = (if u = v then {w} else ∅) ∪ if u = w then {v} else ∅

full_name: SimpleGraph.singletonSubgraph_fst_le_subgraphOfAdj
code: theorem singletonSubgraph_fst_le_subgraphOfAdj {u v : V} {h : G.Adj u v} :
    G.singletonSubgraph u ≤ G.subgraphOfAdj h 
goal: G.singletonSubgraph u ≤ G.subgraphOfAdj h

full_name: SimpleGraph.singletonSubgraph_snd_le_subgraphOfAdj
code: theorem singletonSubgraph_snd_le_subgraphOfAdj {u v : V} {h : G.Adj u v} :
    G.singletonSubgraph v ≤ G.subgraphOfAdj h 
goal: G.singletonSubgraph v ≤ G.subgraphOfAdj h

full_name: SimpleGraph.support_subgraphOfAdj
code: @[simp]
lemma support_subgraphOfAdj {u v : V} (h : G.Adj u v) :
    (G.subgraphOfAdj h).support = {u , v} 
goal: (G.subgraphOfAdj h).support = {u, v}

full_name: SimpleGraph.Subgraph.coeSubgraph
code: /-- Given a subgraph of a subgraph of `G`, construct a subgraph of `G`. -/
protected abbrev coeSubgraph {G' : G.Subgraph} : G'.coe.Subgraph → G.Subgraph 
goal: G'.coe.Subgraph → G.Subgraph

full_name: SimpleGraph.Subgraph.restrict
code: /-- Given a subgraph of `G`, restrict it to being a subgraph of another subgraph `G'` by
taking the portion of `G` that intersects `G'`. -/
protected abbrev restrict {G' : G.Subgraph} : G.Subgraph → G'.coe.Subgraph 
goal: G.Subgraph → G'.coe.Subgraph

full_name: SimpleGraph.Subgraph.verts_coeSubgraph
code: @[simp]
lemma verts_coeSubgraph {G' : Subgraph G} (G'' : Subgraph G'.coe) :
    G''.coeSubgraph.verts = (G''.verts : Set V) 
goal: (SimpleGraph.Subgraph.coeSubgraph G'').verts = Subtype.val '' G''.verts

full_name: SimpleGraph.Subgraph.coeSubgraph_adj
code: lemma coeSubgraph_adj {G' : G.Subgraph} (G'' : G'.coe.Subgraph) (v w : V) :
    (G'.coeSubgraph G'').Adj v w ↔
      ∃ (hv : v ∈ G'.verts) (hw : w ∈ G'.verts), G''.Adj ⟨v, hv⟩ ⟨w, hw⟩ 
goal: (SimpleGraph.Subgraph.coeSubgraph G'').Adj v w ↔ ∃ (hv : v ∈ G'.verts) (hw : w ∈ G'.verts), G''.Adj ⟨v, hv⟩ ⟨w, hw⟩

full_name: SimpleGraph.Subgraph.restrict_adj
code: lemma restrict_adj {G' G'' : G.Subgraph} (v w : G'.verts) :
    (G'.restrict G'').Adj v w ↔ G'.Adj v w ∧ G''.Adj v w 
goal: (SimpleGraph.Subgraph.restrict G'').Adj v w ↔ G'.Adj ↑v ↑w ∧ G''.Adj ↑v ↑w

full_name: SimpleGraph.Subgraph.restrict_coeSubgraph
code: theorem restrict_coeSubgraph {G' : G.Subgraph} (G'' : G'.coe.Subgraph) :
    Subgraph.restrict (Subgraph.coeSubgraph G'') = G'' 
goal: SimpleGraph.Subgraph.restrict (SimpleGraph.Subgraph.coeSubgraph G'') = G''

full_name: SimpleGraph.Subgraph.coeSubgraph_injective
code: theorem coeSubgraph_injective (G' : G.Subgraph) :
    Function.Injective (Subgraph.coeSubgraph : G'.coe.Subgraph → G.Subgraph) 
goal: Function.Injective SimpleGraph.Subgraph.coeSubgraph

full_name: SimpleGraph.Subgraph.coeSubgraph_le
code: lemma coeSubgraph_le {H : G.Subgraph} (H' : H.coe.Subgraph) :
    Subgraph.coeSubgraph H' ≤ H 
goal: SimpleGraph.Subgraph.coeSubgraph H' ≤ H

full_name: SimpleGraph.Subgraph.coeSubgraph_restrict_eq
code: lemma coeSubgraph_restrict_eq {H : G.Subgraph} (H' : G.Subgraph) :
    Subgraph.coeSubgraph (H.restrict H') = H ⊓ H' 
goal: SimpleGraph.Subgraph.coeSubgraph (SimpleGraph.Subgraph.restrict H') = H ⊓ H'

full_name: SimpleGraph.Subgraph.deleteEdges
code: /-- Given a subgraph `G'` and a set of vertex pairs, remove all of the corresponding edges
from its edge set, if present.

See also: `SimpleGraph.deleteEdges`. -/
def deleteEdges (G' : G.Subgraph) (s : Set (Sym2 V)) : G.Subgraph 
goal: G.Subgraph

full_name: SimpleGraph.Subgraph.deleteEdges_verts
code: @[simp]
theorem deleteEdges_verts : (G'.deleteEdges s).verts = G'.verts 
goal: (G'.deleteEdges s).verts = G'.verts

full_name: SimpleGraph.Subgraph.deleteEdges_adj
code: @[simp]
theorem deleteEdges_adj (v w : V) : (G'.deleteEdges s).Adj v w ↔ G'.Adj v w ∧ ¬s(v, w) ∈ s 
goal: (G'.deleteEdges s).Adj v w ↔ G'.Adj v w ∧ s(v, w) ∉ s

full_name: SimpleGraph.Subgraph.deleteEdges_deleteEdges
code: @[simp]
theorem deleteEdges_deleteEdges (s s' : Set (Sym2 V)) :
    (G'.deleteEdges s).deleteEdges s' = G'.deleteEdges (s ∪ s') 
goal: (G'.deleteEdges s).deleteEdges s' = G'.deleteEdges (s ∪ s')

full_name: SimpleGraph.Subgraph.deleteEdges_empty_eq
code: @[simp]
theorem deleteEdges_empty_eq : G'.deleteEdges ∅ = G' 
goal: G'.deleteEdges ∅ = G'

full_name: SimpleGraph.Subgraph.deleteEdges_spanningCoe_eq
code: @[simp]
theorem deleteEdges_spanningCoe_eq :
    G'.spanningCoe.deleteEdges s = (G'.deleteEdges s).spanningCoe 
goal: G'.spanningCoe.deleteEdges s = (G'.deleteEdges s).spanningCoe

full_name: SimpleGraph.Subgraph.deleteEdges_coe_eq
code: theorem deleteEdges_coe_eq (s : Set (Sym2 G'.verts)) :
    G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map (↑) '' s)).coe 
goal: G'.coe.deleteEdges s = (G'.deleteEdges (Sym2.map Subtype.val '' s)).coe

full_name: SimpleGraph.Subgraph.coe_deleteEdges_eq
code: theorem coe_deleteEdges_eq (s : Set (Sym2 V)) :
    (G'.deleteEdges s).coe = G'.coe.deleteEdges (Sym2.map (↑) ⁻¹' s) 
goal: (G'.deleteEdges s).coe = G'.coe.deleteEdges (Sym2.map Subtype.val ⁻¹' s)

full_name: SimpleGraph.Subgraph.deleteEdges_le
code: theorem deleteEdges_le : G'.deleteEdges s ≤ G' 
goal: G'.deleteEdges s ≤ G'

full_name: SimpleGraph.Subgraph.deleteEdges_le_of_le
code: theorem deleteEdges_le_of_le {s s' : Set (Sym2 V)} (h : s ⊆ s') :
    G'.deleteEdges s' ≤ G'.deleteEdges s 
goal: G'.deleteEdges s' ≤ G'.deleteEdges s

full_name: SimpleGraph.Subgraph.deleteEdges_inter_edgeSet_left_eq
code: @[simp]
theorem deleteEdges_inter_edgeSet_left_eq :
    G'.deleteEdges (G'.edgeSet ∩ s) = G'.deleteEdges s 
goal: G'.deleteEdges (G'.edgeSet ∩ s) = G'.deleteEdges s

full_name: SimpleGraph.Subgraph.deleteEdges_inter_edgeSet_right_eq
code: @[simp]
theorem deleteEdges_inter_edgeSet_right_eq :
    G'.deleteEdges (s ∩ G'.edgeSet) = G'.deleteEdges s 
goal: G'.deleteEdges (s ∩ G'.edgeSet) = G'.deleteEdges s

full_name: SimpleGraph.Subgraph.coe_deleteEdges_le
code: theorem coe_deleteEdges_le : (G'.deleteEdges s).coe ≤ (G'.coe : SimpleGraph G'.verts) 
goal: (G'.deleteEdges s).coe ≤ G'.coe

full_name: SimpleGraph.Subgraph.spanningCoe_deleteEdges_le
code: theorem spanningCoe_deleteEdges_le (G' : G.Subgraph) (s : Set (Sym2 V)) :
    (G'.deleteEdges s).spanningCoe ≤ G'.spanningCoe 
goal: (G'.deleteEdges s).spanningCoe ≤ G'.spanningCoe

full_name: SimpleGraph.Subgraph.induce_adj
code: /-- The induced subgraph of a subgraph. The expectation is that `s ⊆ G'.verts` for the usual
notion of an induced subgraph, but, in general, `s` is taken to be the new vertex set and edges
are induced from the subgraph `G'`. -/
@[simps]
def induce (G' : G.Subgraph) (s : Set V) : G.Subgraph 
goal: (G'.induce s).Adj u v = (u ∈ s ∧ v ∈ s ∧ G'.Adj u v)

full_name: SimpleGraph.Subgraph.induce_verts
code: /-- The induced subgraph of a subgraph. The expectation is that `s ⊆ G'.verts` for the usual
notion of an induced subgraph, but, in general, `s` is taken to be the new vertex set and edges
are induced from the subgraph `G'`. -/
@[simps]
def induce (G' : G.Subgraph) (s : Set V) : G.Subgraph 
goal: (G'.induce s).verts = s

full_name: SimpleGraph.Subgraph.induce
code: /-- The induced subgraph of a subgraph. The expectation is that `s ⊆ G'.verts` for the usual
notion of an induced subgraph, but, in general, `s` is taken to be the new vertex set and edges
are induced from the subgraph `G'`. -/
@[simps]
def induce (G' : G.Subgraph) (s : Set V) : G.Subgraph 
goal: G.Subgraph

full_name: SimpleGraph.induce_eq_coe_induce_top
code: theorem _root_.SimpleGraph.induce_eq_coe_induce_top (s : Set V) :
    G.induce s = ((⊤ : G.Subgraph).induce s).coe 
goal: SimpleGraph.induce s G = (⊤.induce s).coe

full_name: SimpleGraph.Subgraph.induce_mono
code: theorem induce_mono (hg : G' ≤ G'') (hs : s ⊆ s') : G'.induce s ≤ G''.induce s' 
goal: G'.induce s ≤ G''.induce s'

full_name: SimpleGraph.Subgraph.induce_mono_left
code: @[mono]
theorem induce_mono_left (hg : G' ≤ G'') : G'.induce s ≤ G''.induce s 
goal: G'.induce s ≤ G''.induce s

full_name: SimpleGraph.Subgraph.induce_mono_right
code: @[mono]
theorem induce_mono_right (hs : s ⊆ s') : G'.induce s ≤ G'.induce s' 
goal: G'.induce s ≤ G'.induce s'

full_name: SimpleGraph.Subgraph.induce_empty
code: @[simp]
theorem induce_empty : G'.induce ∅ = ⊥ 
goal: G'.induce ∅ = ⊥

full_name: SimpleGraph.Subgraph.induce_self_verts
code: @[simp]
theorem induce_self_verts : G'.induce G'.verts = G' 
goal: G'.induce G'.verts = G'

full_name: SimpleGraph.Subgraph.le_induce_top_verts
code: lemma le_induce_top_verts : G' ≤ (⊤ : G.Subgraph).induce G'.verts 
goal: G' ≤ ⊤.induce G'.verts

full_name: SimpleGraph.Subgraph.le_induce_union
code: lemma le_induce_union : G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s') 
goal: G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s')

full_name: SimpleGraph.Subgraph.le_induce_union_left
code: lemma le_induce_union_left : G'.induce s ≤ G'.induce (s ∪ s') 
goal: G'.induce s ≤ G'.induce (s ∪ s')

full_name: SimpleGraph.Subgraph.le_induce_union_right
code: lemma le_induce_union_right : G'.induce s' ≤ G'.induce (s ∪ s') 
goal: G'.induce s' ≤ G'.induce (s ∪ s')

full_name: SimpleGraph.Subgraph.singletonSubgraph_eq_induce
code: theorem singletonSubgraph_eq_induce {v : V} :
    G.singletonSubgraph v = (⊤ : G.Subgraph).induce {v} 
goal: G.singletonSubgraph v = ⊤.induce {v}

full_name: SimpleGraph.Subgraph.subgraphOfAdj_eq_induce
code: theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w} 
goal: G.subgraphOfAdj hvw = ⊤.induce {v, w}

full_name: SimpleGraph.Subgraph.deleteVerts
code: /-- Given a subgraph and a set of vertices, delete all the vertices from the subgraph,
if present. Any edges incident to the deleted vertices are deleted as well. -/
abbrev deleteVerts (G' : G.Subgraph) (s : Set V) : G.Subgraph 
goal: G.Subgraph

full_name: SimpleGraph.Subgraph.deleteVerts_verts
code: theorem deleteVerts_verts : (G'.deleteVerts s).verts = G'.verts \ s 
goal: (G'.deleteVerts s).verts = G'.verts \ s

full_name: SimpleGraph.Subgraph.deleteVerts_adj
code: theorem deleteVerts_adj {u v : V} :
    (G'.deleteVerts s).Adj u v ↔ u ∈ G'.verts ∧ ¬u ∈ s ∧ v ∈ G'.verts ∧ ¬v ∈ s ∧ G'.Adj u v 
goal: (G'.deleteVerts s).Adj u v ↔ u ∈ G'.verts ∧ u ∉ s ∧ v ∈ G'.verts ∧ v ∉ s ∧ G'.Adj u v

full_name: SimpleGraph.Subgraph.deleteVerts_deleteVerts
code: @[simp]
theorem deleteVerts_deleteVerts (s s' : Set V) :
    (G'.deleteVerts s).deleteVerts s' = G'.deleteVerts (s ∪ s') 
goal: (G'.deleteVerts s).deleteVerts s' = G'.deleteVerts (s ∪ s')

full_name: SimpleGraph.Subgraph.deleteVerts_empty
code: @[simp]
theorem deleteVerts_empty : G'.deleteVerts ∅ = G' 
goal: G'.deleteVerts ∅ = G'

full_name: SimpleGraph.Subgraph.deleteVerts_le
code: theorem deleteVerts_le : G'.deleteVerts s ≤ G' 
goal: G'.deleteVerts s ≤ G'

full_name: SimpleGraph.Subgraph.deleteVerts_mono
code: @[mono]
theorem deleteVerts_mono {G' G'' : G.Subgraph} (h : G' ≤ G'') :
    G'.deleteVerts s ≤ G''.deleteVerts s 
goal: G'.deleteVerts s ≤ G''.deleteVerts s

full_name: SimpleGraph.Subgraph.deleteVerts_anti
code: @[mono]
theorem deleteVerts_anti {s s' : Set V} (h : s ⊆ s') : G'.deleteVerts s' ≤ G'.deleteVerts s 
goal: G'.deleteVerts s' ≤ G'.deleteVerts s

full_name: SimpleGraph.Subgraph.deleteVerts_inter_verts_left_eq
code: @[simp]
theorem deleteVerts_inter_verts_left_eq : G'.deleteVerts (G'.verts ∩ s) = G'.deleteVerts s 
goal: G'.deleteVerts (G'.verts ∩ s) = G'.deleteVerts s

full_name: SimpleGraph.Subgraph.deleteVerts_inter_verts_set_right_eq
code: @[simp]
theorem deleteVerts_inter_verts_set_right_eq :
    G'.deleteVerts (s ∩ G'.verts) = G'.deleteVerts s 
goal: G'.deleteVerts (s ∩ G'.verts) = G'.deleteVerts s