File: Mathlib/GroupTheory/Perm/Basic.lean

full_name: Equiv.Perm.instOne
code: instance instOne : One (Perm α) 
goal: One (Equiv.Perm α)

full_name: Equiv.Perm.instMul
code: instance instMul : Mul (Perm α) 
goal: Mul (Equiv.Perm α)

full_name: Equiv.Perm.instInv
code: instance instInv : Inv (Perm α) 
goal: Inv (Equiv.Perm α)

full_name: Equiv.Perm.instPowNat
code: instance instPowNat : Pow (Perm α) ℕ 
goal: Pow (Equiv.Perm α) ℕ

full_name: Equiv.Perm.permGroup
code: instance permGroup : Group (Perm α) 
goal: Group (Equiv.Perm α)

full_name: Equiv.Perm.default_eq
code: @[simp]
theorem default_eq : (default : Perm α) = 1 
goal: default = 1

full_name: Equiv.Perm.equivUnitsEnd
code: /-- The permutation of a type is equivalent to the units group of the endomorphisms monoid of this
type. -/
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
goal: Equiv.Perm α ≃* (Function.End α)ˣ

full_name: Equiv.Perm.equivUnitsEnd_symm_apply_symm_apply
code: /-- The permutation of a type is equivalent to the units group of the endomorphisms monoid of this
type. -/
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
goal: ⇑(Equiv.symm (Equiv.Perm.equivUnitsEnd.symm u)) = ↑u⁻¹

full_name: Equiv.Perm.val_inv_equivUnitsEnd_apply
code: /-- The permutation of a type is equivalent to the units group of the endomorphisms monoid of this
type. -/
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
goal: ∀ (a : α), ↑(Equiv.Perm.equivUnitsEnd e)⁻¹ a = (Equiv.symm e).toFun a

full_name: Equiv.Perm.val_equivUnitsEnd_apply
code: /-- The permutation of a type is equivalent to the units group of the endomorphisms monoid of this
type. -/
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
goal: ∀ (a : α), ↑(Equiv.Perm.equivUnitsEnd e) a = e.toFun a

full_name: Equiv.Perm.equivUnitsEnd_symm_apply_apply
code: /-- The permutation of a type is equivalent to the units group of the endomorphisms monoid of this
type. -/
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
goal: ⇑(Equiv.Perm.equivUnitsEnd.symm u) = ↑u

full_name: MonoidHom.toHomPerm_apply_symm_apply
code: /-- Lift a monoid homomorphism `f : G →* Function.End α` to a monoid homomorphism
`f : G →* Equiv.Perm α`. -/
@[simps!]
def _root_.MonoidHom.toHomPerm {G : Type*} [Group G] (f : G →* Function.End α) : G →* Perm α 
goal: ∀ (a : G), ⇑(Equiv.symm (f.toHomPerm a)) = ↑(f.toHomUnits a)⁻¹

full_name: MonoidHom.toHomPerm
code: /-- Lift a monoid homomorphism `f : G →* Function.End α` to a monoid homomorphism
`f : G →* Equiv.Perm α`. -/
@[simps!]
def _root_.MonoidHom.toHomPerm {G : Type*} [Group G] (f : G →* Function.End α) : G →* Perm α 
goal: G →* Equiv.Perm α

full_name: MonoidHom.toHomPerm_apply_apply
code: /-- Lift a monoid homomorphism `f : G →* Function.End α` to a monoid homomorphism
`f : G →* Equiv.Perm α`. -/
@[simps!]
def _root_.MonoidHom.toHomPerm {G : Type*} [Group G] (f : G →* Function.End α) : G →* Perm α 
goal: ∀ (a : G), ⇑(f.toHomPerm a) = f a

full_name: Equiv.Perm.mul_apply
code: theorem mul_apply (f g : Perm α) (x) : (f * g) x = f (g x) 
goal: (f * g) x = f (g x)

full_name: Equiv.Perm.one_apply
code: theorem one_apply (x) : (1 : Perm α) x = x 
goal: 1 x = x

full_name: Equiv.Perm.inv_apply_self
code: @[simp]
theorem inv_apply_self (f : Perm α) (x) : f⁻¹ (f x) = x 
goal: f⁻¹ (f x) = x

full_name: Equiv.Perm.apply_inv_self
code: @[simp]
theorem apply_inv_self (f : Perm α) (x) : f (f⁻¹ x) = x 
goal: f (f⁻¹ x) = x

full_name: Equiv.Perm.one_def
code: theorem one_def : (1 : Perm α) = Equiv.refl α 
goal: 1 = Equiv.refl α

full_name: Equiv.Perm.mul_def
code: theorem mul_def (f g : Perm α) : f * g = g.trans f 
goal: f * g = Equiv.trans g f

full_name: Equiv.Perm.inv_def
code: theorem inv_def (f : Perm α) : f⁻¹ = f.symm 
goal: f⁻¹ = Equiv.symm f

full_name: Equiv.Perm.coe_one
code: @[simp, norm_cast] lemma coe_one : ⇑(1 : Perm α) = id 
goal: ⇑1 = id

full_name: Equiv.Perm.coe_mul
code: @[simp, norm_cast] lemma coe_mul (f g : Perm α) : ⇑(f * g) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: Equiv.Perm.coe_pow
code: @[norm_cast] lemma coe_pow (f : Perm α) (n : ℕ) : ⇑(f ^ n) = f^[n] 
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: Equiv.Perm.iterate_eq_pow
code: @[simp] lemma iterate_eq_pow (f : Perm α) (n : ℕ) : f^[n] = ⇑(f ^ n) 
goal: (⇑f)^[n] = ⇑(f ^ n)

full_name: Equiv.Perm.eq_inv_iff_eq
code: theorem eq_inv_iff_eq {f : Perm α} {x y : α} : x = f⁻¹ y ↔ f x = y 
goal: x = f⁻¹ y ↔ f x = y

full_name: Equiv.Perm.inv_eq_iff_eq
code: theorem inv_eq_iff_eq {f : Perm α} {x y : α} : f⁻¹ x = y ↔ x = f y 
goal: f⁻¹ x = y ↔ x = f y

full_name: Equiv.Perm.zpow_apply_comm
code: theorem zpow_apply_comm {α : Type*} (σ : Perm α) (m n : ℤ) {x : α} :
    (σ ^ m) ((σ ^ n) x) = (σ ^ n) ((σ ^ m) x) 
goal: (σ ^ m) ((σ ^ n) x) = (σ ^ n) ((σ ^ m) x)

full_name: Equiv.Perm.image_inv
code: @[simp] lemma image_inv (f : Perm α) (s : Set α) : ↑f⁻¹ '' s = f ⁻¹' s 
goal: ⇑f⁻¹ '' s = ⇑f ⁻¹' s

full_name: Equiv.Perm.preimage_inv
code: @[simp] lemma preimage_inv (f : Perm α) (s : Set α) : ↑f⁻¹ ⁻¹' s = f '' s 
goal: ⇑f⁻¹ ⁻¹' s = ⇑f '' s

full_name: Equiv.Perm.trans_one
code: @[simp]
theorem trans_one {α : Sort*} {β : Type*} (e : α ≃ β) : e.trans (1 : Perm β) = e 
goal: e.trans 1 = e

full_name: Equiv.Perm.mul_refl
code: @[simp]
theorem mul_refl (e : Perm α) : e * Equiv.refl α = e 
goal: e * Equiv.refl α = e

full_name: Equiv.Perm.one_symm
code: @[simp]
theorem one_symm : (1 : Perm α).symm = 1 
goal: Equiv.symm 1 = 1

full_name: Equiv.Perm.refl_inv
code: @[simp]
theorem refl_inv : (Equiv.refl α : Perm α)⁻¹ = 1 
goal: (Equiv.refl α)⁻¹ = 1

full_name: Equiv.Perm.one_trans
code: @[simp]
theorem one_trans {α : Type*} {β : Sort*} (e : α ≃ β) : (1 : Perm α).trans e = e 
goal: Equiv.trans 1 e = e

full_name: Equiv.Perm.refl_mul
code: @[simp]
theorem refl_mul (e : Perm α) : Equiv.refl α * e = e 
goal: Equiv.refl α * e = e

full_name: Equiv.Perm.inv_trans_self
code: @[simp]
theorem inv_trans_self (e : Perm α) : e⁻¹.trans e = 1 
goal: Equiv.trans e⁻¹ e = 1

full_name: Equiv.Perm.mul_symm
code: @[simp]
theorem mul_symm (e : Perm α) : e * e.symm = 1 
goal: e * Equiv.symm e = 1

full_name: Equiv.Perm.self_trans_inv
code: @[simp]
theorem self_trans_inv (e : Perm α) : e.trans e⁻¹ = 1 
goal: Equiv.trans e e⁻¹ = 1

full_name: Equiv.Perm.symm_mul
code: @[simp]
theorem symm_mul (e : Perm α) : e.symm * e = 1 
goal: Equiv.symm e * e = 1

full_name: Equiv.Perm.sumCongr_mul
code: @[simp]
theorem sumCongr_mul {α β : Type*} (e : Perm α) (f : Perm β) (g : Perm α) (h : Perm β) :
    sumCongr e f * sumCongr g h = sumCongr (e * g) (f * h) 
goal: e.sumCongr f * g.sumCongr h = (e * g).sumCongr (f * h)

full_name: Equiv.Perm.sumCongr_inv
code: @[simp]
theorem sumCongr_inv {α β : Type*} (e : Perm α) (f : Perm β) :
    (sumCongr e f)⁻¹ = sumCongr e⁻¹ f⁻¹ 
goal: (e.sumCongr f)⁻¹ = e⁻¹.sumCongr f⁻¹

full_name: Equiv.Perm.sumCongr_one
code: @[simp]
theorem sumCongr_one {α β : Type*} : sumCongr (1 : Perm α) (1 : Perm β) = 1 
goal: Equiv.Perm.sumCongr 1 1 = 1

full_name: Equiv.Perm.sumCongrHom
code: /-- `Equiv.Perm.sumCongr` as a `MonoidHom`, with its two arguments bundled into a single `Prod`.

This is particularly useful for its `MonoidHom.range` projection, which is the subgroup of
permutations which do not exchange elements between `α` and `β`. -/
@[simps]
def sumCongrHom (α β : Type*) : Perm α × Perm β →* Perm (α ⊕ β) 
goal: Equiv.Perm α × Equiv.Perm β →* Equiv.Perm (α ⊕ β)

full_name: Equiv.Perm.sumCongrHom_apply
code: /-- `Equiv.Perm.sumCongr` as a `MonoidHom`, with its two arguments bundled into a single `Prod`.

This is particularly useful for its `MonoidHom.range` projection, which is the subgroup of
permutations which do not exchange elements between `α` and `β`. -/
@[simps]
def sumCongrHom (α β : Type*) : Perm α × Perm β →* Perm (α ⊕ β) 
goal: (Equiv.Perm.sumCongrHom α β) a = a.1.sumCongr a.2

full_name: Equiv.Perm.sumCongrHom_injective
code: theorem sumCongrHom_injective {α β : Type*} : Function.Injective (sumCongrHom α β) 
goal: Function.Injective ⇑(Equiv.Perm.sumCongrHom α β)

full_name: Equiv.Perm.sumCongr_swap_one
code: @[simp]
theorem sumCongr_swap_one {α β : Type*} [DecidableEq α] [DecidableEq β] (i j : α) :
    sumCongr (Equiv.swap i j) (1 : Perm β) = Equiv.swap (Sum.inl i) (Sum.inl j) 
goal: (Equiv.swap i j).sumCongr 1 = Equiv.swap (Sum.inl i) (Sum.inl j)

full_name: Equiv.Perm.sumCongr_one_swap
code: @[simp]
theorem sumCongr_one_swap {α β : Type*} [DecidableEq α] [DecidableEq β] (i j : β) :
    sumCongr (1 : Perm α) (Equiv.swap i j) = Equiv.swap (Sum.inr i) (Sum.inr j) 
goal: Equiv.Perm.sumCongr 1 (Equiv.swap i j) = Equiv.swap (Sum.inr i) (Sum.inr j)

full_name: Equiv.Perm.sigmaCongrRight_mul
code: @[simp]
theorem sigmaCongrRight_mul {α : Type*} {β : α → Type*} (F : ∀ a, Perm (β a))
    (G : ∀ a, Perm (β a)) : sigmaCongrRight F * sigmaCongrRight G = sigmaCongrRight (F * G) 
goal: Equiv.Perm.sigmaCongrRight F * Equiv.Perm.sigmaCongrRight G = Equiv.Perm.sigmaCongrRight (F * G)

full_name: Equiv.Perm.sigmaCongrRight_inv
code: @[simp]
theorem sigmaCongrRight_inv {α : Type*} {β : α → Type*} (F : ∀ a, Perm (β a)) :
    (sigmaCongrRight F)⁻¹ = sigmaCongrRight fun a => (F a)⁻¹ 
goal: (Equiv.Perm.sigmaCongrRight F)⁻¹ = Equiv.Perm.sigmaCongrRight fun a => (F a)⁻¹

full_name: Equiv.Perm.sigmaCongrRight_one
code: @[simp]
theorem sigmaCongrRight_one {α : Type*} {β : α → Type*} :
    sigmaCongrRight (1 : ∀ a, Equiv.Perm <| β a) = 1 
goal: Equiv.Perm.sigmaCongrRight 1 = 1

full_name: Equiv.Perm.sigmaCongrRightHom
code: /-- `Equiv.Perm.sigmaCongrRight` as a `MonoidHom`.

This is particularly useful for its `MonoidHom.range` projection, which is the subgroup of
permutations which do not exchange elements between fibers. -/
@[simps]
def sigmaCongrRightHom {α : Type*} (β : α → Type*) : (∀ a, Perm (β a)) →* Perm (Σa, β a) 
goal: ((a : α) → Equiv.Perm (β a)) →* Equiv.Perm ((a : α) × β a)

full_name: Equiv.Perm.sigmaCongrRightHom_apply
code: /-- `Equiv.Perm.sigmaCongrRight` as a `MonoidHom`.

This is particularly useful for its `MonoidHom.range` projection, which is the subgroup of
permutations which do not exchange elements between fibers. -/
@[simps]
def sigmaCongrRightHom {α : Type*} (β : α → Type*) : (∀ a, Perm (β a)) →* Perm (Σa, β a) 
goal: (Equiv.Perm.sigmaCongrRightHom β) F = Equiv.Perm.sigmaCongrRight F

full_name: Equiv.Perm.sigmaCongrRightHom_injective
code: theorem sigmaCongrRightHom_injective {α : Type*} {β : α → Type*} :
    Function.Injective (sigmaCongrRightHom β) 
goal: Function.Injective ⇑(Equiv.Perm.sigmaCongrRightHom β)

full_name: Equiv.Perm.subtypeCongrHom_apply
code: /-- `Equiv.Perm.subtypeCongr` as a `MonoidHom`. -/
@[simps]
def subtypeCongrHom (p : α → Prop) [DecidablePred p] :
    Perm { a // p a } × Perm { a // ¬p a } →* Perm α 
goal: (Equiv.Perm.subtypeCongrHom p) pair = pair.1.subtypeCongr pair.2

full_name: Equiv.Perm.subtypeCongrHom
code: /-- `Equiv.Perm.subtypeCongr` as a `MonoidHom`. -/
@[simps]
def subtypeCongrHom (p : α → Prop) [DecidablePred p] :
    Perm { a // p a } × Perm { a // ¬p a } →* Perm α 
goal: Equiv.Perm { a // p a } × Equiv.Perm { a // ¬p a } →* Equiv.Perm α

full_name: Equiv.Perm.subtypeCongrHom_injective
code: theorem subtypeCongrHom_injective (p : α → Prop) [DecidablePred p] :
    Function.Injective (subtypeCongrHom p) 
goal: Function.Injective ⇑(Equiv.Perm.subtypeCongrHom p)

full_name: Equiv.Perm.permCongr_eq_mul
code: /-- If `e` is also a permutation, we can write `permCongr`
completely in terms of the group structure. -/
@[simp]
theorem permCongr_eq_mul (e p : Perm α) : e.permCongr p = e * p * e⁻¹ 
goal: (Equiv.permCongr e) p = e * p * e⁻¹

full_name: Equiv.Perm.extendDomain_one
code: @[simp]
theorem extendDomain_one : extendDomain 1 f = 1 
goal: Equiv.Perm.extendDomain 1 f = 1

full_name: Equiv.Perm.extendDomain_inv
code: @[simp]
theorem extendDomain_inv : (e.extendDomain f)⁻¹ = e⁻¹.extendDomain f 
goal: (e.extendDomain f)⁻¹ = e⁻¹.extendDomain f

full_name: Equiv.Perm.extendDomain_mul
code: @[simp]
theorem extendDomain_mul (e e' : Perm α) :
    e.extendDomain f * e'.extendDomain f = (e * e').extendDomain f 
goal: e.extendDomain f * e'.extendDomain f = (e * e').extendDomain f

full_name: Equiv.Perm.extendDomainHom
code: /-- `extendDomain` as a group homomorphism -/
@[simps]
def extendDomainHom : Perm α →* Perm β 
goal: Equiv.Perm α →* Equiv.Perm β

full_name: Equiv.Perm.extendDomainHom_apply
code: /-- `extendDomain` as a group homomorphism -/
@[simps]
def extendDomainHom : Perm α →* Perm β 
goal: (Equiv.Perm.extendDomainHom f) e = e.extendDomain f

full_name: Equiv.Perm.extendDomainHom_injective
code: theorem extendDomainHom_injective : Function.Injective (extendDomainHom f) 
goal: Function.Injective ⇑(Equiv.Perm.extendDomainHom f)

full_name: Equiv.Perm.extendDomain_eq_one_iff
code: @[simp]
theorem extendDomain_eq_one_iff {e : Perm α} {f : α ≃ Subtype p} : e.extendDomain f = 1 ↔ e = 1 
goal: e.extendDomain f = 1 ↔ e = 1

full_name: Equiv.Perm.extendDomain_pow
code: @[simp]
lemma extendDomain_pow (n : ℕ) : (e ^ n).extendDomain f = e.extendDomain f ^ n 
goal: (e ^ n).extendDomain f = e.extendDomain f ^ n

full_name: Equiv.Perm.extendDomain_zpow
code: @[simp]
lemma extendDomain_zpow (n : ℤ) : (e ^ n).extendDomain f = e.extendDomain f ^ n 
goal: (e ^ n).extendDomain f = e.extendDomain f ^ n

full_name: Equiv.Perm.subtypePerm
code: /-- If the permutation `f` fixes the subtype `{x // p x}`, then this returns the permutation
  on `{x // p x}` induced by `f`. -/
def subtypePerm (f : Perm α) (h : ∀ x, p x ↔ p (f x)) : Perm { x // p x } 
goal: Equiv.Perm { x // p x }

full_name: Equiv.Perm.subtypePerm_apply
code: @[simp]
theorem subtypePerm_apply (f : Perm α) (h : ∀ x, p x ↔ p (f x)) (x : { x // p x }) :
    subtypePerm f h x = ⟨f x, (h _).1 x.2⟩ 
goal: (f.subtypePerm h) x = ⟨f ↑x, ⋯⟩

full_name: Equiv.Perm.subtypePerm_one
code: @[simp]
theorem subtypePerm_one (p : α → Prop) (h := fun _ => Iff.rfl) : @subtypePerm α p 1 h = 1 
goal: Equiv.Perm.subtypePerm 1 h = 1

full_name: Equiv.Perm.subtypePerm_mul
code: @[simp]
theorem subtypePerm_mul (f g : Perm α) (hf hg) :
    (f.subtypePerm hf * g.subtypePerm hg : Perm { x // p x }) =
      (f * g).subtypePerm fun _ => (hg _).trans <| hf _ 
goal: f.subtypePerm hf * g.subtypePerm hg = (f * g).subtypePerm ⋯

full_name: _private.Mathlib.GroupTheory.Perm.Basic.0.Equiv.Perm.inv_aux
code: private theorem inv_aux : (∀ x, p x ↔ p (f x)) ↔ ∀ x, p x ↔ p (f⁻¹ x) 
goal: (∀ (x : α), p x ↔ p (f x)) ↔ ∀ (x : α), p x ↔ p (f⁻¹ x)

full_name: Equiv.Perm.subtypePerm_inv
code: /-- See `Equiv.Perm.inv_subtypePerm`-/
theorem subtypePerm_inv (f : Perm α) (hf) :
    f⁻¹.subtypePerm hf = (f.subtypePerm <| inv_aux.2 hf : Perm { x // p x })⁻¹ 
goal: f⁻¹.subtypePerm hf = (f.subtypePerm ⋯)⁻¹

full_name: Equiv.Perm.inv_subtypePerm
code: /-- See `Equiv.Perm.subtypePerm_inv`-/
@[simp]
theorem inv_subtypePerm (f : Perm α) (hf) :
    (f.subtypePerm hf : Perm { x // p x })⁻¹ = f⁻¹.subtypePerm (inv_aux.1 hf) 
goal: (f.subtypePerm hf)⁻¹ = f⁻¹.subtypePerm ⋯

full_name: _private.Mathlib.GroupTheory.Perm.Basic.0.Equiv.Perm.pow_aux
code: private theorem pow_aux (hf : ∀ x, p x ↔ p (f x)) : ∀ {n : ℕ} (x), p x ↔ p ((f ^ n) x)
  
goal: p x ↔ p ((f ^ n) x)

full_name: Equiv.Perm.subtypePerm_pow
code: @[simp]
theorem subtypePerm_pow (f : Perm α) (n : ℕ) (hf) :
    (f.subtypePerm hf : Perm { x // p x }) ^ n = (f ^ n).subtypePerm (pow_aux hf) 
goal: f.subtypePerm hf ^ n = (f ^ n).subtypePerm ⋯

full_name: _private.Mathlib.GroupTheory.Perm.Basic.0.Equiv.Perm.zpow_aux
code: private theorem zpow_aux (hf : ∀ x, p x ↔ p (f x)) : ∀ {n : ℤ} (x), p x ↔ p ((f ^ n) x)
  
goal: p x ↔ p ((f ^ n) x)

full_name: Equiv.Perm.subtypePerm_zpow
code: @[simp]
theorem subtypePerm_zpow (f : Perm α) (n : ℤ) (hf) :
    (f.subtypePerm hf ^ n : Perm { x // p x }) = (f ^ n).subtypePerm (zpow_aux hf) 
goal: f.subtypePerm hf ^ n = (f ^ n).subtypePerm ⋯

full_name: Equiv.Perm.ofSubtype
code: /-- The inclusion map of permutations on a subtype of `α` into permutations of `α`,
  fixing the other points. -/
def ofSubtype : Perm (Subtype p) →* Perm α 
goal: Equiv.Perm (Subtype p) →* Equiv.Perm α

full_name: Equiv.Perm.ofSubtype_subtypePerm
code: theorem ofSubtype_subtypePerm {f : Perm α} (h₁ : ∀ x, p x ↔ p (f x)) (h₂ : ∀ x, f x ≠ x → p x) :
    ofSubtype (subtypePerm f h₁) = f 
goal: Equiv.Perm.ofSubtype (f.subtypePerm h₁) = f

full_name: Equiv.Perm.ofSubtype_apply_of_mem
code: theorem ofSubtype_apply_of_mem (f : Perm (Subtype p)) (ha : p a) : ofSubtype f a = f ⟨a, ha⟩ 
goal: (Equiv.Perm.ofSubtype f) a = ↑(f ⟨a, ha⟩)

full_name: Equiv.Perm.ofSubtype_apply_coe
code: @[simp]
theorem ofSubtype_apply_coe (f : Perm (Subtype p)) (x : Subtype p) : ofSubtype f x = f x 
goal: (Equiv.Perm.ofSubtype f) ↑x = ↑(f x)

full_name: Equiv.Perm.ofSubtype_apply_of_not_mem
code: theorem ofSubtype_apply_of_not_mem (f : Perm (Subtype p)) (ha : ¬p a) : ofSubtype f a = a 
goal: (Equiv.Perm.ofSubtype f) a = a

full_name: Equiv.Perm.mem_iff_ofSubtype_apply_mem
code: theorem mem_iff_ofSubtype_apply_mem (f : Perm (Subtype p)) (x : α) :
    p x ↔ p ((ofSubtype f : α → α) x) 
goal: p x ↔ p ((Equiv.Perm.ofSubtype f) x)

full_name: Equiv.Perm.subtypePerm_ofSubtype
code: @[simp]
theorem subtypePerm_ofSubtype (f : Perm (Subtype p)) :
    subtypePerm (ofSubtype f) (mem_iff_ofSubtype_apply_mem f) = f 
goal: (Equiv.Perm.ofSubtype f).subtypePerm ⋯ = f

full_name: Equiv.Perm.subtypeEquivSubtypePerm_apply_coe
code: /-- Permutations on a subtype are equivalent to permutations on the original type that fix pointwise
the rest. -/
@[simps]
protected def subtypeEquivSubtypePerm (p : α → Prop) [DecidablePred p] :
    Perm (Subtype p) ≃ { f : Perm α // ∀ a, ¬p a → f a = a } 
goal: ↑((Equiv.Perm.subtypeEquivSubtypePerm p) f) = Equiv.Perm.ofSubtype f

full_name: Equiv.Perm.subtypeEquivSubtypePerm
code: /-- Permutations on a subtype are equivalent to permutations on the original type that fix pointwise
the rest. -/
@[simps]
protected def subtypeEquivSubtypePerm (p : α → Prop) [DecidablePred p] :
    Perm (Subtype p) ≃ { f : Perm α // ∀ a, ¬p a → f a = a } 
goal: Equiv.Perm (Subtype p) ≃ { f // ∀ (a : α), ¬p a → f a = a }

full_name: Equiv.Perm.subtypeEquivSubtypePerm_symm_apply
code: /-- Permutations on a subtype are equivalent to permutations on the original type that fix pointwise
the rest. -/
@[simps]
protected def subtypeEquivSubtypePerm (p : α → Prop) [DecidablePred p] :
    Perm (Subtype p) ≃ { f : Perm α // ∀ a, ¬p a → f a = a } 
goal: (Equiv.Perm.subtypeEquivSubtypePerm p).symm f = (↑f).subtypePerm ⋯

full_name: Equiv.Perm.subtypeEquivSubtypePerm_apply_of_mem
code: theorem subtypeEquivSubtypePerm_apply_of_mem (f : Perm (Subtype p)) (h : p a) :
    -- Porting note: was `Perm.subtypeEquivSubtypePerm p f a`
    ((Perm.subtypeEquivSubtypePerm p).toFun f).1 a = f ⟨a, h⟩ 
goal: ↑((Equiv.Perm.subtypeEquivSubtypePerm p).toFun f) a = ↑(f ⟨a, h⟩)

full_name: Equiv.Perm.subtypeEquivSubtypePerm_apply_of_not_mem
code: theorem subtypeEquivSubtypePerm_apply_of_not_mem (f : Perm (Subtype p)) (h : ¬p a) :
    -- Porting note: was `Perm.subtypeEquivSubtypePerm p f a`
    ((Perm.subtypeEquivSubtypePerm p).toFun f).1 a = a 
goal: ↑((Equiv.Perm.subtypeEquivSubtypePerm p).toFun f) a = a

full_name: Equiv.swap_inv
code: @[simp]
theorem swap_inv (x y : α) : (swap x y)⁻¹ = swap x y 
goal: (Equiv.swap x y)⁻¹ = Equiv.swap x y

full_name: Equiv.swap_mul_self
code: @[simp]
theorem swap_mul_self (i j : α) : swap i j * swap i j = 1 
goal: Equiv.swap i j * Equiv.swap i j = 1

full_name: Equiv.swap_mul_eq_mul_swap
code: theorem swap_mul_eq_mul_swap (f : Perm α) (x y : α) : swap x y * f = f * swap (f⁻¹ x) (f⁻¹ y) 
goal: Equiv.swap x y * f = f * Equiv.swap (f⁻¹ x) (f⁻¹ y)

full_name: Equiv.mul_swap_eq_swap_mul
code: theorem mul_swap_eq_swap_mul (f : Perm α) (x y : α) : f * swap x y = swap (f x) (f y) * f 
goal: f * Equiv.swap x y = Equiv.swap (f x) (f y) * f

full_name: Equiv.swap_apply_apply
code: theorem swap_apply_apply (f : Perm α) (x y : α) : swap (f x) (f y) = f * swap x y * f⁻¹ 
goal: Equiv.swap (f x) (f y) = f * Equiv.swap x y * f⁻¹

full_name: Equiv.swap_smul_self_smul
code: @[simp]
theorem swap_smul_self_smul [MulAction (Perm α) β] (i j : α) (x : β) :
    swap i j • swap i j • x = x 
goal: Equiv.swap i j • Equiv.swap i j • x = x

full_name: Equiv.swap_smul_involutive
code: theorem swap_smul_involutive [MulAction (Perm α) β] (i j : α) :
    Function.Involutive (swap i j • · : β → β) 
goal: Function.Involutive fun x => Equiv.swap i j • x

full_name: Equiv.swap_mul_self_mul
code: /-- Left-multiplying a permutation with `swap i j` twice gives the original permutation.

  This specialization of `swap_mul_self` is useful when using cosets of permutations.
-/
@[simp]
theorem swap_mul_self_mul (i j : α) (σ : Perm α) : Equiv.swap i j * (Equiv.swap i j * σ) = σ 
goal: Equiv.swap i j * (Equiv.swap i j * σ) = σ

full_name: Equiv.mul_swap_mul_self
code: /-- Right-multiplying a permutation with `swap i j` twice gives the original permutation.

  This specialization of `swap_mul_self` is useful when using cosets of permutations.
-/
@[simp]
theorem mul_swap_mul_self (i j : α) (σ : Perm α) : σ * Equiv.swap i j * Equiv.swap i j = σ 
goal: σ * Equiv.swap i j * Equiv.swap i j = σ

full_name: Equiv.swap_mul_involutive
code: /-- A stronger version of `mul_right_injective` -/
@[simp]
theorem swap_mul_involutive (i j : α) : Function.Involutive (Equiv.swap i j * ·) 
goal: Function.Involutive fun x => Equiv.swap i j * x

full_name: Equiv.mul_swap_involutive
code: /-- A stronger version of `mul_left_injective` -/
@[simp]
theorem mul_swap_involutive (i j : α) : Function.Involutive (· * Equiv.swap i j) 
goal: Function.Involutive fun x => x * Equiv.swap i j

full_name: Equiv.swap_eq_one_iff
code: @[simp]
theorem swap_eq_one_iff {i j : α} : swap i j = (1 : Perm α) ↔ i = j 
goal: Equiv.swap i j = 1 ↔ i = j

full_name: Equiv.swap_mul_eq_iff
code: theorem swap_mul_eq_iff {i j : α} {σ : Perm α} : swap i j * σ = σ ↔ i = j 
goal: Equiv.swap i j * σ = σ ↔ i = j

full_name: Equiv.mul_swap_eq_iff
code: theorem mul_swap_eq_iff {i j : α} {σ : Perm α} : σ * swap i j = σ ↔ i = j 
goal: σ * Equiv.swap i j = σ ↔ i = j

full_name: Equiv.swap_mul_swap_mul_swap
code: theorem swap_mul_swap_mul_swap {x y z : α} (hxy : x ≠ y) (hxz : x ≠ z) :
    swap y z * swap x y * swap y z = swap z x 
goal: Equiv.swap y z * Equiv.swap x y * Equiv.swap y z = Equiv.swap z x

full_name: Equiv.addLeft_zero
code: @[simp] lemma addLeft_zero : Equiv.addLeft (0 : α) = 1 
goal: Equiv.addLeft 0 = 1

full_name: Equiv.addRight_zero
code: @[simp] lemma addRight_zero : Equiv.addRight (0 : α) = 1 
goal: Equiv.addRight 0 = 1

full_name: Equiv.addLeft_add
code: @[simp] lemma addLeft_add : Equiv.addLeft (a + b) = Equiv.addLeft a * Equiv.addLeft b 
goal: Equiv.addLeft (a + b) = Equiv.addLeft a * Equiv.addLeft b

full_name: Equiv.addRight_add
code: @[simp] lemma addRight_add : Equiv.addRight (a + b) = Equiv.addRight b * Equiv.addRight a 
goal: Equiv.addRight (a + b) = Equiv.addRight b * Equiv.addRight a

full_name: Equiv.inv_addLeft
code: @[simp] lemma inv_addLeft : (Equiv.addLeft a)⁻¹ = Equiv.addLeft (-a) 
goal: (Equiv.addLeft a)⁻¹ = Equiv.addLeft (-a)

full_name: Equiv.inv_addRight
code: @[simp] lemma inv_addRight : (Equiv.addRight a)⁻¹ = Equiv.addRight (-a) 
goal: (Equiv.addRight a)⁻¹ = Equiv.addRight (-a)

full_name: Equiv.pow_addLeft
code: @[simp] lemma pow_addLeft (n : ℕ) : Equiv.addLeft a ^ n = Equiv.addLeft (n • a) 
goal: Equiv.addLeft a ^ n = Equiv.addLeft (n • a)

full_name: Equiv.pow_addRight
code: @[simp] lemma pow_addRight (n : ℕ) : Equiv.addRight a ^ n = Equiv.addRight (n • a) 
goal: Equiv.addRight a ^ n = Equiv.addRight (n • a)

full_name: Equiv.zpow_addLeft
code: @[simp] lemma zpow_addLeft (n : ℤ) : Equiv.addLeft a ^ n = Equiv.addLeft (n • a) 
goal: Equiv.addLeft a ^ n = Equiv.addLeft (n • a)

full_name: Equiv.zpow_addRight
code: @[simp] lemma zpow_addRight : ∀ (n : ℤ), Equiv.addRight a ^ n = Equiv.addRight (n • a)
  
goal: Equiv.addRight a ^ n = Equiv.addRight (n • a)

full_name: Equiv.mulLeft_one
code: @[to_additive existing (attr := simp)]
lemma mulLeft_one : Equiv.mulLeft (1 : α) = 1 
goal: Equiv.mulLeft 1 = 1

full_name: Equiv.mulRight_one
code: @[to_additive existing (attr := simp)]
lemma mulRight_one : Equiv.mulRight (1 : α) = 1 
goal: Equiv.mulRight 1 = 1

full_name: Equiv.mulLeft_mul
code: @[to_additive existing (attr := simp)]
lemma mulLeft_mul : Equiv.mulLeft (a * b) = Equiv.mulLeft a * Equiv.mulLeft b 
goal: Equiv.mulLeft (a * b) = Equiv.mulLeft a * Equiv.mulLeft b

full_name: Equiv.mulRight_mul
code: @[to_additive existing (attr := simp)]
lemma mulRight_mul : Equiv.mulRight (a * b) = Equiv.mulRight b * Equiv.mulRight a 
goal: Equiv.mulRight (a * b) = Equiv.mulRight b * Equiv.mulRight a

full_name: Equiv.inv_mulLeft
code: @[to_additive existing (attr := simp) inv_addLeft]
lemma inv_mulLeft : (Equiv.mulLeft a)⁻¹ = Equiv.mulLeft a⁻¹ 
goal: (Equiv.mulLeft a)⁻¹ = Equiv.mulLeft a⁻¹

full_name: Equiv.inv_mulRight
code: @[to_additive existing (attr := simp) inv_addRight]
lemma inv_mulRight : (Equiv.mulRight a)⁻¹ = Equiv.mulRight a⁻¹ 
goal: (Equiv.mulRight a)⁻¹ = Equiv.mulRight a⁻¹

full_name: Equiv.pow_mulLeft
code: @[to_additive existing (attr := simp) pow_addLeft]
lemma pow_mulLeft (n : ℕ) : Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n) 
goal: Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n)

full_name: Equiv.pow_mulRight
code: @[to_additive existing (attr := simp) pow_addRight]
lemma pow_mulRight (n : ℕ) : Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n) 
goal: Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)

full_name: Equiv.zpow_mulLeft
code: @[to_additive existing (attr := simp) zpow_addLeft]
lemma zpow_mulLeft (n : ℤ) : Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n) 
goal: Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n)

full_name: Equiv.zpow_mulRight
code: @[to_additive existing (attr := simp) zpow_addRight]
lemma zpow_mulRight : ∀ n : ℤ, Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)
  
goal: Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)

full_name: Set.BijOn.perm_inv
code: lemma BijOn.perm_inv (hf : BijOn f s s) : BijOn ↑(f⁻¹) s s 
goal: Set.BijOn (⇑f⁻¹) s s

full_name: Set.MapsTo.perm_pow
code: lemma MapsTo.perm_pow : MapsTo f s s → ∀ n : ℕ, MapsTo (f ^ n) s s 
goal: Set.MapsTo (⇑f) s s → ∀ (n : ℕ), Set.MapsTo (⇑(f ^ n)) s s

full_name: Set.SurjOn.perm_pow
code: lemma SurjOn.perm_pow : SurjOn f s s → ∀ n : ℕ, SurjOn (f ^ n) s s 
goal: Set.SurjOn (⇑f) s s → ∀ (n : ℕ), Set.SurjOn (⇑(f ^ n)) s s

full_name: Set.BijOn.perm_pow
code: lemma BijOn.perm_pow : BijOn f s s → ∀ n : ℕ, BijOn (f ^ n) s s 
goal: Set.BijOn (⇑f) s s → ∀ (n : ℕ), Set.BijOn (⇑(f ^ n)) s s

full_name: Set.BijOn.perm_zpow
code: lemma BijOn.perm_zpow (hf : BijOn f s s) : ∀ n : ℤ, BijOn (f ^ n) s s
  
goal: Set.BijOn (⇑(f ^ n)) s s