File: Mathlib/Logic/Embedding/Basic.lean

full_name: Function.Embedding.toFun
code: /-- `α ↪ β` is a bundled injective function. -/
structure Embedding (α : Sort*) (β : Sort*) where
  /-- An embedding as a function. Use coercion instead. -/
  toFun : α → β
  /-- An embedding is an injective function. Use `Function.Embedding.injective` instead. -/
  inj' : Injective toFun
goal: α → β

full_name: Function.Embedding.inj'
code: /-- `α ↪ β` is a bundled injective function. -/
structure Embedding (α : Sort*) (β : Sort*) where
  /-- An embedding as a function. Use coercion instead. -/
  toFun : α → β
  /-- An embedding is an injective function. Use `Function.Embedding.injective` instead. -/
  inj' : Injective toFun
goal: Function.Injective self.toFun

full_name: Function.Embedding
code: /-- `α ↪ β` is a bundled injective function. -/
structure Embedding (α : Sort*) (β : Sort*) where
  /-- An embedding as a function. Use coercion instead. -/
  toFun : α → β
  /-- An embedding is an injective function. Use `Function.Embedding.injective` instead. -/
  inj' : Injective toFun
goal: Sort (max (max 1 u_1) u_2)

full_name: Function._aux_Mathlib_Logic_Embedding_Basic___unexpand_Function_Embedding_1
code: /-- An embedding, a.k.a. a bundled injective function. -/
infixr:25 " ↪ " => Embedding
goal: Lean.PrettyPrinter.Unexpander

full_name: Function.«_aux_Mathlib_Logic_Embedding_Basic___macroRules_Function_term_↪__1»
code: /-- An embedding, a.k.a. a bundled injective function. -/
infixr:25 " ↪ " => Embedding
goal: Lean.Macro

full_name: Function.instFunLikeEmbedding
code: instance {α : Sort u} {β : Sort v} : FunLike (α ↪ β) α β 
goal: FunLike (α ↪ β) α β

full_name: Function.instEmbeddingLikeEmbedding
code: instance {α : Sort u} {β : Sort v} : EmbeddingLike (α ↪ β) α β 
goal: EmbeddingLike (α ↪ β) α β

full_name: Function.exists_surjective_iff
code: theorem exists_surjective_iff {α β : Sort*} :
    (∃ f : α → β, Surjective f) ↔ Nonempty (α → β) ∧ Nonempty (β ↪ α) 
goal: (∃ f, Function.Surjective f) ↔ Nonempty (α → β) ∧ Nonempty (β ↪ α)

full_name: Function.instCanLiftForallEmbeddingCoeInjective
code: instance {α β : Sort*} : CanLift (α → β) (α ↪ β) (↑) Injective 
goal: CanLift (α → β) (α ↪ β) DFunLike.coe Function.Injective

full_name: Equiv.toEmbedding
code: /-- Convert an `α ≃ β` to `α ↪ β`.

This is also available as a coercion `Equiv.coeEmbedding`.
The explicit `Equiv.toEmbedding` version is preferred though, since the coercion can have issues
inferring the type of the resulting embedding. For example:

```lean
-- Works:
example (s : Finset (Fin 3)) (f : Equiv.Perm (Fin 3)) : s.map f.toEmbedding = s.map f := by simp
-- Error, `f` has type `Fin 3 ≃ Fin 3` but is expected to have type `Fin 3 ↪ ?m_1 : Type ?`
example (s : Finset (Fin 3)) (f : Equiv.Perm (Fin 3)) : s.map f = s.map f.toEmbedding := by simp
```
-/
protected def Equiv.toEmbedding : α ↪ β 
goal: α ↪ β

full_name: Equiv.coe_toEmbedding
code: @[simp]
theorem Equiv.coe_toEmbedding : (f.toEmbedding : α → β) = f 
goal: ⇑f.toEmbedding = ⇑f

full_name: Equiv.toEmbedding_apply
code: theorem Equiv.toEmbedding_apply (a : α) : f.toEmbedding a = f a 
goal: f.toEmbedding a = f a

full_name: Equiv.toEmbedding_injective
code: theorem Equiv.toEmbedding_injective : Function.Injective (Equiv.toEmbedding : (α ≃ β) → (α ↪ β)) 
goal: Function.Injective Equiv.toEmbedding

full_name: Equiv.coeEmbedding
code: instance Equiv.coeEmbedding : Coe (α ≃ β) (α ↪ β) 
goal: Coe (α ≃ β) (α ↪ β)

full_name: Equiv.Perm.coeEmbedding
code: @[instance] abbrev Equiv.Perm.coeEmbedding : Coe (Equiv.Perm α) (α ↪ α) 
goal: Coe (Equiv.Perm α) (α ↪ α)

full_name: Function.Embedding.coe_injective
code: theorem coe_injective {α β} : @Injective (α ↪ β) (α → β) (fun f ↦ ↑f) 
goal: Function.Injective fun f => ⇑f

full_name: Function.Embedding.ext
code: @[ext]
theorem ext {α β} {f g : Embedding α β} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: Function.Embedding.instUniqueOfIsEmpty
code: instance {α β : Sort*} [IsEmpty α] : Unique (α ↪ β) 
goal: Unique (α ↪ β)

full_name: Function.Embedding.ext_iff
code: theorem ext_iff {α β} {f g : Embedding α β} : (∀ x, f x = g x) ↔ f = g 
goal: (∀ (x : α), f x = g x) ↔ f = g

full_name: Function.Embedding.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe {α β} (f : α ↪ β) : toFun f = f 
goal: f.toFun = ⇑f

full_name: Function.Embedding.coeFn_mk
code: @[simp]
theorem coeFn_mk {α β} (f : α → β) (i) : (@mk _ _ f i : α → β) = f 
goal: ⇑{ toFun := f, inj' := i } = f

full_name: Function.Embedding.mk_coe
code: @[simp]
theorem mk_coe {α β : Type*} (f : α ↪ β) (inj) : (⟨f, inj⟩ : α ↪ β) = f 
goal: { toFun := ⇑f, inj' := inj } = f

full_name: Function.Embedding.injective
code: protected theorem injective {α β} (f : α ↪ β) : Injective f 
goal: Function.Injective ⇑f

full_name: Function.Embedding.apply_eq_iff_eq
code: theorem apply_eq_iff_eq {α β} (f : α ↪ β) (x y : α) : f x = f y ↔ x = y 
goal: f x = f y ↔ x = y

full_name: Function.Embedding.refl
code: /-- The identity map as a `Function.Embedding`. -/
@[refl, simps (config := { simpRhs := true })]
protected def refl (α : Sort*) : α ↪ α 
goal: α ↪ α

full_name: Function.Embedding.refl_apply
code: /-- The identity map as a `Function.Embedding`. -/
@[refl, simps (config := { simpRhs := true })]
protected def refl (α : Sort*) : α ↪ α 
goal: (Function.Embedding.refl α) a = a

full_name: Function.Embedding.trans_apply
code: /-- Composition of `f : α ↪ β` and `g : β ↪ γ`. -/
@[trans, simps (config := { simpRhs := true })]
protected def trans {α β γ} (f : α ↪ β) (g : β ↪ γ) : α ↪ γ 
goal: ∀ (a : α), (f.trans g) a = g (f a)

full_name: Function.Embedding.trans
code: /-- Composition of `f : α ↪ β` and `g : β ↪ γ`. -/
@[trans, simps (config := { simpRhs := true })]
protected def trans {α β γ} (f : α ↪ β) (g : β ↪ γ) : α ↪ γ 
goal: α ↪ γ

full_name: Function.Embedding.instTrans
code: instance : Trans Embedding Embedding Embedding 
goal: Trans Function.Embedding Function.Embedding Function.Embedding

full_name: Function.Embedding.equiv_toEmbedding_trans_symm_toEmbedding
code: @[simp]
theorem equiv_toEmbedding_trans_symm_toEmbedding {α β : Sort*} (e : α ≃ β) :
    e.toEmbedding.trans e.symm.toEmbedding = Embedding.refl _ 
goal: e.toEmbedding.trans e.symm.toEmbedding = Function.Embedding.refl α

full_name: Function.Embedding.equiv_symm_toEmbedding_trans_toEmbedding
code: @[simp]
theorem equiv_symm_toEmbedding_trans_toEmbedding {α β : Sort*} (e : α ≃ β) :
    e.symm.toEmbedding.trans e.toEmbedding = Embedding.refl _ 
goal: e.symm.toEmbedding.trans e.toEmbedding = Function.Embedding.refl β

full_name: Function.Embedding.congr_apply
code: /-- Transfer an embedding along a pair of equivalences. -/
@[simps! (config := { fullyApplied := false, simpRhs := true })]
protected def congr {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort x} (e₁ : α ≃ β) (e₂ : γ ≃ δ)
    (f : α ↪ γ) : β ↪ δ 
goal: ⇑(Function.Embedding.congr e₁ e₂ f) = ⇑(f.trans e₂.toEmbedding) ∘ ⇑e₁.symm

full_name: Function.Embedding.congr
code: /-- Transfer an embedding along a pair of equivalences. -/
@[simps! (config := { fullyApplied := false, simpRhs := true })]
protected def congr {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort x} (e₁ : α ≃ β) (e₂ : γ ≃ δ)
    (f : α ↪ γ) : β ↪ δ 
goal: β ↪ δ

full_name: Function.Embedding.ofSurjective
code: /-- A right inverse `surjInv` of a surjective function as an `Embedding`. -/
protected noncomputable def ofSurjective {α β} (f : β → α) (hf : Surjective f) : α ↪ β 
goal: α ↪ β

full_name: Function.Embedding.equivOfSurjective
code: /-- Convert a surjective `Embedding` to an `Equiv` -/
protected noncomputable def equivOfSurjective {α β} (f : α ↪ β) (hf : Surjective f) : α ≃ β 
goal: α ≃ β

full_name: Function.Embedding.ofIsEmpty
code: /-- There is always an embedding from an empty type. -/
protected def ofIsEmpty {α β} [IsEmpty α] : α ↪ β 
goal: α ↪ β

full_name: Function.Embedding.setValue
code: /-- Change the value of an embedding `f` at one point. If the prescribed image
is already occupied by some `f a'`, then swap the values at these two points. -/
def setValue {α β : Sort*} (f : α ↪ β) (a : α) (b : β) [∀ a', Decidable (a' = a)]
    [∀ a', Decidable (f a' = b)] : α ↪ β 
goal: α ↪ β

full_name: Function.Embedding.setValue_eq
code: @[simp]
theorem setValue_eq {α β} (f : α ↪ β) (a : α) (b : β) [∀ a', Decidable (a' = a)]
    [∀ a', Decidable (f a' = b)] : setValue f a b a = b 
goal: (f.setValue a b) a = b

full_name: Function.Embedding.setValue_eq_iff
code: @[simp]
theorem setValue_eq_iff {α β} (f : α ↪ β) {a a' : α} {b : β} [∀ a', Decidable (a' = a)]
    [∀ a', Decidable (f a' = b)] : setValue f a b a' = b ↔ a' = a 
goal: (f.setValue a b) a' = b ↔ a' = a

full_name: Function.Embedding.some
code: /-- Embedding into `Option α` using `some`. -/
@[simps (config := .asFn)]
protected def some {α} : α ↪ Option α 
goal: α ↪ Option α

full_name: Function.Embedding.some_apply
code: /-- Embedding into `Option α` using `some`. -/
@[simps (config := .asFn)]
protected def some {α} : α ↪ Option α 
goal: ⇑Function.Embedding.some = some

full_name: Function.Embedding.optionMap
code: /-- A version of `Option.map` for `Function.Embedding`s. -/
@[simps (config := .asFn)]
def optionMap {α β} (f : α ↪ β) : Option α ↪ Option β 
goal: Option α ↪ Option β

full_name: Function.Embedding.optionMap_apply
code: /-- A version of `Option.map` for `Function.Embedding`s. -/
@[simps (config := .asFn)]
def optionMap {α β} (f : α ↪ β) : Option α ↪ Option β 
goal: ⇑f.optionMap = Option.map ⇑f

full_name: Function.Embedding.subtype
code: /-- Embedding of a `Subtype`. -/
def subtype {α} (p : α → Prop) : Subtype p ↪ α 
goal: Subtype p ↪ α

full_name: Function.Embedding.coe_subtype
code: @[simp]
theorem coe_subtype {α} (p : α → Prop) : ↑(subtype p) = Subtype.val 
goal: ⇑(Function.Embedding.subtype p) = Subtype.val

full_name: Function.Embedding.quotientOut
code: /-- `Quotient.out` as an embedding. -/
noncomputable def quotientOut (α) [s : Setoid α] : Quotient s ↪ α 
goal: Quotient s ↪ α

full_name: Function.Embedding.coe_quotientOut
code: @[simp]
theorem coe_quotientOut (α) [Setoid α] : ↑(quotientOut α) = Quotient.out 
goal: ⇑(Function.Embedding.quotientOut α) = Quotient.out

full_name: Function.Embedding.punit
code: /-- Choosing an element `b : β` gives an embedding of `PUnit` into `β`. -/
def punit {β : Sort*} (b : β) : PUnit ↪ β 
goal: PUnit.{u_2} ↪ β

full_name: Function.Embedding.sectl_apply
code: /-- Fixing an element `b : β` gives an embedding `α ↪ α × β`. -/
@[simps]
def sectl (α : Sort _) {β : Sort _} (b : β) : α ↪ α × β 
goal: (Function.Embedding.sectl α b) a = (a, b)

full_name: Function.Embedding.sectl
code: /-- Fixing an element `b : β` gives an embedding `α ↪ α × β`. -/
@[simps]
def sectl (α : Sort _) {β : Sort _} (b : β) : α ↪ α × β 
goal: α ↪ α × β

full_name: Function.Embedding.sectr_apply
code: /-- Fixing an element `a : α` gives an embedding `β ↪ α × β`. -/
@[simps]
def sectr {α : Sort _} (a : α) (β : Sort _) : β ↪ α × β 
goal: (Function.Embedding.sectr a β) b = (a, b)

full_name: Function.Embedding.sectr
code: /-- Fixing an element `a : α` gives an embedding `β ↪ α × β`. -/
@[simps]
def sectr {α : Sort _} (a : α) (β : Sort _) : β ↪ α × β 
goal: β ↪ α × β

full_name: Function.Embedding.prodMap
code: /-- If `e₁` and `e₂` are embeddings, then so is `Prod.map e₁ e₂ : (a, b) ↦ (e₁ a, e₂ b)`. -/
def prodMap {α β γ δ : Type*} (e₁ : α ↪ β) (e₂ : γ ↪ δ) : α × γ ↪ β × δ 
goal: α × γ ↪ β × δ

full_name: Function.Embedding.coe_prodMap
code: @[simp]
theorem coe_prodMap {α β γ δ : Type*} (e₁ : α ↪ β) (e₂ : γ ↪ δ) :
    e₁.prodMap e₂ = Prod.map e₁ e₂ 
goal: ⇑(e₁.prodMap e₂) = Prod.map ⇑e₁ ⇑e₂

full_name: Function.Embedding.pprodMap
code: /-- If `e₁` and `e₂` are embeddings,
  then so is `fun ⟨a, b⟩ ↦ ⟨e₁ a, e₂ b⟩ : PProd α γ → PProd β δ`. -/
def pprodMap {α β γ δ : Sort*} (e₁ : α ↪ β) (e₂ : γ ↪ δ) : PProd α γ ↪ PProd β δ 
goal: PProd α γ ↪ PProd β δ

full_name: Function.Embedding.sumMap
code: /-- If `e₁` and `e₂` are embeddings, then so is `Sum.map e₁ e₂`. -/
def sumMap {α β γ δ : Type*} (e₁ : α ↪ β) (e₂ : γ ↪ δ) : α ⊕ γ ↪ β ⊕ δ 
goal: α ⊕ γ ↪ β ⊕ δ

full_name: Function.Embedding.coe_sumMap
code: @[simp]
theorem coe_sumMap {α β γ δ} (e₁ : α ↪ β) (e₂ : γ ↪ δ) : sumMap e₁ e₂ = Sum.map e₁ e₂ 
goal: ⇑(e₁.sumMap e₂) = Sum.map ⇑e₁ ⇑e₂

full_name: Function.Embedding.inl
code: /-- The embedding of `α` into the sum `α ⊕ β`. -/
@[simps]
def inl {α β : Type*} : α ↪ α ⊕ β 
goal: α ↪ α ⊕ β

full_name: Function.Embedding.inl_apply
code: /-- The embedding of `α` into the sum `α ⊕ β`. -/
@[simps]
def inl {α β : Type*} : α ↪ α ⊕ β 
goal: Function.Embedding.inl val = Sum.inl val

full_name: Function.Embedding.inr
code: /-- The embedding of `β` into the sum `α ⊕ β`. -/
@[simps]
def inr {α β : Type*} : β ↪ α ⊕ β 
goal: β ↪ α ⊕ β

full_name: Function.Embedding.inr_apply
code: /-- The embedding of `β` into the sum `α ⊕ β`. -/
@[simps]
def inr {α β : Type*} : β ↪ α ⊕ β 
goal: Function.Embedding.inr val = Sum.inr val

full_name: Function.Embedding.sigmaMk_apply
code: /-- `Sigma.mk` as a `Function.Embedding`. -/
@[simps apply]
def sigmaMk (a : α) : β a ↪ Σx, β x 
goal: (Function.Embedding.sigmaMk a) snd = ⟨a, snd⟩

full_name: Function.Embedding.sigmaMk
code: /-- `Sigma.mk` as a `Function.Embedding`. -/
@[simps apply]
def sigmaMk (a : α) : β a ↪ Σx, β x 
goal: β a ↪ (x : α) × β x

full_name: Function.Embedding.sigmaMap
code: /-- If `f : α ↪ α'` is an embedding and `g : Π a, β α ↪ β' (f α)` is a family
of embeddings, then `Sigma.map f g` is an embedding. -/
@[simps apply]
def sigmaMap (f : α ↪ α') (g : ∀ a, β a ↪ β' (f a)) : (Σa, β a) ↪ Σa', β' a' 
goal: (a : α) × β a ↪ (a' : α') × β' a'

full_name: Function.Embedding.sigmaMap_apply
code: /-- If `f : α ↪ α'` is an embedding and `g : Π a, β α ↪ β' (f α)` is a family
of embeddings, then `Sigma.map f g` is an embedding. -/
@[simps apply]
def sigmaMap (f : α ↪ α') (g : ∀ a, β a ↪ β' (f a)) : (Σa, β a) ↪ Σa', β' a' 
goal: (f.sigmaMap g) x = Sigma.map (⇑f) (fun a => ⇑(g a)) x

full_name: Function.Embedding.piCongrRight
code: /-- Define an embedding `(Π a : α, β a) ↪ (Π a : α, γ a)` from a family of embeddings
`e : Π a, (β a ↪ γ a)`. This embedding sends `f` to `fun a ↦ e a (f a)`. -/
@[simps]
def piCongrRight {α : Sort*} {β γ : α → Sort*} (e : ∀ a, β a ↪ γ a) : (∀ a, β a) ↪ ∀ a, γ a 
goal: ((a : α) → β a) ↪ (a : α) → γ a

full_name: Function.Embedding.piCongrRight_apply
code: /-- Define an embedding `(Π a : α, β a) ↪ (Π a : α, γ a)` from a family of embeddings
`e : Π a, (β a ↪ γ a)`. This embedding sends `f` to `fun a ↦ e a (f a)`. -/
@[simps]
def piCongrRight {α : Sort*} {β γ : α → Sort*} (e : ∀ a, β a ↪ γ a) : (∀ a, β a) ↪ ∀ a, γ a 
goal: (Function.Embedding.piCongrRight e) f a = (e a) (f a)

full_name: Function.Embedding.arrowCongrRight
code: /-- An embedding `e : α ↪ β` defines an embedding `(γ → α) ↪ (γ → β)` that sends each `f`
to `e ∘ f`. -/
def arrowCongrRight {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ↪ β) : (γ → α) ↪ γ → β 
goal: (γ → α) ↪ γ → β

full_name: Function.Embedding.arrowCongrRight_apply
code: @[simp]
theorem arrowCongrRight_apply {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ↪ β) (f : γ → α) :
    arrowCongrRight e f = e ∘ f 
goal: e.arrowCongrRight f = ⇑e ∘ f

full_name: Function.Embedding.arrowCongrLeft
code: /-- An embedding `e : α ↪ β` defines an embedding `(α → γ) ↪ (β → γ)` for any inhabited type `γ`.
This embedding sends each `f : α → γ` to a function `g : β → γ` such that `g ∘ e = f` and
`g y = default` whenever `y ∉ range e`. -/
noncomputable def arrowCongrLeft {α : Sort u} {β : Sort v} {γ : Sort w} [Inhabited γ] (e : α ↪ β) :
    (α → γ) ↪ β → γ 
goal: (α → γ) ↪ β → γ

full_name: Function.Embedding.subtypeMap
code: /-- Restrict both domain and codomain of an embedding. -/
protected def subtypeMap {α β} {p : α → Prop} {q : β → Prop} (f : α ↪ β)
    (h : ∀ ⦃x⦄, p x → q (f x)) :
    { x : α // p x } ↪ { y : β // q y } 
goal: { x // p x } ↪ { y // q y }

full_name: Function.Embedding.swap_apply
code: theorem swap_apply {α β : Type*} [DecidableEq α] [DecidableEq β] (f : α ↪ β) (x y z : α) :
    Equiv.swap (f x) (f y) (f z) = f (Equiv.swap x y z) 
goal: (Equiv.swap (f x) (f y)) (f z) = f ((Equiv.swap x y) z)

full_name: Function.Embedding.swap_comp
code: theorem swap_comp {α β : Type*} [DecidableEq α] [DecidableEq β] (f : α ↪ β) (x y : α) :
    Equiv.swap (f x) (f y) ∘ f = f ∘ Equiv.swap x y 
goal: ⇑(Equiv.swap (f x) (f y)) ∘ ⇑f = ⇑f ∘ ⇑(Equiv.swap x y)

full_name: Equiv.asEmbedding
code: /-- Given an equivalence to a subtype, produce an embedding to the elements of the corresponding
set. -/
@[simps!]
def asEmbedding {β α : Sort*} {p : β → Prop} (e : α ≃ Subtype p) : α ↪ β 
goal: α ↪ β

full_name: Equiv.asEmbedding_apply
code: /-- Given an equivalence to a subtype, produce an embedding to the elements of the corresponding
set. -/
@[simps!]
def asEmbedding {β α : Sort*} {p : β → Prop} (e : α ≃ Subtype p) : α ↪ β 
goal: ∀ (a : α), e.asEmbedding a = ↑(e a)

full_name: Equiv.subtypeInjectiveEquivEmbedding
code: /-- The type of embeddings `α ↪ β` is equivalent to
    the subtype of all injective functions `α → β`. -/
def subtypeInjectiveEquivEmbedding (α β : Sort*) :
    { f : α → β // Injective f } ≃ (α ↪ β) 
goal: { f // Function.Injective f } ≃ (α ↪ β)

full_name: Equiv.embeddingCongr_apply
code: /-- If `α₁ ≃ α₂` and `β₁ ≃ β₂`, then the type of embeddings `α₁ ↪ β₁`
is equivalent to the type of embeddings `α₂ ↪ β₂`. -/
@[simps apply]
def embeddingCongr {α β γ δ : Sort*} (h : α ≃ β) (h' : γ ≃ δ) : (α ↪ γ) ≃ (β ↪ δ) 
goal: (h.embeddingCongr h') f = Function.Embedding.congr h h' f

full_name: Equiv.embeddingCongr
code: /-- If `α₁ ≃ α₂` and `β₁ ≃ β₂`, then the type of embeddings `α₁ ↪ β₁`
is equivalent to the type of embeddings `α₂ ↪ β₂`. -/
@[simps apply]
def embeddingCongr {α β γ δ : Sort*} (h : α ≃ β) (h' : γ ≃ δ) : (α ↪ γ) ≃ (β ↪ δ) 
goal: (α ↪ γ) ≃ (β ↪ δ)

full_name: Equiv.embeddingCongr_refl
code: @[simp]
theorem embeddingCongr_refl {α β : Sort*} :
    embeddingCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α ↪ β) 
goal: (Equiv.refl α).embeddingCongr (Equiv.refl β) = Equiv.refl (α ↪ β)

full_name: Equiv.embeddingCongr_trans
code: @[simp]
theorem embeddingCongr_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Sort*} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂)
    (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
    embeddingCongr (e₁.trans e₂) (e₁'.trans e₂') =
      (embeddingCongr e₁ e₁').trans (embeddingCongr e₂ e₂') 
goal: (e₁.trans e₂).embeddingCongr (e₁'.trans e₂') = (e₁.embeddingCongr e₁').trans (e₂.embeddingCongr e₂')

full_name: Equiv.embeddingCongr_symm
code: @[simp]
theorem embeddingCongr_symm {α₁ β₁ α₂ β₂ : Sort*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
    (embeddingCongr e₁ e₂).symm = embeddingCongr e₁.symm e₂.symm 
goal: (e₁.embeddingCongr e₂).symm = e₁.symm.embeddingCongr e₂.symm

full_name: Equiv.embeddingCongr_apply_trans
code: theorem embeddingCongr_apply_trans {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
    (ec : γ₁ ≃ γ₂) (f : α₁ ↪ β₁) (g : β₁ ↪ γ₁) :
    Equiv.embeddingCongr ea ec (f.trans g) =
      (Equiv.embeddingCongr ea eb f).trans (Equiv.embeddingCongr eb ec g) 
goal: (ea.embeddingCongr ec) (f.trans g) = ((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)

full_name: Equiv.refl_toEmbedding
code: @[simp]
theorem refl_toEmbedding {α : Type*} : (Equiv.refl α).toEmbedding = Embedding.refl α 
goal: (Equiv.refl α).toEmbedding = Function.Embedding.refl α

full_name: Equiv.trans_toEmbedding
code: @[simp]
theorem trans_toEmbedding {α β γ : Type*} (e : α ≃ β) (f : β ≃ γ) :
    (e.trans f).toEmbedding = e.toEmbedding.trans f.toEmbedding 
goal: (e.trans f).toEmbedding = e.toEmbedding.trans f.toEmbedding

full_name: subtypeOrLeftEmbedding
code: /-- A subtype `{x // p x ∨ q x}` over a disjunction of `p q : α → Prop` can be injectively split
into a sum of subtypes `{x // p x} ⊕ {x // q x}` such that `¬ p x` is sent to the right. -/
def subtypeOrLeftEmbedding (p q : α → Prop) [DecidablePred p] :
    { x // p x ∨ q x } ↪ { x // p x } ⊕ { x // q x } 
goal: { x // p x ∨ q x } ↪ { x // p x } ⊕ { x // q x }

full_name: subtypeOrLeftEmbedding_apply_left
code: theorem subtypeOrLeftEmbedding_apply_left {p q : α → Prop} [DecidablePred p]
    (x : { x // p x ∨ q x }) (hx : p x) :
    subtypeOrLeftEmbedding p q x = Sum.inl ⟨x, hx⟩ 
goal: (subtypeOrLeftEmbedding p q) x = Sum.inl ⟨↑x, hx⟩

full_name: subtypeOrLeftEmbedding_apply_right
code: theorem subtypeOrLeftEmbedding_apply_right {p q : α → Prop} [DecidablePred p]
    (x : { x // p x ∨ q x }) (hx : ¬p x) :
    subtypeOrLeftEmbedding p q x = Sum.inr ⟨x, x.prop.resolve_left hx⟩ 
goal: (subtypeOrLeftEmbedding p q) x = Sum.inr ⟨↑x, ⋯⟩

full_name: Subtype.impEmbedding_apply_coe
code: /-- A subtype `{x // p x}` can be injectively sent to into a subtype `{x // q x}`,
if `p x → q x` for all `x : α`. -/
@[simps]
def Subtype.impEmbedding (p q : α → Prop) (h : ∀ x, p x → q x) : { x // p x } ↪ { x // q x } 
goal: ↑((Subtype.impEmbedding p q h) x) = ↑x

full_name: Subtype.impEmbedding
code: /-- A subtype `{x // p x}` can be injectively sent to into a subtype `{x // q x}`,
if `p x → q x` for all `x : α`. -/
@[simps]
def Subtype.impEmbedding (p q : α → Prop) (h : ∀ x, p x → q x) : { x // p x } ↪ { x // q x } 
goal: { x // p x } ↪ { x // q x }