File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

full_name: SimpleGraph.map
code: /-- Given an injective function, there is a covariant induced map on graphs by pushing forward
the adjacency relation.

This is injective (see `SimpleGraph.map_injective`). -/
protected def map (f : V ↪ W) (G : SimpleGraph V) : SimpleGraph W 
goal: SimpleGraph W

full_name: SimpleGraph.instDecidableMapAdj
code: instance instDecidableMapAdj {f : V ↪ W} {a b} [Decidable (Relation.Map G.Adj f f a b)] :
    Decidable ((G.map f).Adj a b) 
goal: Decidable ((SimpleGraph.map f G).Adj a b)

full_name: SimpleGraph.map_adj
code: @[simp]
theorem map_adj (f : V ↪ W) (G : SimpleGraph V) (u v : W) :
    (G.map f).Adj u v ↔ ∃ u' v' : V, G.Adj u' v' ∧ f u' = u ∧ f v' = v 
goal: (SimpleGraph.map f G).Adj u v ↔ ∃ u' v', G.Adj u' v' ∧ f u' = u ∧ f v' = v

full_name: SimpleGraph.map_adj_apply
code: lemma map_adj_apply {G : SimpleGraph V} {f : V ↪ W} {a b : V} :
    (G.map f).Adj (f a) (f b) ↔ G.Adj a b 
goal: (SimpleGraph.map f G).Adj (f a) (f b) ↔ G.Adj a b

full_name: SimpleGraph.map_monotone
code: theorem map_monotone (f : V ↪ W) : Monotone (SimpleGraph.map f) 
goal: Monotone (SimpleGraph.map f)

full_name: SimpleGraph.map_id
code: @[simp] lemma map_id : G.map (Function.Embedding.refl _) = G 
goal: SimpleGraph.map (Function.Embedding.refl V) G = G

full_name: SimpleGraph.map_map
code: @[simp] lemma map_map (f : V ↪ W) (g : W ↪ X) : (G.map f).map g = G.map (f.trans g) 
goal: SimpleGraph.map g (SimpleGraph.map f G) = SimpleGraph.map (f.trans g) G

full_name: SimpleGraph.comap
code: /-- Given a function, there is a contravariant induced map on graphs by pulling back the
adjacency relation.
This is one of the ways of creating induced graphs. See `SimpleGraph.induce` for a wrapper.

This is surjective when `f` is injective (see `SimpleGraph.comap_surjective`). -/
protected def comap (f : V → W) (G : SimpleGraph W) : SimpleGraph V 
goal: SimpleGraph V

full_name: SimpleGraph.comap_adj
code: @[simp] lemma comap_adj {G : SimpleGraph W} {f : V → W} :
    (G.comap f).Adj u v ↔ G.Adj (f u) (f v) 
goal: (SimpleGraph.comap f G).Adj u v ↔ G.Adj (f u) (f v)

full_name: SimpleGraph.comap_id
code: @[simp] lemma comap_id {G : SimpleGraph V} : G.comap id = G 
goal: SimpleGraph.comap id G = G

full_name: SimpleGraph.comap_comap
code: @[simp] lemma comap_comap {G : SimpleGraph X} (f : V → W) (g : W → X) :
  (G.comap g).comap f = G.comap (g ∘ f) 
goal: SimpleGraph.comap f (SimpleGraph.comap g G) = SimpleGraph.comap (g ∘ f) G

full_name: SimpleGraph.instDecidableComapAdj
code: instance instDecidableComapAdj (f : V → W) (G : SimpleGraph W) [DecidableRel G.Adj] :
    DecidableRel (G.comap f).Adj 
goal: DecidableRel (SimpleGraph.comap f G).Adj

full_name: SimpleGraph.comap_symm
code: lemma comap_symm (G : SimpleGraph V) (e : V ≃ W) :
    G.comap e.symm.toEmbedding = G.map e.toEmbedding 
goal: SimpleGraph.comap (⇑e.symm.toEmbedding) G = SimpleGraph.map e.toEmbedding G

full_name: SimpleGraph.map_symm
code: lemma map_symm (G : SimpleGraph W) (e : V ≃ W) :
    G.map e.symm.toEmbedding = G.comap e.toEmbedding 
goal: SimpleGraph.map e.symm.toEmbedding G = SimpleGraph.comap (⇑e.toEmbedding) G

full_name: SimpleGraph.comap_monotone
code: theorem comap_monotone (f : V ↪ W) : Monotone (SimpleGraph.comap f) 
goal: Monotone (SimpleGraph.comap ⇑f)

full_name: SimpleGraph.comap_map_eq
code: @[simp]
theorem comap_map_eq (f : V ↪ W) (G : SimpleGraph V) : (G.map f).comap f = G 
goal: SimpleGraph.comap (⇑f) (SimpleGraph.map f G) = G

full_name: SimpleGraph.leftInverse_comap_map
code: theorem leftInverse_comap_map (f : V ↪ W) :
    Function.LeftInverse (SimpleGraph.comap f) (SimpleGraph.map f) 
goal: Function.LeftInverse (SimpleGraph.comap ⇑f) (SimpleGraph.map f)

full_name: SimpleGraph.map_injective
code: theorem map_injective (f : V ↪ W) : Function.Injective (SimpleGraph.map f) 
goal: Function.Injective (SimpleGraph.map f)

full_name: SimpleGraph.comap_surjective
code: theorem comap_surjective (f : V ↪ W) : Function.Surjective (SimpleGraph.comap f) 
goal: Function.Surjective (SimpleGraph.comap ⇑f)

full_name: SimpleGraph.map_le_iff_le_comap
code: theorem map_le_iff_le_comap (f : V ↪ W) (G : SimpleGraph V) (G' : SimpleGraph W) :
    G.map f ≤ G' ↔ G ≤ G'.comap f 
goal: SimpleGraph.map f G ≤ G' ↔ G ≤ SimpleGraph.comap (⇑f) G'

full_name: SimpleGraph.map_comap_le
code: theorem map_comap_le (f : V ↪ W) (G : SimpleGraph W) : (G.comap f).map f ≤ G 
goal: SimpleGraph.map f (SimpleGraph.comap (⇑f) G) ≤ G

full_name: SimpleGraph.le_comap_of_subsingleton
code: lemma le_comap_of_subsingleton (f : V → W) [Subsingleton V] : G ≤ G'.comap f 
goal: G ≤ SimpleGraph.comap f G'

full_name: SimpleGraph.map_le_of_subsingleton
code: lemma map_le_of_subsingleton (f : V ↪ W) [Subsingleton V] : G.map f ≤ G' 
goal: SimpleGraph.map f G ≤ G'

full_name: SimpleGraph.completeMultipartiteGraph
code: /-- Given a family of vertex types indexed by `ι`, pulling back from `⊤ : SimpleGraph ι`
yields the complete multipartite graph on the family.
Two vertices are adjacent if and only if their indices are not equal. -/
abbrev completeMultipartiteGraph {ι : Type*} (V : ι → Type*) : SimpleGraph (Σ i, V i) 
goal: SimpleGraph ((i : ι) × V i)

full_name: Equiv.simpleGraph
code: /-- Equivalent types have equivalent simple graphs. -/
@[simps apply]
protected def _root_.Equiv.simpleGraph (e : V ≃ W) : SimpleGraph V ≃ SimpleGraph W 
goal: SimpleGraph V ≃ SimpleGraph W

full_name: Equiv.simpleGraph_apply
code: /-- Equivalent types have equivalent simple graphs. -/
@[simps apply]
protected def _root_.Equiv.simpleGraph (e : V ≃ W) : SimpleGraph V ≃ SimpleGraph W 
goal: e.simpleGraph G = SimpleGraph.comap (⇑e.symm) G

full_name: Equiv.simpleGraph_refl
code: @[simp] lemma _root_.Equiv.simpleGraph_refl : (Equiv.refl V).simpleGraph = Equiv.refl _ 
goal: (Equiv.refl V).simpleGraph = Equiv.refl (SimpleGraph V)

full_name: Equiv.simpleGraph_trans
code: @[simp] lemma _root_.Equiv.simpleGraph_trans (e₁ : V ≃ W) (e₂ : W ≃ X) :
  (e₁.trans e₂).simpleGraph = e₁.simpleGraph.trans e₂.simpleGraph 
goal: (e₁.trans e₂).simpleGraph = e₁.simpleGraph.trans e₂.simpleGraph

full_name: Equiv.symm_simpleGraph
code: @[simp]
lemma _root_.Equiv.symm_simpleGraph (e : V ≃ W) : e.simpleGraph.symm = e.symm.simpleGraph 
goal: e.simpleGraph.symm = e.symm.simpleGraph

full_name: SimpleGraph.induce
code: /-- Restrict a graph to the vertices in the set `s`, deleting all edges incident to vertices
outside the set. This is a wrapper around `SimpleGraph.comap`. -/
abbrev induce (s : Set V) (G : SimpleGraph V) : SimpleGraph s 
goal: SimpleGraph ↑s

full_name: SimpleGraph.induce_singleton_eq_top
code: @[simp] lemma induce_singleton_eq_top (v : V) : G.induce {v} = ⊤ 
goal: SimpleGraph.induce {v} G = ⊤

full_name: SimpleGraph.spanningCoe
code: /-- Given a graph on a set of vertices, we can make it be a `SimpleGraph V` by
adding in the remaining vertices without adding in any additional edges.
This is a wrapper around `SimpleGraph.map`. -/
abbrev spanningCoe {s : Set V} (G : SimpleGraph s) : SimpleGraph V 
goal: SimpleGraph V

full_name: SimpleGraph.induce_spanningCoe
code: theorem induce_spanningCoe {s : Set V} {G : SimpleGraph s} : G.spanningCoe.induce s = G 
goal: SimpleGraph.induce s G.spanningCoe = G

full_name: SimpleGraph.spanningCoe_induce_le
code: theorem spanningCoe_induce_le (s : Set V) : (G.induce s).spanningCoe ≤ G 
goal: (SimpleGraph.induce s G).spanningCoe ≤ G

full_name: SimpleGraph.Hom
code: /-- A graph homomorphism is a map on vertex sets that respects adjacency relations.

The notation `G →g G'` represents the type of graph homomorphisms. -/
abbrev Hom 
goal: Type (max u_1 u_2)

full_name: SimpleGraph.Embedding
code: /-- A graph embedding is an embedding `f` such that for vertices `v w : V`,
`G.Adj (f v) (f w) ↔ G.Adj v w`. Its image is an induced subgraph of G'.

The notation `G ↪g G'` represents the type of graph embeddings. -/
abbrev Embedding 
goal: Type (max u_1 u_2)

full_name: SimpleGraph.Iso
code: /-- A graph isomorphism is a bijective map on vertex sets that respects adjacency relations.

The notation `G ≃g G'` represents the type of graph isomorphisms.
-/
abbrev Iso 
goal: Type (max u_1 u_2)

full_name: SimpleGraph.«_aux_Mathlib_Combinatorics_SimpleGraph_Maps___macroRules_SimpleGraph_term_→g__1»
code: @[inherit_doc] infixl:50 " →g " => Hom
goal: Lean.Macro

full_name: SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Maps___unexpand_SimpleGraph_Hom_1
code: @[inherit_doc] infixl:50 " →g " => Hom
goal: Lean.PrettyPrinter.Unexpander

full_name: SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Maps___unexpand_SimpleGraph_Embedding_1
code: @[inherit_doc] infixl:50 " ↪g " => Embedding
goal: Lean.PrettyPrinter.Unexpander

full_name: SimpleGraph.«_aux_Mathlib_Combinatorics_SimpleGraph_Maps___macroRules_SimpleGraph_term_↪g__1»
code: @[inherit_doc] infixl:50 " ↪g " => Embedding
goal: Lean.Macro

full_name: SimpleGraph.«_aux_Mathlib_Combinatorics_SimpleGraph_Maps___macroRules_SimpleGraph_term_≃g__1»
code: @[inherit_doc] infixl:50 " ≃g " => Iso
goal: Lean.Macro

full_name: SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Maps___unexpand_SimpleGraph_Iso_1
code: @[inherit_doc] infixl:50 " ≃g " => Iso
goal: Lean.PrettyPrinter.Unexpander

full_name: SimpleGraph.Hom.id
code: /-- The identity homomorphism from a graph to itself. -/
protected abbrev id : G →g G 
goal: G →g G

full_name: SimpleGraph.Hom.coe_id
code: @[simp, norm_cast] lemma coe_id : ⇑(Hom.id : G →g G) = id 
goal: ⇑SimpleGraph.Hom.id = id

full_name: SimpleGraph.Hom.instSubsingletonOfForall
code: instance [Subsingleton (V → W)] : Subsingleton (G →g H) 
goal: Subsingleton (G →g H)

full_name: SimpleGraph.Hom.instUniqueOfIsEmpty
code: instance [IsEmpty V] : Unique (G →g H) 
goal: Unique (G →g H)

full_name: SimpleGraph.Hom.instFintype
code: instance instFintype [DecidableEq V] [Fintype V] [Fintype W] [DecidableRel G.Adj]
    [DecidableRel H.Adj] : Fintype (G →g H) 
goal: Fintype (G →g H)

full_name: SimpleGraph.Hom.instFinite
code: instance [Finite V] [Finite W] : Finite (G →g H) 
goal: Finite (G →g H)

full_name: SimpleGraph.Hom.map_adj
code: theorem map_adj {v w : V} (h : G.Adj v w) : G'.Adj (f v) (f w) 
goal: G'.Adj (f v) (f w)

full_name: SimpleGraph.Hom.map_mem_edgeSet
code: theorem map_mem_edgeSet {e : Sym2 V} (h : e ∈ G.edgeSet) : e.map f ∈ G'.edgeSet 
goal: Sym2.map (⇑f) e ∈ G'.edgeSet

full_name: SimpleGraph.Hom.apply_mem_neighborSet
code: theorem apply_mem_neighborSet {v w : V} (h : w ∈ G.neighborSet v) : f w ∈ G'.neighborSet (f v) 
goal: f w ∈ G'.neighborSet (f v)

full_name: SimpleGraph.Hom.mapEdgeSet_coe
code: /-- The map between edge sets induced by a homomorphism.
The underlying map on edges is given by `Sym2.map`. -/
@[simps]
def mapEdgeSet (e : G.edgeSet) : G'.edgeSet 
goal: ↑(f.mapEdgeSet e) = Sym2.map ⇑f ↑e

full_name: SimpleGraph.Hom.mapEdgeSet
code: /-- The map between edge sets induced by a homomorphism.
The underlying map on edges is given by `Sym2.map`. -/
@[simps]
def mapEdgeSet (e : G.edgeSet) : G'.edgeSet 
goal: ↑G'.edgeSet

full_name: SimpleGraph.Hom.mapNeighborSet_coe
code: /-- The map between neighbor sets induced by a homomorphism. -/
@[simps]
def mapNeighborSet (v : V) (w : G.neighborSet v) : G'.neighborSet (f v) 
goal: ↑(f.mapNeighborSet v w) = f ↑w

full_name: SimpleGraph.Hom.mapNeighborSet
code: /-- The map between neighbor sets induced by a homomorphism. -/
@[simps]
def mapNeighborSet (v : V) (w : G.neighborSet v) : G'.neighborSet (f v) 
goal: ↑(G'.neighborSet (f v))

full_name: SimpleGraph.Hom.mapDart
code: /-- The map between darts induced by a homomorphism. -/
def mapDart (d : G.Dart) : G'.Dart 
goal: G'.Dart

full_name: SimpleGraph.Hom.mapDart_apply
code: @[simp]
theorem mapDart_apply (d : G.Dart) : f.mapDart d = ⟨d.1.map f f, f.map_adj d.2⟩ 
goal: f.mapDart d = { toProd := Prod.map (⇑f) (⇑f) d.toProd, adj := ⋯ }

full_name: SimpleGraph.Hom.mapSpanningSubgraphs_apply
code: /-- The induced map for spanning subgraphs, which is the identity on vertices. -/
@[simps]
def mapSpanningSubgraphs {G G' : SimpleGraph V} (h : G ≤ G') : G →g G' 
goal: (SimpleGraph.Hom.mapSpanningSubgraphs h) x = x

full_name: SimpleGraph.Hom.mapSpanningSubgraphs
code: /-- The induced map for spanning subgraphs, which is the identity on vertices. -/
@[simps]
def mapSpanningSubgraphs {G G' : SimpleGraph V} (h : G ≤ G') : G →g G' 
goal: G →g G'

full_name: SimpleGraph.Hom.mapEdgeSet.injective
code: theorem mapEdgeSet.injective (hinj : Function.Injective f) : Function.Injective f.mapEdgeSet 
goal: Function.Injective f.mapEdgeSet

full_name: SimpleGraph.Hom.injective_of_top_hom
code: /-- Every graph homomorphism from a complete graph is injective. -/
theorem injective_of_top_hom (f : (⊤ : SimpleGraph V) →g G') : Function.Injective f 
goal: Function.Injective ⇑f

full_name: SimpleGraph.Hom.comap
code: /-- There is a homomorphism to a graph from a comapped graph.
When the function is injective, this is an embedding (see `SimpleGraph.Embedding.comap`). -/
@[simps]
protected def comap (f : V → W) (G : SimpleGraph W) : G.comap f →g G 
goal: SimpleGraph.comap f G →g G

full_name: SimpleGraph.Hom.comap_apply
code: /-- There is a homomorphism to a graph from a comapped graph.
When the function is injective, this is an embedding (see `SimpleGraph.Embedding.comap`). -/
@[simps]
protected def comap (f : V → W) (G : SimpleGraph W) : G.comap f →g G 
goal: ∀ (a : V), (SimpleGraph.Hom.comap f G) a = f a

full_name: SimpleGraph.Hom.comp
code: /-- Composition of graph homomorphisms. -/
abbrev comp (f' : G' →g G'') (f : G →g G') : G →g G'' 
goal: G →g G''

full_name: SimpleGraph.Hom.coe_comp
code: @[simp]
theorem coe_comp (f' : G' →g G'') (f : G →g G') : ⇑(f'.comp f) = f' ∘ f 
goal: ⇑(f'.comp f) = ⇑f' ∘ ⇑f

full_name: SimpleGraph.Hom.ofLE
code: /-- The graph homomorphism from a smaller graph to a bigger one. -/
def ofLE (h : G₁ ≤ G₂) : G₁ →g G₂ 
goal: G₁ →g G₂

full_name: SimpleGraph.Hom.coe_ofLE
code: @[simp, norm_cast] lemma coe_ofLE (h : G₁ ≤ G₂) : ⇑(ofLE h) = id 
goal: ⇑(SimpleGraph.Hom.ofLE h) = id

full_name: SimpleGraph.Embedding.refl
code: /-- The identity embedding from a graph to itself. -/
abbrev refl : G ↪g G 
goal: G ↪g G

full_name: SimpleGraph.Embedding.toHom
code: /-- An embedding of graphs gives rise to a homomorphism of graphs. -/
abbrev toHom : G →g G' 
goal: G →g G'

full_name: SimpleGraph.Embedding.coe_toHom
code: @[simp] lemma coe_toHom (f : G ↪g H) : ⇑f.toHom = f 
goal: ⇑f.toHom = ⇑f

full_name: SimpleGraph.Embedding.map_adj_iff
code: @[simp] theorem map_adj_iff {v w : V} : G'.Adj (f v) (f w) ↔ G.Adj v w 
goal: G'.Adj (f v) (f w) ↔ G.Adj v w

full_name: SimpleGraph.Embedding.map_mem_edgeSet_iff
code: theorem map_mem_edgeSet_iff {e : Sym2 V} : e.map f ∈ G'.edgeSet ↔ e ∈ G.edgeSet 
goal: Sym2.map (⇑f) e ∈ G'.edgeSet ↔ e ∈ G.edgeSet

full_name: SimpleGraph.Embedding.apply_mem_neighborSet_iff
code: theorem apply_mem_neighborSet_iff {v w : V} : f w ∈ G'.neighborSet (f v) ↔ w ∈ G.neighborSet v 
goal: f w ∈ G'.neighborSet (f v) ↔ w ∈ G.neighborSet v

full_name: SimpleGraph.Embedding.mapEdgeSet_apply
code: /-- A graph embedding induces an embedding of edge sets. -/
@[simps]
def mapEdgeSet : G.edgeSet ↪ G'.edgeSet 
goal: f.mapEdgeSet e = SimpleGraph.Hom.mapEdgeSet (RelEmbedding.toRelHom f) e

full_name: SimpleGraph.Embedding.mapEdgeSet
code: /-- A graph embedding induces an embedding of edge sets. -/
@[simps]
def mapEdgeSet : G.edgeSet ↪ G'.edgeSet 
goal: ↑G.edgeSet ↪ ↑G'.edgeSet

full_name: SimpleGraph.Embedding.mapNeighborSet
code: /-- A graph embedding induces an embedding of neighbor sets. -/
@[simps]
def mapNeighborSet (v : V) : G.neighborSet v ↪ G'.neighborSet (f v) 
goal: ↑(G.neighborSet v) ↪ ↑(G'.neighborSet (f v))

full_name: SimpleGraph.Embedding.mapNeighborSet_apply_coe
code: /-- A graph embedding induces an embedding of neighbor sets. -/
@[simps]
def mapNeighborSet (v : V) : G.neighborSet v ↪ G'.neighborSet (f v) 
goal: ↑((f.mapNeighborSet v) w) = f ↑w

full_name: SimpleGraph.Embedding.comap
code: /-- Given an injective function, there is an embedding from the comapped graph into the original
graph. -/
-- Porting note: @[simps] does not work here since `f` is not a constructor application.
-- `@[simps toEmbedding]` could work, but Floris suggested writing `comap_apply` for now.
protected def comap (f : V ↪ W) (G : SimpleGraph W) : G.comap f ↪g G 
goal: SimpleGraph.comap (⇑f) G ↪g G

full_name: SimpleGraph.Embedding.comap_apply
code: @[simp]
theorem comap_apply (f : V ↪ W) (G : SimpleGraph W) (v : V) :
    SimpleGraph.Embedding.comap f G v = f v 
goal: (SimpleGraph.Embedding.comap f G) v = f v

full_name: SimpleGraph.Embedding.map
code: /-- Given an injective function, there is an embedding from a graph into the mapped graph. -/
-- Porting note: @[simps] does not work here since `f` is not a constructor application.
-- `@[simps toEmbedding]` could work, but Floris suggested writing `map_apply` for now.
protected def map (f : V ↪ W) (G : SimpleGraph V) : G ↪g G.map f 
goal: G ↪g SimpleGraph.map f G

full_name: SimpleGraph.Embedding.map_apply
code: @[simp]
theorem map_apply (f : V ↪ W) (G : SimpleGraph V) (v : V) :
    SimpleGraph.Embedding.map f G v = f v 
goal: (SimpleGraph.Embedding.map f G) v = f v

full_name: SimpleGraph.Embedding.induce
code: /-- Induced graphs embed in the original graph.

Note that if `G.induce s = ⊤` (i.e., if `s` is a clique) then this gives the embedding of a
complete graph. -/
protected abbrev induce (s : Set V) : G.induce s ↪g G 
goal: SimpleGraph.induce s G ↪g G

full_name: SimpleGraph.Embedding.spanningCoe
code: /-- Graphs on a set of vertices embed in their `spanningCoe`. -/
protected abbrev spanningCoe {s : Set V} (G : SimpleGraph s) : G ↪g G.spanningCoe 
goal: G ↪g G.spanningCoe

full_name: SimpleGraph.Embedding.completeGraph
code: /-- Embeddings of types induce embeddings of complete graphs on those types. -/
protected def completeGraph {α β : Type*} (f : α ↪ β) :
    (⊤ : SimpleGraph α) ↪g (⊤ : SimpleGraph β) 
goal: ⊤ ↪g ⊤

full_name: SimpleGraph.Embedding.coe_completeGraph
code: @[simp] lemma coe_completeGraph {α β : Type*} (f : α ↪ β) : ⇑(Embedding.completeGraph f) = f 
goal: ⇑(SimpleGraph.Embedding.completeGraph f) = ⇑f

full_name: SimpleGraph.Embedding.comp
code: /-- Composition of graph embeddings. -/
abbrev comp (f' : G' ↪g G'') (f : G ↪g G') : G ↪g G'' 
goal: G ↪g G''

full_name: SimpleGraph.Embedding.coe_comp
code: @[simp]
theorem coe_comp (f' : G' ↪g G'') (f : G ↪g G') : ⇑(f'.comp f) = f' ∘ f 
goal: ⇑(f'.comp f) = ⇑f' ∘ ⇑f

full_name: SimpleGraph.induceHom
code: /-- The restriction of a morphism of graphs to induced subgraphs. -/
def induceHom : G.induce s →g G'.induce t 
goal: SimpleGraph.induce s G →g SimpleGraph.induce t G'

full_name: SimpleGraph.coe_induceHom
code: @[simp, norm_cast] lemma coe_induceHom : ⇑(induceHom φ φst) = Set.MapsTo.restrict φ s t φst 
goal: ⇑(SimpleGraph.induceHom φ φst) = Set.MapsTo.restrict (⇑φ) s t φst

full_name: SimpleGraph.induceHom_id
code: @[simp] lemma induceHom_id (G : SimpleGraph V) (s) :
    induceHom (Hom.id : G →g G) (Set.mapsTo_id s) = Hom.id 
goal: SimpleGraph.induceHom SimpleGraph.Hom.id ⋯ = SimpleGraph.Hom.id

full_name: SimpleGraph.induceHom_comp
code: @[simp] lemma induceHom_comp :
    (induceHom ψ ψtr).comp (induceHom φ φst) = induceHom (ψ.comp φ) (ψtr.comp φst) 
goal: (SimpleGraph.induceHom ψ ψtr).comp (SimpleGraph.induceHom φ φst) = SimpleGraph.induceHom (ψ.comp φ) ⋯

full_name: SimpleGraph.induceHom_injective
code: lemma induceHom_injective (hi : Set.InjOn φ s) :
    Function.Injective (induceHom φ φst) 
goal: Function.Injective ⇑(SimpleGraph.induceHom φ φst)

full_name: SimpleGraph.induceHomOfLE
code: /-- Given an inclusion of vertex subsets, the induced embedding on induced graphs.
This is not an abbreviation for `induceHom` since we get an embedding in this case. -/
def induceHomOfLE (h : s ≤ s') : G.induce s ↪g G.induce s' 
goal: SimpleGraph.induce s G ↪g SimpleGraph.induce s' G

full_name: SimpleGraph.induceHomOfLE_apply
code: @[simp] lemma induceHomOfLE_apply (v : s) : (G.induceHomOfLE h) v = Set.inclusion h v 
goal: (G.induceHomOfLE h) v = Set.inclusion h v

full_name: SimpleGraph.induceHomOfLE_toHom
code: @[simp] lemma induceHomOfLE_toHom :
    (G.induceHomOfLE h).toHom = induceHom (.id : G →g G) ((Set.mapsTo_id s).mono_right h) 
goal: (G.induceHomOfLE h).toHom = SimpleGraph.induceHom SimpleGraph.Hom.id ⋯

full_name: SimpleGraph.Iso.refl
code: /-- The identity isomorphism of a graph with itself. -/
abbrev refl : G ≃g G 
goal: G ≃g G

full_name: SimpleGraph.Iso.toEmbedding
code: /-- An isomorphism of graphs gives rise to an embedding of graphs. -/
abbrev toEmbedding : G ↪g G' 
goal: G ↪g G'

full_name: SimpleGraph.Iso.toHom
code: /-- An isomorphism of graphs gives rise to a homomorphism of graphs. -/
abbrev toHom : G →g G' 
goal: G →g G'

full_name: SimpleGraph.Iso.symm
code: /-- The inverse of a graph isomorphism. -/
abbrev symm : G' ≃g G 
goal: G' ≃g G

full_name: SimpleGraph.Iso.map_adj_iff
code: theorem map_adj_iff {v w : V} : G'.Adj (f v) (f w) ↔ G.Adj v w 
goal: G'.Adj (f v) (f w) ↔ G.Adj v w

full_name: SimpleGraph.Iso.map_mem_edgeSet_iff
code: theorem map_mem_edgeSet_iff {e : Sym2 V} : e.map f ∈ G'.edgeSet ↔ e ∈ G.edgeSet 
goal: Sym2.map (⇑f) e ∈ G'.edgeSet ↔ e ∈ G.edgeSet

full_name: SimpleGraph.Iso.apply_mem_neighborSet_iff
code: theorem apply_mem_neighborSet_iff {v w : V} : f w ∈ G'.neighborSet (f v) ↔ w ∈ G.neighborSet v 
goal: f w ∈ G'.neighborSet (f v) ↔ w ∈ G.neighborSet v

full_name: SimpleGraph.Iso.mapEdgeSet_symm_apply
code: /-- An isomorphism of graphs induces an equivalence of edge sets. -/
@[simps]
def mapEdgeSet : G.edgeSet ≃ G'.edgeSet 
goal: f.mapEdgeSet.symm e = SimpleGraph.Hom.mapEdgeSet (RelIso.toRelEmbedding f.symm).toRelHom e

full_name: SimpleGraph.Iso.mapEdgeSet
code: /-- An isomorphism of graphs induces an equivalence of edge sets. -/
@[simps]
def mapEdgeSet : G.edgeSet ≃ G'.edgeSet 
goal: ↑G.edgeSet ≃ ↑G'.edgeSet

full_name: SimpleGraph.Iso.mapEdgeSet_apply
code: /-- An isomorphism of graphs induces an equivalence of edge sets. -/
@[simps]
def mapEdgeSet : G.edgeSet ≃ G'.edgeSet 
goal: f.mapEdgeSet e = SimpleGraph.Hom.mapEdgeSet (RelIso.toRelEmbedding f).toRelHom e

full_name: SimpleGraph.Iso.mapNeighborSet
code: /-- A graph isomorphism induces an equivalence of neighbor sets. -/
@[simps]
def mapNeighborSet (v : V) : G.neighborSet v ≃ G'.neighborSet (f v) 
goal: ↑(G.neighborSet v) ≃ ↑(G'.neighborSet (f v))

full_name: SimpleGraph.Iso.mapNeighborSet_symm_apply_coe
code: /-- A graph isomorphism induces an equivalence of neighbor sets. -/
@[simps]
def mapNeighborSet (v : V) : G.neighborSet v ≃ G'.neighborSet (f v) 
goal: ↑((f.mapNeighborSet v).symm w) = f.symm ↑w

full_name: SimpleGraph.Iso.mapNeighborSet_apply_coe
code: /-- A graph isomorphism induces an equivalence of neighbor sets. -/
@[simps]
def mapNeighborSet (v : V) : G.neighborSet v ≃ G'.neighborSet (f v) 
goal: ↑((f.mapNeighborSet v) w) = f ↑w

full_name: SimpleGraph.Iso.card_eq
code: theorem card_eq [Fintype V] [Fintype W] : Fintype.card V = Fintype.card W 
goal: Fintype.card V = Fintype.card W

full_name: SimpleGraph.Iso.comap
code: /-- Given a bijection, there is an embedding from the comapped graph into the original
graph. -/
-- Porting note: `@[simps]` does not work here anymore since `f` is not a constructor application.
-- `@[simps toEmbedding]` could work, but Floris suggested writing `comap_apply` for now.
protected def comap (f : V ≃ W) (G : SimpleGraph W) : G.comap f.toEmbedding ≃g G 
goal: SimpleGraph.comap (⇑f.toEmbedding) G ≃g G

full_name: SimpleGraph.Iso.comap_apply
code: @[simp]
lemma comap_apply (f : V ≃ W) (G : SimpleGraph W) (v : V) :
    SimpleGraph.Iso.comap f G v = f v 
goal: (SimpleGraph.Iso.comap f G) v = f v

full_name: SimpleGraph.Iso.comap_symm_apply
code: @[simp]
lemma comap_symm_apply (f : V ≃ W) (G : SimpleGraph W) (w : W) :
    (SimpleGraph.Iso.comap f G).symm w = f.symm w 
goal: (SimpleGraph.Iso.comap f G).symm w = f.symm w

full_name: SimpleGraph.Iso.map
code: /-- Given an injective function, there is an embedding from a graph into the mapped graph. -/
-- Porting note: `@[simps]` does not work here anymore since `f` is not a constructor application.
-- `@[simps toEmbedding]` could work, but Floris suggested writing `map_apply` for now.
protected def map (f : V ≃ W) (G : SimpleGraph V) : G ≃g G.map f.toEmbedding 
goal: G ≃g SimpleGraph.map f.toEmbedding G

full_name: SimpleGraph.Iso.map_apply
code: @[simp]
lemma map_apply (f : V ≃ W) (G : SimpleGraph V) (v : V) :
    SimpleGraph.Iso.map f G v = f v 
goal: (SimpleGraph.Iso.map f G) v = f v

full_name: SimpleGraph.Iso.map_symm_apply
code: @[simp]
lemma map_symm_apply (f : V ≃ W) (G : SimpleGraph V) (w : W) :
    (SimpleGraph.Iso.map f G).symm w = f.symm w 
goal: (SimpleGraph.Iso.map f G).symm w = f.symm w

full_name: SimpleGraph.Iso.completeGraph
code: /-- Equivalences of types induce isomorphisms of complete graphs on those types. -/
protected def completeGraph {α β : Type*} (f : α ≃ β) :
    (⊤ : SimpleGraph α) ≃g (⊤ : SimpleGraph β) 
goal: ⊤ ≃g ⊤

full_name: SimpleGraph.Iso.toEmbedding_completeGraph
code: theorem toEmbedding_completeGraph {α β : Type*} (f : α ≃ β) :
    (Iso.completeGraph f).toEmbedding = Embedding.completeGraph f.toEmbedding 
goal: (SimpleGraph.Iso.completeGraph f).toEmbedding = SimpleGraph.Embedding.completeGraph f.toEmbedding

full_name: SimpleGraph.Iso.comp
code: /-- Composition of graph isomorphisms. -/
abbrev comp (f' : G' ≃g G'') (f : G ≃g G') : G ≃g G'' 
goal: G ≃g G''

full_name: SimpleGraph.Iso.coe_comp
code: @[simp]
theorem coe_comp (f' : G' ≃g G'') (f : G ≃g G') : ⇑(f'.comp f) = f' ∘ f 
goal: ⇑(f'.comp f) = ⇑f' ∘ ⇑f

full_name: SimpleGraph.induceUnivIso
code: /-- The graph induced on `Set.univ` is isomorphic to the original graph. -/
@[simps!]
def induceUnivIso (G : SimpleGraph V) : G.induce Set.univ ≃g G 
goal: SimpleGraph.induce Set.univ G ≃g G

full_name: SimpleGraph.induceUnivIso_symm_apply_coe
code: /-- The graph induced on `Set.univ` is isomorphic to the original graph. -/
@[simps!]
def induceUnivIso (G : SimpleGraph V) : G.induce Set.univ ≃g G 
goal: ↑((RelIso.symm G.induceUnivIso) a) = a

full_name: SimpleGraph.induceUnivIso_apply
code: /-- The graph induced on `Set.univ` is isomorphic to the original graph. -/
@[simps!]
def induceUnivIso (G : SimpleGraph V) : G.induce Set.univ ≃g G 
goal: G.induceUnivIso self = ↑self

full_name: SimpleGraph.overFin
code: /-- Given a graph over a finite vertex type `V` and a proof `hc` that `Fintype.card V = n`,
`G.overFin n` is an isomorphic (as shown in `overFinIso`) graph over `Fin n`. -/
def overFin (hc : Fintype.card V = n) : SimpleGraph (Fin n) 
goal: SimpleGraph (Fin n)

full_name: SimpleGraph.overFinIso
code: /-- The isomorphism between `G` and `G.overFin hc`. -/
noncomputable def overFinIso (hc : Fintype.card V = n) : G ≃g G.overFin hc 
goal: G ≃g G.overFin hc