File: Mathlib/Logic/Equiv/PartialEquiv.lean

full_name: mfld_cfg
code: /-- Common `@[simps]` configuration options used for manifold-related declarations. -/
def mfld_cfg : Simps.Config 
goal: Simps.Config

full_name: Tactic.MfldSetTac._aux_Mathlib_Logic_Equiv_PartialEquiv___elabRules_Tactic_MfldSetTac_mfldSetTac_1
code: /-- A very basic tactic to show that sets showing up in manifolds coincide or are included
in one another. -/
elab (name := mfldSetTac) "mfld_set_tac" : tactic => withMainContext do
  let g ← getMainGoal
  let goalTy := (← instantiateMVars (← g.getDecl).type).getAppFnArgs
  match goalTy with
  | (``Eq, #[_ty, _e₁, _e₂]) =>
    evalTactic (← `(tactic| (
      apply Set.ext; intro my_y
      constructor <;>
        · intro h_my_y
          try simp only [*, mfld_simps] at h_my_y
          try simp only [*, mfld_simps])))
  | (``Subset, #[_ty, _inst, _e₁, _e₂]) =>
    evalTactic (← `(tactic| (
      intro my_y h_my_y
      try simp only [*, mfld_simps] at h_my_y
      try simp only [*, mfld_simps])))
  | _ => throwError "goal should be an equality or an inclusion"
goal: Lean.Elab.Tactic.Tactic

full_name: Tactic.MfldSetTac.mfldSetTac
code: /-- A very basic tactic to show that sets showing up in manifolds coincide or are included
in one another. -/
elab (name := mfldSetTac) "mfld_set_tac" : tactic => withMainContext do
  let g ← getMainGoal
  let goalTy := (← instantiateMVars (← g.getDecl).type).getAppFnArgs
  match goalTy with
  | (``Eq, #[_ty, _e₁, _e₂]) =>
    evalTactic (← `(tactic| (
      apply Set.ext; intro my_y
      constructor <;>
        · intro h_my_y
          try simp only [*, mfld_simps] at h_my_y
          try simp only [*, mfld_simps])))
  | (``Subset, #[_ty, _inst, _e₁, _e₂]) =>
    evalTactic (← `(tactic| (
      intro my_y h_my_y
      try simp only [*, mfld_simps] at h_my_y
      try simp only [*, mfld_simps])))
  | _ => throwError "goal should be an equality or an inclusion"
goal: Lean.ParserDescr

full_name: PartialEquiv.map_target'
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: x ∈ self.target → self.invFun x ∈ self.source

full_name: PartialEquiv.source
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: Set α

full_name: PartialEquiv.invFun
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: β → α

full_name: PartialEquiv
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: Type (max u_5 u_6)

full_name: PartialEquiv.right_inv'
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: x ∈ self.target → ↑self (self.invFun x) = x

full_name: PartialEquiv.target
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: Set β

full_name: PartialEquiv.left_inv'
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: x ∈ self.source → self.invFun (↑self x) = x

full_name: PartialEquiv.toFun
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: α → β

full_name: PartialEquiv.map_source'
code: /-- Local equivalence between subsets `source` and `target` of `α` and `β` respectively. The
(global) maps `toFun : α → β` and `invFun : β → α` map `source` to `target` and conversely, and are
inverse to each other there. The values of `toFun` outside of `source` and of `invFun` outside of
`target` are irrelevant. -/
structure PartialEquiv (α : Type*) (β : Type*) where
  /-- The global function which has a partial inverse. Its value outside of the `source` subset is
  irrelevant. -/
  toFun : α → β
  /-- The partial inverse to `toFun`. Its value outside of the `target` subset is irrelevant. -/
  invFun : β → α
  /-- The domain of the partial equivalence. -/
  source : Set α
  /-- The codomain of the partial equivalence. -/
  target : Set β
  /-- The proposition that elements of `source` are mapped to elements of `target`. -/
  map_source' : ∀ ⦃x⦄, x ∈ source → toFun x ∈ target
  /-- The proposition that elements of `target` are mapped to elements of `source`. -/
  map_target' : ∀ ⦃x⦄, x ∈ target → invFun x ∈ source
  /-- The proposition that `invFun` is a left-inverse of `toFun` on `source`. -/
  left_inv' : ∀ ⦃x⦄, x ∈ source → invFun (toFun x) = x
  /-- The proposition that `invFun` is a right-inverse of `toFun` on `target`. -/
  right_inv' : ∀ ⦃x⦄, x ∈ target → toFun (invFun x) = x
goal: x ∈ self.source → ↑self x ∈ self.target

full_name: PartialEquiv.instInhabited
code: instance [Inhabited α] [Inhabited β] : Inhabited (PartialEquiv α β) 
goal: Inhabited (PartialEquiv α β)

full_name: PartialEquiv.symm
code: /-- The inverse of a partial equivalence -/
@[symm]
protected def symm : PartialEquiv β α 
goal: PartialEquiv β α

full_name: PartialEquiv.instCoeFunForall
code: instance : CoeFun (PartialEquiv α β) fun _ => α → β 
goal: CoeFun (PartialEquiv α β) fun x => α → β

full_name: PartialEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (e : PartialEquiv α β) : β → α 
goal: β → α

full_name: PartialEquiv.coe_symm_mk
code: @[simp, mfld_simps]
theorem coe_symm_mk (f : α → β) (g s t ml mr il ir) :
    ((PartialEquiv.mk f g s t ml mr il ir).symm : β → α) = g 
goal: ↑{ toFun := f, invFun := g, source := s, target := t, map_source' := ml, map_target' := mr, left_inv' := il,
        right_inv' := ir }.symm =
  g

full_name: PartialEquiv.invFun_as_coe
code: @[simp, mfld_simps]
theorem invFun_as_coe : e.invFun = e.symm 
goal: e.invFun = ↑e.symm

full_name: PartialEquiv.map_source
code: @[simp, mfld_simps]
theorem map_source {x : α} (h : x ∈ e.source) : e x ∈ e.target 
goal: ↑e x ∈ e.target

full_name: PartialEquiv.map_source''
code: /-- Variant of `e.map_source` and `map_source'`, stated for images of subsets of `source`. -/
lemma map_source'' : e '' e.source ⊆ e.target 
goal: ↑e '' e.source ⊆ e.target

full_name: PartialEquiv.map_target
code: @[simp, mfld_simps]
theorem map_target {x : β} (h : x ∈ e.target) : e.symm x ∈ e.source 
goal: ↑e.symm x ∈ e.source

full_name: PartialEquiv.left_inv
code: @[simp, mfld_simps]
theorem left_inv {x : α} (h : x ∈ e.source) : e.symm (e x) = x 
goal: ↑e.symm (↑e x) = x

full_name: PartialEquiv.right_inv
code: @[simp, mfld_simps]
theorem right_inv {x : β} (h : x ∈ e.target) : e (e.symm x) = x 
goal: ↑e (↑e.symm x) = x

full_name: PartialEquiv.eq_symm_apply
code: theorem eq_symm_apply {x : α} {y : β} (hx : x ∈ e.source) (hy : y ∈ e.target) :
    x = e.symm y ↔ e x = y 
goal: x = ↑e.symm y ↔ ↑e x = y

full_name: PartialEquiv.mapsTo
code: protected theorem mapsTo : MapsTo e e.source e.target 
goal: Set.MapsTo (↑e) e.source e.target

full_name: PartialEquiv.symm_mapsTo
code: theorem symm_mapsTo : MapsTo e.symm e.target e.source 
goal: Set.MapsTo (↑e.symm) e.target e.source

full_name: PartialEquiv.leftInvOn
code: protected theorem leftInvOn : LeftInvOn e.symm e e.source 
goal: Set.LeftInvOn (↑e.symm) (↑e) e.source

full_name: PartialEquiv.rightInvOn
code: protected theorem rightInvOn : RightInvOn e.symm e e.target 
goal: Set.RightInvOn (↑e.symm) (↑e) e.target

full_name: PartialEquiv.invOn
code: protected theorem invOn : InvOn e.symm e e.source e.target 
goal: Set.InvOn (↑e.symm) (↑e) e.source e.target

full_name: PartialEquiv.injOn
code: protected theorem injOn : InjOn e e.source 
goal: Set.InjOn (↑e) e.source

full_name: PartialEquiv.bijOn
code: protected theorem bijOn : BijOn e e.source e.target 
goal: Set.BijOn (↑e) e.source e.target

full_name: PartialEquiv.surjOn
code: protected theorem surjOn : SurjOn e e.source e.target 
goal: Set.SurjOn (↑e) e.source e.target

full_name: Equiv.toPartialEquivOfImageEq
code: /-- Interpret an `Equiv` as a `PartialEquiv` by restricting it to `s` in the domain
and to `t` in the codomain. -/
@[simps (config := .asFn)]
def _root_.Equiv.toPartialEquivOfImageEq (e : α ≃ β) (s : Set α) (t : Set β) (h : e '' s = t) :
    PartialEquiv α β 
goal: PartialEquiv α β

full_name: Equiv.toPartialEquivOfImageEq_target
code: /-- Interpret an `Equiv` as a `PartialEquiv` by restricting it to `s` in the domain
and to `t` in the codomain. -/
@[simps (config := .asFn)]
def _root_.Equiv.toPartialEquivOfImageEq (e : α ≃ β) (s : Set α) (t : Set β) (h : e '' s = t) :
    PartialEquiv α β 
goal: (e.toPartialEquivOfImageEq s t h).target = t

full_name: Equiv.toPartialEquivOfImageEq_symm_apply
code: /-- Interpret an `Equiv` as a `PartialEquiv` by restricting it to `s` in the domain
and to `t` in the codomain. -/
@[simps (config := .asFn)]
def _root_.Equiv.toPartialEquivOfImageEq (e : α ≃ β) (s : Set α) (t : Set β) (h : e '' s = t) :
    PartialEquiv α β 
goal: ↑(e.toPartialEquivOfImageEq s t h).symm = ⇑e.symm

full_name: Equiv.toPartialEquivOfImageEq_apply
code: /-- Interpret an `Equiv` as a `PartialEquiv` by restricting it to `s` in the domain
and to `t` in the codomain. -/
@[simps (config := .asFn)]
def _root_.Equiv.toPartialEquivOfImageEq (e : α ≃ β) (s : Set α) (t : Set β) (h : e '' s = t) :
    PartialEquiv α β 
goal: ↑(e.toPartialEquivOfImageEq s t h) = ⇑e

full_name: Equiv.toPartialEquivOfImageEq_source
code: /-- Interpret an `Equiv` as a `PartialEquiv` by restricting it to `s` in the domain
and to `t` in the codomain. -/
@[simps (config := .asFn)]
def _root_.Equiv.toPartialEquivOfImageEq (e : α ≃ β) (s : Set α) (t : Set β) (h : e '' s = t) :
    PartialEquiv α β 
goal: (e.toPartialEquivOfImageEq s t h).source = s

full_name: Equiv.toPartialEquiv
code: /-- Associate a `PartialEquiv` to an `Equiv`. -/
@[simps! (config := mfld_cfg)]
def _root_.Equiv.toPartialEquiv (e : α ≃ β) : PartialEquiv α β 
goal: PartialEquiv α β

full_name: Equiv.toPartialEquiv_symm_apply
code: /-- Associate a `PartialEquiv` to an `Equiv`. -/
@[simps! (config := mfld_cfg)]
def _root_.Equiv.toPartialEquiv (e : α ≃ β) : PartialEquiv α β 
goal: ↑e.toPartialEquiv.symm = ⇑e.symm

full_name: Equiv.toPartialEquiv_source
code: /-- Associate a `PartialEquiv` to an `Equiv`. -/
@[simps! (config := mfld_cfg)]
def _root_.Equiv.toPartialEquiv (e : α ≃ β) : PartialEquiv α β 
goal: e.toPartialEquiv.source = Set.univ

full_name: Equiv.toPartialEquiv_target
code: /-- Associate a `PartialEquiv` to an `Equiv`. -/
@[simps! (config := mfld_cfg)]
def _root_.Equiv.toPartialEquiv (e : α ≃ β) : PartialEquiv α β 
goal: e.toPartialEquiv.target = Set.univ

full_name: Equiv.toPartialEquiv_apply
code: /-- Associate a `PartialEquiv` to an `Equiv`. -/
@[simps! (config := mfld_cfg)]
def _root_.Equiv.toPartialEquiv (e : α ≃ β) : PartialEquiv α β 
goal: ↑e.toPartialEquiv = ⇑e

full_name: PartialEquiv.inhabitedOfEmpty
code: instance inhabitedOfEmpty [IsEmpty α] [IsEmpty β] : Inhabited (PartialEquiv α β) 
goal: Inhabited (PartialEquiv α β)

full_name: PartialEquiv.copy_source
code: /-- Create a copy of a `PartialEquiv` providing better definitional equalities. -/
@[simps (config := .asFn)]
def copy (e : PartialEquiv α β) (f : α → β) (hf : ⇑e = f) (g : β → α) (hg : ⇑e.symm = g) (s : Set α)
    (hs : e.source = s) (t : Set β) (ht : e.target = t) :
    PartialEquiv α β 
goal: (e.copy f hf g hg s hs t ht).source = s

full_name: PartialEquiv.copy_symm_apply
code: /-- Create a copy of a `PartialEquiv` providing better definitional equalities. -/
@[simps (config := .asFn)]
def copy (e : PartialEquiv α β) (f : α → β) (hf : ⇑e = f) (g : β → α) (hg : ⇑e.symm = g) (s : Set α)
    (hs : e.source = s) (t : Set β) (ht : e.target = t) :
    PartialEquiv α β 
goal: ↑(e.copy f hf g hg s hs t ht).symm = g

full_name: PartialEquiv.copy_target
code: /-- Create a copy of a `PartialEquiv` providing better definitional equalities. -/
@[simps (config := .asFn)]
def copy (e : PartialEquiv α β) (f : α → β) (hf : ⇑e = f) (g : β → α) (hg : ⇑e.symm = g) (s : Set α)
    (hs : e.source = s) (t : Set β) (ht : e.target = t) :
    PartialEquiv α β 
goal: (e.copy f hf g hg s hs t ht).target = t

full_name: PartialEquiv.copy
code: /-- Create a copy of a `PartialEquiv` providing better definitional equalities. -/
@[simps (config := .asFn)]
def copy (e : PartialEquiv α β) (f : α → β) (hf : ⇑e = f) (g : β → α) (hg : ⇑e.symm = g) (s : Set α)
    (hs : e.source = s) (t : Set β) (ht : e.target = t) :
    PartialEquiv α β 
goal: PartialEquiv α β

full_name: PartialEquiv.copy_apply
code: /-- Create a copy of a `PartialEquiv` providing better definitional equalities. -/
@[simps (config := .asFn)]
def copy (e : PartialEquiv α β) (f : α → β) (hf : ⇑e = f) (g : β → α) (hg : ⇑e.symm = g) (s : Set α)
    (hs : e.source = s) (t : Set β) (ht : e.target = t) :
    PartialEquiv α β 
goal: ↑(e.copy f hf g hg s hs t ht) = f

full_name: PartialEquiv.copy_eq
code: theorem copy_eq (e : PartialEquiv α β) (f : α → β) (hf : ⇑e = f) (g : β → α) (hg : ⇑e.symm = g)
    (s : Set α) (hs : e.source = s) (t : Set β) (ht : e.target = t) :
    e.copy f hf g hg s hs t ht = e 
goal: e.copy f hf g hg s hs t ht = e

full_name: PartialEquiv.toEquiv
code: /-- Associate to a `PartialEquiv` an `Equiv` between the source and the target. -/
protected def toEquiv : e.source ≃ e.target 
goal: ↑e.source ≃ ↑e.target

full_name: PartialEquiv.symm_source
code: @[simp, mfld_simps]
theorem symm_source : e.symm.source = e.target 
goal: e.symm.source = e.target

full_name: PartialEquiv.symm_target
code: @[simp, mfld_simps]
theorem symm_target : e.symm.target = e.source 
goal: e.symm.target = e.source

full_name: PartialEquiv.symm_symm
code: @[simp, mfld_simps]
theorem symm_symm : e.symm.symm = e 
goal: e.symm.symm = e

full_name: PartialEquiv.symm_bijective
code: theorem symm_bijective :
    Function.Bijective (PartialEquiv.symm : PartialEquiv α β → PartialEquiv β α) 
goal: Function.Bijective PartialEquiv.symm

full_name: PartialEquiv.image_source_eq_target
code: theorem image_source_eq_target : e '' e.source = e.target 
goal: ↑e '' e.source = e.target

full_name: PartialEquiv.forall_mem_target
code: theorem forall_mem_target {p : β → Prop} : (∀ y ∈ e.target, p y) ↔ ∀ x ∈ e.source, p (e x) 
goal: (∀ y ∈ e.target, p y) ↔ ∀ x ∈ e.source, p (↑e x)

full_name: PartialEquiv.exists_mem_target
code: theorem exists_mem_target {p : β → Prop} : (∃ y ∈ e.target, p y) ↔ ∃ x ∈ e.source, p (e x) 
goal: (∃ y ∈ e.target, p y) ↔ ∃ x ∈ e.source, p (↑e x)

full_name: PartialEquiv.IsImage
code: /-- We say that `t : Set β` is an image of `s : Set α` under a partial equivalence if
any of the following equivalent conditions hold:

* `e '' (e.source ∩ s) = e.target ∩ t`;
* `e.source ∩ e ⁻¹ t = e.source ∩ s`;
* `∀ x ∈ e.source, e x ∈ t ↔ x ∈ s` (this one is used in the definition).
-/
def IsImage (s : Set α) (t : Set β) : Prop 
goal: Prop

full_name: PartialEquiv.IsImage.apply_mem_iff
code: theorem apply_mem_iff (h : e.IsImage s t) (hx : x ∈ e.source) : e x ∈ t ↔ x ∈ s 
goal: ↑e x ∈ t ↔ x ∈ s

full_name: PartialEquiv.IsImage.symm_apply_mem_iff
code: theorem symm_apply_mem_iff (h : e.IsImage s t) : ∀ ⦃y⦄, y ∈ e.target → (e.symm y ∈ s ↔ y ∈ t) 
goal: y ∈ e.target → (↑e.symm y ∈ s ↔ y ∈ t)

full_name: PartialEquiv.IsImage.symm
code: protected theorem symm (h : e.IsImage s t) : e.symm.IsImage t s 
goal: e.symm.IsImage t s

full_name: PartialEquiv.IsImage.symm_iff
code: @[simp]
theorem symm_iff : e.symm.IsImage t s ↔ e.IsImage s t 
goal: e.symm.IsImage t s ↔ e.IsImage s t

full_name: PartialEquiv.IsImage.mapsTo
code: protected theorem mapsTo (h : e.IsImage s t) : MapsTo e (e.source ∩ s) (e.target ∩ t) 
goal: Set.MapsTo (↑e) (e.source ∩ s) (e.target ∩ t)

full_name: PartialEquiv.IsImage.symm_mapsTo
code: theorem symm_mapsTo (h : e.IsImage s t) : MapsTo e.symm (e.target ∩ t) (e.source ∩ s) 
goal: Set.MapsTo (↑e.symm) (e.target ∩ t) (e.source ∩ s)

full_name: PartialEquiv.IsImage.restr_apply
code: /-- Restrict a `PartialEquiv` to a pair of corresponding sets. -/
@[simps (config := .asFn)]
def restr (h : e.IsImage s t) : PartialEquiv α β 
goal: ↑h.restr = ↑e

full_name: PartialEquiv.IsImage.restr_symm_apply
code: /-- Restrict a `PartialEquiv` to a pair of corresponding sets. -/
@[simps (config := .asFn)]
def restr (h : e.IsImage s t) : PartialEquiv α β 
goal: ↑h.restr.symm = ↑e.symm

full_name: PartialEquiv.IsImage.restr_target
code: /-- Restrict a `PartialEquiv` to a pair of corresponding sets. -/
@[simps (config := .asFn)]
def restr (h : e.IsImage s t) : PartialEquiv α β 
goal: h.restr.target = e.target ∩ t

full_name: PartialEquiv.IsImage.restr_source
code: /-- Restrict a `PartialEquiv` to a pair of corresponding sets. -/
@[simps (config := .asFn)]
def restr (h : e.IsImage s t) : PartialEquiv α β 
goal: h.restr.source = e.source ∩ s

full_name: PartialEquiv.IsImage.restr
code: /-- Restrict a `PartialEquiv` to a pair of corresponding sets. -/
@[simps (config := .asFn)]
def restr (h : e.IsImage s t) : PartialEquiv α β 
goal: PartialEquiv α β

full_name: PartialEquiv.IsImage.image_eq
code: theorem image_eq (h : e.IsImage s t) : e '' (e.source ∩ s) = e.target ∩ t 
goal: ↑e '' (e.source ∩ s) = e.target ∩ t

full_name: PartialEquiv.IsImage.symm_image_eq
code: theorem symm_image_eq (h : e.IsImage s t) : e.symm '' (e.target ∩ t) = e.source ∩ s 
goal: ↑e.symm '' (e.target ∩ t) = e.source ∩ s

full_name: PartialEquiv.IsImage.iff_preimage_eq
code: theorem iff_preimage_eq : e.IsImage s t ↔ e.source ∩ e ⁻¹' t = e.source ∩ s 
goal: e.IsImage s t ↔ e.source ∩ ↑e ⁻¹' t = e.source ∩ s

full_name: PartialEquiv.IsImage.iff_symm_preimage_eq
code: theorem iff_symm_preimage_eq : e.IsImage s t ↔ e.target ∩ e.symm ⁻¹' s = e.target ∩ t 
goal: e.IsImage s t ↔ e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t

full_name: PartialEquiv.IsImage.of_image_eq
code: theorem of_image_eq (h : e '' (e.source ∩ s) = e.target ∩ t) : e.IsImage s t 
goal: e.IsImage s t

full_name: PartialEquiv.IsImage.of_symm_image_eq
code: theorem of_symm_image_eq (h : e.symm '' (e.target ∩ t) = e.source ∩ s) : e.IsImage s t 
goal: e.IsImage s t

full_name: PartialEquiv.IsImage.compl
code: protected theorem compl (h : e.IsImage s t) : e.IsImage sᶜ tᶜ 
goal: e.IsImage sᶜ tᶜ

full_name: PartialEquiv.IsImage.inter
code: protected theorem inter {s' t'} (h : e.IsImage s t) (h' : e.IsImage s' t') :
    e.IsImage (s ∩ s') (t ∩ t') 
goal: e.IsImage (s ∩ s') (t ∩ t')

full_name: PartialEquiv.IsImage.union
code: protected theorem union {s' t'} (h : e.IsImage s t) (h' : e.IsImage s' t') :
    e.IsImage (s ∪ s') (t ∪ t') 
goal: e.IsImage (s ∪ s') (t ∪ t')

full_name: PartialEquiv.IsImage.diff
code: protected theorem diff {s' t'} (h : e.IsImage s t) (h' : e.IsImage s' t') :
    e.IsImage (s \ s') (t \ t') 
goal: e.IsImage (s \ s') (t \ t')

full_name: PartialEquiv.IsImage.leftInvOn_piecewise
code: theorem leftInvOn_piecewise {e' : PartialEquiv α β} [∀ i, Decidable (i ∈ s)]
    [∀ i, Decidable (i ∈ t)] (h : e.IsImage s t) (h' : e'.IsImage s t) :
    LeftInvOn (t.piecewise e.symm e'.symm) (s.piecewise e e') (s.ite e.source e'.source) 
goal: Set.LeftInvOn (t.piecewise ↑e.symm ↑e'.symm) (s.piecewise ↑e ↑e') (s.ite e.source e'.source)

full_name: PartialEquiv.IsImage.inter_eq_of_inter_eq_of_eqOn
code: theorem inter_eq_of_inter_eq_of_eqOn {e' : PartialEquiv α β} (h : e.IsImage s t)
    (h' : e'.IsImage s t) (hs : e.source ∩ s = e'.source ∩ s) (heq : EqOn e e' (e.source ∩ s)) :
    e.target ∩ t = e'.target ∩ t 
goal: e.target ∩ t = e'.target ∩ t

full_name: PartialEquiv.IsImage.symm_eq_on_of_inter_eq_of_eqOn
code: theorem symm_eq_on_of_inter_eq_of_eqOn {e' : PartialEquiv α β} (h : e.IsImage s t)
    (hs : e.source ∩ s = e'.source ∩ s) (heq : EqOn e e' (e.source ∩ s)) :
    EqOn e.symm e'.symm (e.target ∩ t) 
goal: Set.EqOn (↑e.symm) (↑e'.symm) (e.target ∩ t)

full_name: PartialEquiv.isImage_source_target
code: theorem isImage_source_target : e.IsImage e.source e.target 
goal: e.IsImage e.source e.target

full_name: PartialEquiv.isImage_source_target_of_disjoint
code: theorem isImage_source_target_of_disjoint (e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) : e.IsImage e'.source e'.target 
goal: e.IsImage e'.source e'.target

full_name: PartialEquiv.image_source_inter_eq'
code: theorem image_source_inter_eq' (s : Set α) : e '' (e.source ∩ s) = e.target ∩ e.symm ⁻¹' s 
goal: ↑e '' (e.source ∩ s) = e.target ∩ ↑e.symm ⁻¹' s

full_name: PartialEquiv.image_source_inter_eq
code: theorem image_source_inter_eq (s : Set α) :
    e '' (e.source ∩ s) = e.target ∩ e.symm ⁻¹' (e.source ∩ s) 
goal: ↑e '' (e.source ∩ s) = e.target ∩ ↑e.symm ⁻¹' (e.source ∩ s)

full_name: PartialEquiv.image_eq_target_inter_inv_preimage
code: theorem image_eq_target_inter_inv_preimage {s : Set α} (h : s ⊆ e.source) :
    e '' s = e.target ∩ e.symm ⁻¹' s 
goal: ↑e '' s = e.target ∩ ↑e.symm ⁻¹' s

full_name: PartialEquiv.symm_image_eq_source_inter_preimage
code: theorem symm_image_eq_source_inter_preimage {s : Set β} (h : s ⊆ e.target) :
    e.symm '' s = e.source ∩ e ⁻¹' s 
goal: ↑e.symm '' s = e.source ∩ ↑e ⁻¹' s

full_name: PartialEquiv.symm_image_target_inter_eq
code: theorem symm_image_target_inter_eq (s : Set β) :
    e.symm '' (e.target ∩ s) = e.source ∩ e ⁻¹' (e.target ∩ s) 
goal: ↑e.symm '' (e.target ∩ s) = e.source ∩ ↑e ⁻¹' (e.target ∩ s)

full_name: PartialEquiv.symm_image_target_inter_eq'
code: theorem symm_image_target_inter_eq' (s : Set β) : e.symm '' (e.target ∩ s) = e.source ∩ e ⁻¹' s 
goal: ↑e.symm '' (e.target ∩ s) = e.source ∩ ↑e ⁻¹' s

full_name: PartialEquiv.source_inter_preimage_inv_preimage
code: theorem source_inter_preimage_inv_preimage (s : Set α) :
    e.source ∩ e ⁻¹' (e.symm ⁻¹' s) = e.source ∩ s 
goal: e.source ∩ ↑e ⁻¹' (↑e.symm ⁻¹' s) = e.source ∩ s

full_name: PartialEquiv.source_inter_preimage_target_inter
code: theorem source_inter_preimage_target_inter (s : Set β) :
    e.source ∩ e ⁻¹' (e.target ∩ s) = e.source ∩ e ⁻¹' s 
goal: e.source ∩ ↑e ⁻¹' (e.target ∩ s) = e.source ∩ ↑e ⁻¹' s

full_name: PartialEquiv.target_inter_inv_preimage_preimage
code: theorem target_inter_inv_preimage_preimage (s : Set β) :
    e.target ∩ e.symm ⁻¹' (e ⁻¹' s) = e.target ∩ s 
goal: e.target ∩ ↑e.symm ⁻¹' (↑e ⁻¹' s) = e.target ∩ s

full_name: PartialEquiv.symm_image_image_of_subset_source
code: theorem symm_image_image_of_subset_source {s : Set α} (h : s ⊆ e.source) : e.symm '' (e '' s) = s 
goal: ↑e.symm '' (↑e '' s) = s

full_name: PartialEquiv.image_symm_image_of_subset_target
code: theorem image_symm_image_of_subset_target {s : Set β} (h : s ⊆ e.target) : e '' (e.symm '' s) = s 
goal: ↑e '' (↑e.symm '' s) = s

full_name: PartialEquiv.source_subset_preimage_target
code: theorem source_subset_preimage_target : e.source ⊆ e ⁻¹' e.target 
goal: e.source ⊆ ↑e ⁻¹' e.target

full_name: PartialEquiv.symm_image_target_eq_source
code: theorem symm_image_target_eq_source : e.symm '' e.target = e.source 
goal: ↑e.symm '' e.target = e.source

full_name: PartialEquiv.target_subset_preimage_source
code: theorem target_subset_preimage_source : e.target ⊆ e.symm ⁻¹' e.source 
goal: e.target ⊆ ↑e.symm ⁻¹' e.source

full_name: PartialEquiv.ext
code: /-- Two partial equivs that have the same `source`, same `toFun` and same `invFun`, coincide. -/
@[ext]
protected theorem ext {e e' : PartialEquiv α β} (h : ∀ x, e x = e' x)
    (hsymm : ∀ x, e.symm x = e'.symm x) (hs : e.source = e'.source) : e = e' 
goal: e = e'

full_name: PartialEquiv.restr
code: /-- Restricting a partial equivalence to `e.source ∩ s` -/
protected def restr (s : Set α) : PartialEquiv α β 
goal: PartialEquiv α β

full_name: PartialEquiv.restr_coe
code: @[simp, mfld_simps]
theorem restr_coe (s : Set α) : (e.restr s : α → β) = e 
goal: ↑(e.restr s) = ↑e

full_name: PartialEquiv.restr_coe_symm
code: @[simp, mfld_simps]
theorem restr_coe_symm (s : Set α) : ((e.restr s).symm : β → α) = e.symm 
goal: ↑(e.restr s).symm = ↑e.symm

full_name: PartialEquiv.restr_source
code: @[simp, mfld_simps]
theorem restr_source (s : Set α) : (e.restr s).source = e.source ∩ s 
goal: (e.restr s).source = e.source ∩ s

full_name: PartialEquiv.restr_target
code: @[simp, mfld_simps]
theorem restr_target (s : Set α) : (e.restr s).target = e.target ∩ e.symm ⁻¹' s 
goal: (e.restr s).target = e.target ∩ ↑e.symm ⁻¹' s

full_name: PartialEquiv.restr_eq_of_source_subset
code: theorem restr_eq_of_source_subset {e : PartialEquiv α β} {s : Set α} (h : e.source ⊆ s) :
    e.restr s = e 
goal: e.restr s = e

full_name: PartialEquiv.restr_univ
code: @[simp, mfld_simps]
theorem restr_univ {e : PartialEquiv α β} : e.restr univ = e 
goal: e.restr Set.univ = e

full_name: PartialEquiv.refl
code: /-- The identity partial equiv -/
protected def refl (α : Type*) : PartialEquiv α α 
goal: PartialEquiv α α

full_name: PartialEquiv.refl_source
code: @[simp, mfld_simps]
theorem refl_source : (PartialEquiv.refl α).source = univ 
goal: (PartialEquiv.refl α).source = Set.univ

full_name: PartialEquiv.refl_target
code: @[simp, mfld_simps]
theorem refl_target : (PartialEquiv.refl α).target = univ 
goal: (PartialEquiv.refl α).target = Set.univ

full_name: PartialEquiv.refl_coe
code: @[simp, mfld_simps]
theorem refl_coe : (PartialEquiv.refl α : α → α) = id 
goal: ↑(PartialEquiv.refl α) = id

full_name: PartialEquiv.refl_symm
code: @[simp, mfld_simps]
theorem refl_symm : (PartialEquiv.refl α).symm = PartialEquiv.refl α 
goal: (PartialEquiv.refl α).symm = PartialEquiv.refl α

full_name: PartialEquiv.refl_restr_source
code: @[mfld_simps]
theorem refl_restr_source (s : Set α) : ((PartialEquiv.refl α).restr s).source = s 
goal: ((PartialEquiv.refl α).restr s).source = s

full_name: PartialEquiv.refl_restr_target
code: @[mfld_simps]
theorem refl_restr_target (s : Set α) : ((PartialEquiv.refl α).restr s).target = s 
goal: ((PartialEquiv.refl α).restr s).target = s

full_name: PartialEquiv.ofSet
code: /-- The identity partial equivalence on a set `s` -/
def ofSet (s : Set α) : PartialEquiv α α 
goal: PartialEquiv α α

full_name: PartialEquiv.ofSet_source
code: @[simp, mfld_simps]
theorem ofSet_source (s : Set α) : (PartialEquiv.ofSet s).source = s 
goal: (PartialEquiv.ofSet s).source = s

full_name: PartialEquiv.ofSet_target
code: @[simp, mfld_simps]
theorem ofSet_target (s : Set α) : (PartialEquiv.ofSet s).target = s 
goal: (PartialEquiv.ofSet s).target = s

full_name: PartialEquiv.ofSet_coe
code: @[simp, mfld_simps]
theorem ofSet_coe (s : Set α) : (PartialEquiv.ofSet s : α → α) = id 
goal: ↑(PartialEquiv.ofSet s) = id

full_name: PartialEquiv.ofSet_symm
code: @[simp, mfld_simps]
theorem ofSet_symm (s : Set α) : (PartialEquiv.ofSet s).symm = PartialEquiv.ofSet s 
goal: (PartialEquiv.ofSet s).symm = PartialEquiv.ofSet s

full_name: PartialEquiv.trans'_target
code: /-- Composing two partial equivs if the target of the first coincides with the source of the
second. -/
@[simps]
protected def trans' (e' : PartialEquiv β γ) (h : e.target = e'.source) : PartialEquiv α γ 
goal: (e.trans' e' h).target = e'.target

full_name: PartialEquiv.trans'_symm_apply
code: /-- Composing two partial equivs if the target of the first coincides with the source of the
second. -/
@[simps]
protected def trans' (e' : PartialEquiv β γ) (h : e.target = e'.source) : PartialEquiv α γ 
goal: ∀ (a : γ), ↑(e.trans' e' h).symm a = (↑e.symm ∘ ↑e'.symm) a

full_name: PartialEquiv.trans'
code: /-- Composing two partial equivs if the target of the first coincides with the source of the
second. -/
@[simps]
protected def trans' (e' : PartialEquiv β γ) (h : e.target = e'.source) : PartialEquiv α γ 
goal: PartialEquiv α γ

full_name: PartialEquiv.trans'_source
code: /-- Composing two partial equivs if the target of the first coincides with the source of the
second. -/
@[simps]
protected def trans' (e' : PartialEquiv β γ) (h : e.target = e'.source) : PartialEquiv α γ 
goal: (e.trans' e' h).source = e.source

full_name: PartialEquiv.trans'_apply
code: /-- Composing two partial equivs if the target of the first coincides with the source of the
second. -/
@[simps]
protected def trans' (e' : PartialEquiv β γ) (h : e.target = e'.source) : PartialEquiv α γ 
goal: ∀ (a : α), ↑(e.trans' e' h) a = (↑e' ∘ ↑e) a

full_name: PartialEquiv.trans
code: /-- Composing two partial equivs, by restricting to the maximal domain where their composition
is well defined. -/
@[trans]
protected def trans : PartialEquiv α γ 
goal: PartialEquiv α γ

full_name: PartialEquiv.coe_trans
code: @[simp, mfld_simps]
theorem coe_trans : (e.trans e' : α → γ) = e' ∘ e 
goal: ↑(e.trans e') = ↑e' ∘ ↑e

full_name: PartialEquiv.coe_trans_symm
code: @[simp, mfld_simps]
theorem coe_trans_symm : ((e.trans e').symm : γ → α) = e.symm ∘ e'.symm 
goal: ↑(e.trans e').symm = ↑e.symm ∘ ↑e'.symm

full_name: PartialEquiv.trans_apply
code: theorem trans_apply {x : α} : (e.trans e') x = e' (e x) 
goal: ↑(e.trans e') x = ↑e' (↑e x)

full_name: PartialEquiv.trans_symm_eq_symm_trans_symm
code: theorem trans_symm_eq_symm_trans_symm : (e.trans e').symm = e'.symm.trans e.symm 
goal: (e.trans e').symm = e'.symm.trans e.symm

full_name: PartialEquiv.trans_source
code: @[simp, mfld_simps]
theorem trans_source : (e.trans e').source = e.source ∩ e ⁻¹' e'.source 
goal: (e.trans e').source = e.source ∩ ↑e ⁻¹' e'.source

full_name: PartialEquiv.trans_source'
code: theorem trans_source' : (e.trans e').source = e.source ∩ e ⁻¹' (e.target ∩ e'.source) 
goal: (e.trans e').source = e.source ∩ ↑e ⁻¹' (e.target ∩ e'.source)

full_name: PartialEquiv.trans_source''
code: theorem trans_source'' : (e.trans e').source = e.symm '' (e.target ∩ e'.source) 
goal: (e.trans e').source = ↑e.symm '' (e.target ∩ e'.source)

full_name: PartialEquiv.image_trans_source
code: theorem image_trans_source : e '' (e.trans e').source = e.target ∩ e'.source 
goal: ↑e '' (e.trans e').source = e.target ∩ e'.source

full_name: PartialEquiv.trans_target
code: @[simp, mfld_simps]
theorem trans_target : (e.trans e').target = e'.target ∩ e'.symm ⁻¹' e.target 
goal: (e.trans e').target = e'.target ∩ ↑e'.symm ⁻¹' e.target

full_name: PartialEquiv.trans_target'
code: theorem trans_target' : (e.trans e').target = e'.target ∩ e'.symm ⁻¹' (e'.source ∩ e.target) 
goal: (e.trans e').target = e'.target ∩ ↑e'.symm ⁻¹' (e'.source ∩ e.target)

full_name: PartialEquiv.trans_target''
code: theorem trans_target'' : (e.trans e').target = e' '' (e'.source ∩ e.target) 
goal: (e.trans e').target = ↑e' '' (e'.source ∩ e.target)

full_name: PartialEquiv.inv_image_trans_target
code: theorem inv_image_trans_target : e'.symm '' (e.trans e').target = e'.source ∩ e.target 
goal: ↑e'.symm '' (e.trans e').target = e'.source ∩ e.target

full_name: PartialEquiv.trans_assoc
code: theorem trans_assoc (e'' : PartialEquiv γ δ) : (e.trans e').trans e'' = e.trans (e'.trans e'') 
goal: (e.trans e').trans e'' = e.trans (e'.trans e'')

full_name: PartialEquiv.trans_refl
code: @[simp, mfld_simps]
theorem trans_refl : e.trans (PartialEquiv.refl β) = e 
goal: e.trans (PartialEquiv.refl β) = e

full_name: PartialEquiv.refl_trans
code: @[simp, mfld_simps]
theorem refl_trans : (PartialEquiv.refl α).trans e = e 
goal: (PartialEquiv.refl α).trans e = e

full_name: PartialEquiv.trans_ofSet
code: theorem trans_ofSet (s : Set β) : e.trans (ofSet s) = e.restr (e ⁻¹' s) 
goal: e.trans (PartialEquiv.ofSet s) = e.restr (↑e ⁻¹' s)

full_name: PartialEquiv.trans_refl_restr
code: theorem trans_refl_restr (s : Set β) :
    e.trans ((PartialEquiv.refl β).restr s) = e.restr (e ⁻¹' s) 
goal: e.trans ((PartialEquiv.refl β).restr s) = e.restr (↑e ⁻¹' s)

full_name: PartialEquiv.trans_refl_restr'
code: theorem trans_refl_restr' (s : Set β) :
    e.trans ((PartialEquiv.refl β).restr s) = e.restr (e.source ∩ e ⁻¹' s) 
goal: e.trans ((PartialEquiv.refl β).restr s) = e.restr (e.source ∩ ↑e ⁻¹' s)

full_name: PartialEquiv.restr_trans
code: theorem restr_trans (s : Set α) : (e.restr s).trans e' = (e.trans e').restr s 
goal: (e.restr s).trans e' = (e.trans e').restr s

full_name: PartialEquiv.mem_symm_trans_source
code: /-- A lemma commonly useful when `e` and `e'` are charts of a manifold. -/
theorem mem_symm_trans_source {e' : PartialEquiv α γ} {x : α} (he : x ∈ e.source)
    (he' : x ∈ e'.source) : e x ∈ (e.symm.trans e').source 
goal: ↑e x ∈ (e.symm.trans e').source

full_name: PartialEquiv.EqOnSource
code: /-- `EqOnSource e e'` means that `e` and `e'` have the same source, and coincide there. Then `e`
and `e'` should really be considered the same partial equiv. -/
def EqOnSource (e e' : PartialEquiv α β) : Prop 
goal: Prop

full_name: PartialEquiv.eqOnSourceSetoid
code: /-- `EqOnSource` is an equivalence relation. This instance provides the `≈` notation between two
`PartialEquiv`s. -/
instance eqOnSourceSetoid : Setoid (PartialEquiv α β) 
goal: Setoid (PartialEquiv α β)

full_name: PartialEquiv.eqOnSource_refl
code: theorem eqOnSource_refl : e ≈ e 
goal: e ≈ e

full_name: PartialEquiv.EqOnSource.source_eq
code: /-- Two equivalent partial equivs have the same source. -/
theorem EqOnSource.source_eq {e e' : PartialEquiv α β} (h : e ≈ e') : e.source = e'.source 
goal: e.source = e'.source

full_name: PartialEquiv.EqOnSource.eqOn
code: /-- Two equivalent partial equivs coincide on the source. -/
theorem EqOnSource.eqOn {e e' : PartialEquiv α β} (h : e ≈ e') : e.source.EqOn e e' 
goal: Set.EqOn (↑e) (↑e') e.source

full_name: PartialEquiv.EqOnSource.target_eq
code: /-- Two equivalent partial equivs have the same target. -/
theorem EqOnSource.target_eq {e e' : PartialEquiv α β} (h : e ≈ e') : e.target = e'.target 
goal: e.target = e'.target

full_name: PartialEquiv.EqOnSource.symm'
code: /-- If two partial equivs are equivalent, so are their inverses. -/
theorem EqOnSource.symm' {e e' : PartialEquiv α β} (h : e ≈ e') : e.symm ≈ e'.symm 
goal: e.symm ≈ e'.symm

full_name: PartialEquiv.EqOnSource.symm_eqOn
code: /-- Two equivalent partial equivs have coinciding inverses on the target. -/
theorem EqOnSource.symm_eqOn {e e' : PartialEquiv α β} (h : e ≈ e') :
    EqOn e.symm e'.symm e.target 
goal: Set.EqOn (↑e.symm) (↑e'.symm) e.target

full_name: PartialEquiv.EqOnSource.trans'
code: /-- Composition of partial equivs respects equivalence. -/
theorem EqOnSource.trans' {e e' : PartialEquiv α β} {f f' : PartialEquiv β γ} (he : e ≈ e')
    (hf : f ≈ f') : e.trans f ≈ e'.trans f' 
goal: e.trans f ≈ e'.trans f'

full_name: PartialEquiv.EqOnSource.restr
code: /-- Restriction of partial equivs respects equivalence. -/
theorem EqOnSource.restr {e e' : PartialEquiv α β} (he : e ≈ e') (s : Set α) :
    e.restr s ≈ e'.restr s 
goal: e.restr s ≈ e'.restr s

full_name: PartialEquiv.EqOnSource.source_inter_preimage_eq
code: /-- Preimages are respected by equivalence. -/
theorem EqOnSource.source_inter_preimage_eq {e e' : PartialEquiv α β} (he : e ≈ e') (s : Set β) :
    e.source ∩ e ⁻¹' s = e'.source ∩ e' ⁻¹' s 
goal: e.source ∩ ↑e ⁻¹' s = e'.source ∩ ↑e' ⁻¹' s

full_name: PartialEquiv.self_trans_symm
code: /-- Composition of a partial equivlance and its inverse is equivalent to
the restriction of the identity to the source. -/
theorem self_trans_symm : e.trans e.symm ≈ ofSet e.source 
goal: e.trans e.symm ≈ PartialEquiv.ofSet e.source

full_name: PartialEquiv.symm_trans_self
code: /-- Composition of the inverse of a partial equivalence and this partial equivalence is equivalent
to the restriction of the identity to the target. -/
theorem symm_trans_self : e.symm.trans e ≈ ofSet e.target 
goal: e.symm.trans e ≈ PartialEquiv.ofSet e.target

full_name: PartialEquiv.eq_of_eqOnSource_univ
code: /-- Two equivalent partial equivs are equal when the source and target are `univ`. -/
theorem eq_of_eqOnSource_univ (e e' : PartialEquiv α β) (h : e ≈ e') (s : e.source = univ)
    (t : e.target = univ) : e = e' 
goal: e = e'

full_name: PartialEquiv.prod
code: /-- The product of two partial equivalences, as a partial equivalence on the product. -/
def prod (e : PartialEquiv α β) (e' : PartialEquiv γ δ) : PartialEquiv (α × γ) (β × δ) 
goal: PartialEquiv (α × γ) (β × δ)

full_name: PartialEquiv.prod_source
code: @[simp, mfld_simps]
theorem prod_source (e : PartialEquiv α β) (e' : PartialEquiv γ δ) :
    (e.prod e').source = e.source ×ˢ e'.source 
goal: (e.prod e').source = e.source ×ˢ e'.source

full_name: PartialEquiv.prod_target
code: @[simp, mfld_simps]
theorem prod_target (e : PartialEquiv α β) (e' : PartialEquiv γ δ) :
    (e.prod e').target = e.target ×ˢ e'.target 
goal: (e.prod e').target = e.target ×ˢ e'.target

full_name: PartialEquiv.prod_coe
code: @[simp, mfld_simps]
theorem prod_coe (e : PartialEquiv α β) (e' : PartialEquiv γ δ) :
    (e.prod e' : α × γ → β × δ) = fun p => (e p.1, e' p.2) 
goal: ↑(e.prod e') = fun p => (↑e p.1, ↑e' p.2)

full_name: PartialEquiv.prod_coe_symm
code: theorem prod_coe_symm (e : PartialEquiv α β) (e' : PartialEquiv γ δ) :
    ((e.prod e').symm : β × δ → α × γ) = fun p => (e.symm p.1, e'.symm p.2) 
goal: ↑(e.prod e').symm = fun p => (↑e.symm p.1, ↑e'.symm p.2)

full_name: PartialEquiv.prod_symm
code: @[simp, mfld_simps]
theorem prod_symm (e : PartialEquiv α β) (e' : PartialEquiv γ δ) :
    (e.prod e').symm = e.symm.prod e'.symm 
goal: (e.prod e').symm = e.symm.prod e'.symm

full_name: PartialEquiv.refl_prod_refl
code: @[simp, mfld_simps]
theorem refl_prod_refl :
    (PartialEquiv.refl α).prod (PartialEquiv.refl β) = PartialEquiv.refl (α × β) 
goal: (PartialEquiv.refl α).prod (PartialEquiv.refl β) = PartialEquiv.refl (α × β)

full_name: PartialEquiv.prod_trans
code: @[simp, mfld_simps]
theorem prod_trans {η : Type*} {ε : Type*} (e : PartialEquiv α β) (f : PartialEquiv β γ)
    (e' : PartialEquiv δ η) (f' : PartialEquiv η ε) :
    (e.prod e').trans (f.prod f') = (e.trans f).prod (e'.trans f') 
goal: (e.prod e').trans (f.prod f') = (e.trans f).prod (e'.trans f')

full_name: PartialEquiv.piecewise
code: /-- Combine two `PartialEquiv`s using `Set.piecewise`. The source of the new `PartialEquiv` is
`s.ite e.source e'.source = e.source ∩ s ∪ e'.source \ s`, and similarly for target.  The function
sends `e.source ∩ s` to `e.target ∩ t` using `e` and `e'.source \ s` to `e'.target \ t` using `e'`,
and similarly for the inverse function. The definition assumes `e.isImage s t` and
`e'.isImage s t`. -/
@[simps (config := .asFn)]
def piecewise (e e' : PartialEquiv α β) (s : Set α) (t : Set β) [∀ x, Decidable (x ∈ s)]
    [∀ y, Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t) :
    PartialEquiv α β 
goal: PartialEquiv α β

full_name: PartialEquiv.piecewise_apply
code: /-- Combine two `PartialEquiv`s using `Set.piecewise`. The source of the new `PartialEquiv` is
`s.ite e.source e'.source = e.source ∩ s ∪ e'.source \ s`, and similarly for target.  The function
sends `e.source ∩ s` to `e.target ∩ t` using `e` and `e'.source \ s` to `e'.target \ t` using `e'`,
and similarly for the inverse function. The definition assumes `e.isImage s t` and
`e'.isImage s t`. -/
@[simps (config := .asFn)]
def piecewise (e e' : PartialEquiv α β) (s : Set α) (t : Set β) [∀ x, Decidable (x ∈ s)]
    [∀ y, Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t) :
    PartialEquiv α β 
goal: ↑(e.piecewise e' s t H H') = s.piecewise ↑e ↑e'

full_name: PartialEquiv.piecewise_symm_apply
code: /-- Combine two `PartialEquiv`s using `Set.piecewise`. The source of the new `PartialEquiv` is
`s.ite e.source e'.source = e.source ∩ s ∪ e'.source \ s`, and similarly for target.  The function
sends `e.source ∩ s` to `e.target ∩ t` using `e` and `e'.source \ s` to `e'.target \ t` using `e'`,
and similarly for the inverse function. The definition assumes `e.isImage s t` and
`e'.isImage s t`. -/
@[simps (config := .asFn)]
def piecewise (e e' : PartialEquiv α β) (s : Set α) (t : Set β) [∀ x, Decidable (x ∈ s)]
    [∀ y, Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t) :
    PartialEquiv α β 
goal: ↑(e.piecewise e' s t H H').symm = t.piecewise ↑e.symm ↑e'.symm

full_name: PartialEquiv.piecewise_target
code: /-- Combine two `PartialEquiv`s using `Set.piecewise`. The source of the new `PartialEquiv` is
`s.ite e.source e'.source = e.source ∩ s ∪ e'.source \ s`, and similarly for target.  The function
sends `e.source ∩ s` to `e.target ∩ t` using `e` and `e'.source \ s` to `e'.target \ t` using `e'`,
and similarly for the inverse function. The definition assumes `e.isImage s t` and
`e'.isImage s t`. -/
@[simps (config := .asFn)]
def piecewise (e e' : PartialEquiv α β) (s : Set α) (t : Set β) [∀ x, Decidable (x ∈ s)]
    [∀ y, Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t) :
    PartialEquiv α β 
goal: (e.piecewise e' s t H H').target = t.ite e.target e'.target

full_name: PartialEquiv.piecewise_source
code: /-- Combine two `PartialEquiv`s using `Set.piecewise`. The source of the new `PartialEquiv` is
`s.ite e.source e'.source = e.source ∩ s ∪ e'.source \ s`, and similarly for target.  The function
sends `e.source ∩ s` to `e.target ∩ t` using `e` and `e'.source \ s` to `e'.target \ t` using `e'`,
and similarly for the inverse function. The definition assumes `e.isImage s t` and
`e'.isImage s t`. -/
@[simps (config := .asFn)]
def piecewise (e e' : PartialEquiv α β) (s : Set α) (t : Set β) [∀ x, Decidable (x ∈ s)]
    [∀ y, Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t) :
    PartialEquiv α β 
goal: (e.piecewise e' s t H H').source = s.ite e.source e'.source

full_name: PartialEquiv.symm_piecewise
code: theorem symm_piecewise (e e' : PartialEquiv α β) {s : Set α} {t : Set β} [∀ x, Decidable (x ∈ s)]
    [∀ y, Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t) :
    (e.piecewise e' s t H H').symm = e.symm.piecewise e'.symm t s H.symm H'.symm 
goal: (e.piecewise e' s t H H').symm = e.symm.piecewise e'.symm t s ⋯ ⋯

full_name: PartialEquiv.disjointUnion_target
code: /-- Combine two `PartialEquiv`s with disjoint sources and disjoint targets. We reuse
`PartialEquiv.piecewise`, then override `source` and `target` to ensure better definitional
equalities. -/
@[simps! (config := .asFn)]
def disjointUnion (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) [∀ x, Decidable (x ∈ e.source)]
    [∀ y, Decidable (y ∈ e.target)] : PartialEquiv α β 
goal: (e.disjointUnion e' hs ht).target = e.target ∪ e'.target

full_name: PartialEquiv.disjointUnion
code: /-- Combine two `PartialEquiv`s with disjoint sources and disjoint targets. We reuse
`PartialEquiv.piecewise`, then override `source` and `target` to ensure better definitional
equalities. -/
@[simps! (config := .asFn)]
def disjointUnion (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) [∀ x, Decidable (x ∈ e.source)]
    [∀ y, Decidable (y ∈ e.target)] : PartialEquiv α β 
goal: PartialEquiv α β

full_name: PartialEquiv.disjointUnion_apply
code: /-- Combine two `PartialEquiv`s with disjoint sources and disjoint targets. We reuse
`PartialEquiv.piecewise`, then override `source` and `target` to ensure better definitional
equalities. -/
@[simps! (config := .asFn)]
def disjointUnion (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) [∀ x, Decidable (x ∈ e.source)]
    [∀ y, Decidable (y ∈ e.target)] : PartialEquiv α β 
goal: ↑(e.disjointUnion e' hs ht) = e.source.piecewise ↑e ↑e'

full_name: PartialEquiv.disjointUnion_symm_apply
code: /-- Combine two `PartialEquiv`s with disjoint sources and disjoint targets. We reuse
`PartialEquiv.piecewise`, then override `source` and `target` to ensure better definitional
equalities. -/
@[simps! (config := .asFn)]
def disjointUnion (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) [∀ x, Decidable (x ∈ e.source)]
    [∀ y, Decidable (y ∈ e.target)] : PartialEquiv α β 
goal: ↑(e.disjointUnion e' hs ht).symm = e.target.piecewise ↑e.symm ↑e'.symm

full_name: PartialEquiv.disjointUnion_source
code: /-- Combine two `PartialEquiv`s with disjoint sources and disjoint targets. We reuse
`PartialEquiv.piecewise`, then override `source` and `target` to ensure better definitional
equalities. -/
@[simps! (config := .asFn)]
def disjointUnion (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) [∀ x, Decidable (x ∈ e.source)]
    [∀ y, Decidable (y ∈ e.target)] : PartialEquiv α β 
goal: (e.disjointUnion e' hs ht).source = e.source ∪ e'.source

full_name: PartialEquiv.disjointUnion_eq_piecewise
code: theorem disjointUnion_eq_piecewise (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) [∀ x, Decidable (x ∈ e.source)]
    [∀ y, Decidable (y ∈ e.target)] :
    e.disjointUnion e' hs ht =
      e.piecewise e' e.source e.target e.isImage_source_target
        (e'.isImage_source_target_of_disjoint _ hs.symm ht.symm) 
goal: e.disjointUnion e' hs ht = e.piecewise e' e.source e.target ⋯ ⋯

full_name: PartialEquiv.pi_source
code: /-- The product of a family of partial equivalences, as a partial equivalence on the pi type. -/
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i) 
goal: (PartialEquiv.pi ei).source = Set.univ.pi fun i => (ei i).source

full_name: PartialEquiv.pi_apply
code: /-- The product of a family of partial equivalences, as a partial equivalence on the pi type. -/
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i) 
goal: ↑(PartialEquiv.pi ei) = fun f i => ↑(ei i) (f i)

full_name: PartialEquiv.pi_target
code: /-- The product of a family of partial equivalences, as a partial equivalence on the pi type. -/
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i) 
goal: (PartialEquiv.pi ei).target = Set.univ.pi fun i => (ei i).target

full_name: PartialEquiv.pi
code: /-- The product of a family of partial equivalences, as a partial equivalence on the pi type. -/
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i) 
goal: PartialEquiv ((i : ι) → αi i) ((i : ι) → βi i)

full_name: PartialEquiv.pi_symm
code: @[simp, mfld_simps]
theorem pi_symm (ei : ∀ i, PartialEquiv (αi i) (βi i)) :
    (PartialEquiv.pi ei).symm = .pi fun i ↦ (ei i).symm 
goal: (PartialEquiv.pi ei).symm = PartialEquiv.pi fun i => (ei i).symm

full_name: PartialEquiv.pi_symm_apply
code: theorem pi_symm_apply (ei : ∀ i, PartialEquiv (αi i) (βi i)) :
    ⇑(PartialEquiv.pi ei).symm = fun f i ↦ (ei i).symm (f i) 
goal: ↑(PartialEquiv.pi ei).symm = fun f i => ↑(ei i).symm (f i)

full_name: PartialEquiv.pi_refl
code: @[simp, mfld_simps]
theorem pi_refl : (PartialEquiv.pi fun i ↦ PartialEquiv.refl (αi i)) = .refl (∀ i, αi i) 
goal: (PartialEquiv.pi fun i => PartialEquiv.refl (αi i)) = PartialEquiv.refl ((i : ι) → αi i)

full_name: PartialEquiv.pi_trans
code: @[simp, mfld_simps]
theorem pi_trans (ei : ∀ i, PartialEquiv (αi i) (βi i)) (ei' : ∀ i, PartialEquiv (βi i) (γi i)) :
    (PartialEquiv.pi ei).trans (PartialEquiv.pi ei') = .pi fun i ↦ (ei i).trans (ei' i) 
goal: (PartialEquiv.pi ei).trans (PartialEquiv.pi ei') = PartialEquiv.pi fun i => (ei i).trans (ei' i)

full_name: Set.BijOn.toPartialEquiv
code: /-- A bijection between two sets `s : Set α` and `t : Set β` provides a partial equivalence
between `α` and `β`. -/
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
goal: PartialEquiv α β

full_name: Set.BijOn.toPartialEquiv_target
code: /-- A bijection between two sets `s : Set α` and `t : Set β` provides a partial equivalence
between `α` and `β`. -/
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
goal: (Set.BijOn.toPartialEquiv f s t hf).target = t

full_name: Set.BijOn.toPartialEquiv_symm_apply
code: /-- A bijection between two sets `s : Set α` and `t : Set β` provides a partial equivalence
between `α` and `β`. -/
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
goal: ↑(Set.BijOn.toPartialEquiv f s t hf).symm = Function.invFunOn f s

full_name: Set.BijOn.toPartialEquiv_source
code: /-- A bijection between two sets `s : Set α` and `t : Set β` provides a partial equivalence
between `α` and `β`. -/
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
goal: (Set.BijOn.toPartialEquiv f s t hf).source = s

full_name: Set.BijOn.toPartialEquiv_apply
code: /-- A bijection between two sets `s : Set α` and `t : Set β` provides a partial equivalence
between `α` and `β`. -/
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
goal: ↑(Set.BijOn.toPartialEquiv f s t hf) = f

full_name: Set.InjOn.toPartialEquiv
code: /-- A map injective on a subset of its domain provides a partial equivalence. -/
@[simp, mfld_simps]
noncomputable def InjOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (hf : InjOn f s) :
    PartialEquiv α β 
goal: PartialEquiv α β

full_name: Equiv.refl_toPartialEquiv
code: @[simp, mfld_simps]
theorem refl_toPartialEquiv : (Equiv.refl α).toPartialEquiv = PartialEquiv.refl α 
goal: (Equiv.refl α).toPartialEquiv = PartialEquiv.refl α

full_name: Equiv.symm_toPartialEquiv
code: @[simp, mfld_simps]
theorem symm_toPartialEquiv : e.symm.toPartialEquiv = e.toPartialEquiv.symm 
goal: e.symm.toPartialEquiv = e.toPartialEquiv.symm

full_name: Equiv.trans_toPartialEquiv
code: @[simp, mfld_simps]
theorem trans_toPartialEquiv :
    (e.trans e').toPartialEquiv = e.toPartialEquiv.trans e'.toPartialEquiv 
goal: (e.trans e').toPartialEquiv = e.toPartialEquiv.trans e'.toPartialEquiv

full_name: Equiv.transPartialEquiv_symm_apply
code: /-- Precompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
goal: ∀ (a : γ), ↑(e.transPartialEquiv f').symm a = e.symm (↑f'.symm a)

full_name: Equiv.transPartialEquiv
code: /-- Precompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
goal: PartialEquiv α γ

full_name: Equiv.transPartialEquiv_source
code: /-- Precompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
goal: (e.transPartialEquiv f').source = ⇑e ⁻¹' f'.source

full_name: Equiv.transPartialEquiv_apply
code: /-- Precompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
goal: ∀ (a : α), ↑(e.transPartialEquiv f') a = ↑f' (e a)

full_name: Equiv.transPartialEquiv_target
code: /-- Precompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
goal: (e.transPartialEquiv f').target = f'.target

full_name: Equiv.transPartialEquiv_eq_trans
code: theorem transPartialEquiv_eq_trans (e : α ≃ β) (f' : PartialEquiv β γ) :
    e.transPartialEquiv f' = e.toPartialEquiv.trans f' 
goal: e.transPartialEquiv f' = e.toPartialEquiv.trans f'

full_name: Equiv.transPartialEquiv_trans
code: @[simp, mfld_simps]
theorem transPartialEquiv_trans (e : α ≃ β) (f' : PartialEquiv β γ) (f'' : PartialEquiv γ δ) :
    (e.transPartialEquiv f').trans f'' = e.transPartialEquiv (f'.trans f'') 
goal: (e.transPartialEquiv f').trans f'' = e.transPartialEquiv (f'.trans f'')

full_name: Equiv.trans_transPartialEquiv
code: @[simp, mfld_simps]
theorem trans_transPartialEquiv (e : α ≃ β) (e' : β ≃ γ) (f'' : PartialEquiv γ δ) :
    (e.trans e').transPartialEquiv f'' = e.transPartialEquiv (e'.transPartialEquiv f'') 
goal: (e.trans e').transPartialEquiv f'' = e.transPartialEquiv (e'.transPartialEquiv f'')

full_name: PartialEquiv.transEquiv_symm_apply
code: /-- Postcompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
goal: ∀ (a : γ), ↑(e.transEquiv f').symm a = ↑e.symm (f'.symm a)

full_name: PartialEquiv.transEquiv_apply
code: /-- Postcompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
goal: ∀ (a : α), ↑(e.transEquiv f') a = f' (↑e a)

full_name: PartialEquiv.transEquiv
code: /-- Postcompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
goal: PartialEquiv α γ

full_name: PartialEquiv.transEquiv_source
code: /-- Postcompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
goal: (e.transEquiv f').source = e.source

full_name: PartialEquiv.transEquiv_target
code: /-- Postcompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
goal: (e.transEquiv f').target = ⇑f'.symm ⁻¹' e.target

full_name: PartialEquiv.transEquiv_eq_trans
code: theorem transEquiv_eq_trans (e : PartialEquiv α β) (e' : β ≃ γ) :
    e.transEquiv e' = e.trans e'.toPartialEquiv 
goal: e.transEquiv e' = e.trans e'.toPartialEquiv

full_name: PartialEquiv.transEquiv_transEquiv
code: @[simp, mfld_simps]
theorem transEquiv_transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) (f'' : γ ≃ δ) :
    (e.transEquiv f').transEquiv f'' = e.transEquiv (f'.trans f'') 
goal: (e.transEquiv f').transEquiv f'' = e.transEquiv (f'.trans f'')

full_name: PartialEquiv.trans_transEquiv
code: @[simp, mfld_simps]
theorem trans_transEquiv (e : PartialEquiv α β) (e' : PartialEquiv β γ) (f'' : γ ≃ δ) :
    (e.trans e').transEquiv f'' = e.trans (e'.transEquiv f'') 
goal: (e.trans e').transEquiv f'' = e.trans (e'.transEquiv f'')