ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MulAction.IsBlock.def_mem
theorem IsBlock.def_mem {B : Set X} (hB : IsBlock G B) {a : X} {g : G} :
    a ∈ B → g • a ∈ B → g • B = B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B : Set X} (hB : MulAction.IsBlock G B) {a : X} {g : G}
Goal: a ∈ B → g • a ∈ B → g • B = B
-- MulAction.IsBlock.mk_subset
theorem IsBlock.mk_subset {B : Set X} :
    IsBlock G B ↔ ∀ {g : G} {b : X} (_ : b ∈ B) (_ : b ∈ g • B), g • B ⊆ B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B : Set X}
Goal: MulAction.IsBlock G B ↔ ∀ {g : G} {b : X}, b ∈ B → b ∈ g • B → g • B ⊆ B
-- MulAction.IsInvariantBlock.isFixedBlock
theorem IsInvariantBlock.isFixedBlock {B : Set X} (hfB : IsInvariantBlock G B) :
    IsFixedBlock G B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B : Set X} (hfB : MulAction.IsInvariantBlock G B)
Goal: MulAction.IsFixedBlock G B
-- MulAction.IsInvariantBlock.isBlock
theorem IsInvariantBlock.isBlock {B : Set X} (hfB : IsInvariantBlock G B) :
    IsBlock G B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B : Set X} (hfB : MulAction.IsInvariantBlock G B)
Goal: MulAction.IsBlock G B
-- MulAction.isFixedBlock_orbit
theorem isFixedBlock_orbit (a : X) : IsFixedBlock G (orbit G a) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] (a : X)
Goal: MulAction.IsFixedBlock G (MulAction.orbit G a)
-- MulAction.isBlock_orbit
theorem isBlock_orbit (a : X) : IsBlock G (orbit G a) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] (a : X)
Goal: MulAction.IsBlock G (MulAction.orbit G a)
-- MulAction.isFixedBlock_top
theorem isFixedBlock_top : IsFixedBlock G (⊤ : Set X) 
Arguments: {G : Type u_1} [Group G] (X : Type u_2) [MulAction G X]
Goal: MulAction.IsFixedBlock G ⊤
-- MulAction.isBlock_top
theorem isBlock_top : IsBlock G (⊤ : Set X) 
Arguments: {G : Type u_1} [Group G] (X : Type u_2) [MulAction G X]
Goal: MulAction.IsBlock G ⊤
-- MulAction.IsBlock.subgroup
theorem IsBlock.subgroup {H : Subgroup G} {B : Set X} (hfB : IsBlock G B) :
    IsBlock H B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {H : Subgroup G} {B : Set X} (hfB : MulAction.IsBlock G B)
Goal: MulAction.IsBlock (↥H) B
-- MulAction.IsBlock.preimage
theorem IsBlock.preimage {H Y : Type*} [Group H] [MulAction H Y]
    {φ : H → G} (j : Y →ₑ[φ] X) {B : Set X} (hB : IsBlock G B) :
    IsBlock H (j ⁻¹' B) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {H : Type u_3} {Y : Type u_4} [Group H] [MulAction H Y] {φ : H → G} (j : Y →ₑ[φ] X) {B : Set X} (hB : MulAction.IsBlock G B)
Goal: MulAction.IsBlock H (⇑j ⁻¹' B)
-- MulAction.IsBlock.image
theorem IsBlock.image {H Y : Type*} [Group H] [MulAction H Y]
    {φ : G →* H} (j : X →ₑ[φ] Y)
    (hφ : Function.Surjective φ) (hj : Function.Injective j)
    {B : Set X} (hB : IsBlock G B) :
    IsBlock H (j '' B) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {H : Type u_3} {Y : Type u_4} [Group H] [MulAction H Y] {φ : G →* H} (j : X →ₑ[⇑φ] Y) (hφ : Function.Surjective ⇑φ) (hj : Function.Injective ⇑j) {B : Set X} (hB : MulAction.IsBlock G B)
Goal: MulAction.IsBlock H (⇑j '' B)
-- MulAction.IsBlock.subtype_val_preimage
theorem IsBlock.subtype_val_preimage {C : SubMulAction G X} {B : Set X} (hB : IsBlock G B) :
    IsBlock G (Subtype.val ⁻¹' B : Set C) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {C : SubMulAction G X} {B : Set X} (hB : MulAction.IsBlock G B)
Goal: MulAction.IsBlock G (Subtype.val ⁻¹' B)
-- MulAction.IsBlock.iff_subtype_val
theorem IsBlock.iff_subtype_val {C : SubMulAction G X} {B : Set C} :
    IsBlock G B ↔ IsBlock G (Subtype.val '' B : Set X) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {C : SubMulAction G X} {B : Set ↥C}
Goal: MulAction.IsBlock G B ↔ MulAction.IsBlock G (Subtype.val '' B)
-- MulAction.IsBlock.iff_top
theorem IsBlock.iff_top (B : Set X) :
    IsBlock G B ↔ IsBlock (⊤ : Subgroup G) B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] (B : Set X)
Goal: MulAction.IsBlock G B ↔ MulAction.IsBlock (↥⊤) B
-- MulAction.IsBlock.inter
theorem IsBlock.inter {B₁ B₂ : Set X} (h₁ : IsBlock G B₁) (h₂ : IsBlock G B₂) :
    IsBlock G (B₁ ∩ B₂) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B₁ B₂ : Set X} (h₁ : MulAction.IsBlock G B₁) (h₂ : MulAction.IsBlock G B₂)
Goal: MulAction.IsBlock G (B₁ ∩ B₂)
-- MulAction.IsBlock.iInter
theorem IsBlock.iInter {ι : Type*} {B : ι → Set X} (hB : ∀ i : ι, IsBlock G (B i)) :
    IsBlock G (⋂ i, B i) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {ι : Type u_3} {B : ι → Set X} (hB : ∀ (i : ι), MulAction.IsBlock G (B i))
Goal: MulAction.IsBlock G (⋂ i, B i)
-- MulAction.IsBlock.of_subgroup_of_conjugate
theorem IsBlock.of_subgroup_of_conjugate {B : Set X} {H : Subgroup G} (hB : IsBlock H B) (g : G) :
    IsBlock (Subgroup.map (MulEquiv.toMonoidHom (MulAut.conj g)) H) (g • B) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B : Set X} {H : Subgroup G} (hB : MulAction.IsBlock (↥H) B) (g : G)
Goal: MulAction.IsBlock (↥(Subgroup.map (MulEquiv.toMonoidHom (MulAut.conj g)) H)) (g • B)
-- MulAction.IsBlock.translate
theorem IsBlock.translate {B : Set X} (g : G) (hB : IsBlock G B) :
    IsBlock G (g • B) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B : Set X} (g : G) (hB : MulAction.IsBlock G B)
Goal: MulAction.IsBlock G (g • B)
-- MulAction.IsBlock.isBlockSystem
theorem IsBlock.isBlockSystem [hGX : MulAction.IsPretransitive G X]
    {B : Set X} (hB : IsBlock G B) (hBe : B.Nonempty) :
    IsBlockSystem G (Set.range fun g : G => g • B) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] [hGX : MulAction.IsPretransitive G X] {B : Set X} (hB : MulAction.IsBlock G B) (hBe : B.Nonempty)
Goal: MulAction.IsBlockSystem G (Set.range fun g => g • B)
-- MulAction.smul_orbit_eq_orbit_smul
lemma smul_orbit_eq_orbit_smul (N : Subgroup G) [nN : N.Normal] (a : X) (g : G) :
    g • orbit N a = orbit N (g • a) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] (N : Subgroup G) [nN : N.Normal] (a : X) (g : G)
Goal: g • MulAction.orbit (↥N) a = MulAction.orbit (↥N) (g • a)
-- MulAction.orbit.isBlock_of_normal
theorem orbit.isBlock_of_normal {N : Subgroup G} [N.Normal] (a : X) :
    IsBlock G (orbit N a) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {N : Subgroup G} [N.Normal] (a : X)
Goal: MulAction.IsBlock G (MulAction.orbit (↥N) a)
-- MulAction.IsBlockSystem.of_normal
theorem IsBlockSystem.of_normal {N : Subgroup G} [N.Normal] :
    IsBlockSystem G (Set.range fun a : X => orbit N a) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {N : Subgroup G} [N.Normal]
Goal: MulAction.IsBlockSystem G (Set.range fun a => MulAction.orbit (↥N) a)
-- MulAction.IsBlock.of_orbit
theorem IsBlock.of_orbit {H : Subgroup G} {a : X} (hH : stabilizer G a ≤ H) :
    IsBlock G (MulAction.orbit H a) 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {H : Subgroup G} {a : X} (hH : MulAction.stabilizer G a ≤ H)
Goal: MulAction.IsBlock G (MulAction.orbit (↥H) a)
-- MulAction.IsBlock.stabilizer_le
theorem IsBlock.stabilizer_le {B : Set X} (hB : IsBlock G B) {a : X} (ha : a ∈ B) :
    stabilizer G a ≤ stabilizer G B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {B : Set X} (hB : MulAction.IsBlock G B) {a : X} (ha : a ∈ B)
Goal: MulAction.stabilizer G a ≤ MulAction.stabilizer G B
-- MulAction.IsBlock.orbit_stabilizer_eq
theorem IsBlock.orbit_stabilizer_eq
    [htGX : IsPretransitive G X] {B : Set X} (hB : IsBlock G B) {a : X} (ha : a ∈ B) :
    MulAction.orbit (stabilizer G B) a = B 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] [htGX : MulAction.IsPretransitive G X] {B : Set X} (hB : MulAction.IsBlock G B) {a : X} (ha : a ∈ B)
Goal: MulAction.orbit (↥(MulAction.stabilizer G B)) a = B
-- MulAction.stabilizer_orbit_eq
theorem stabilizer_orbit_eq {a : X} {H : Subgroup G} (hH : stabilizer G a ≤ H) :
    stabilizer G (orbit H a) = H 
Arguments: {G : Type u_1} [Group G] {X : Type u_2} [MulAction G X] {a : X} {H : Subgroup G} (hH : MulAction.stabilizer G a ≤ H)
Goal: MulAction.stabilizer G (MulAction.orbit (↥H) a) = H
-- Equiv.Perm.default_eq
@[simp]
theorem default_eq : (default : Perm α) = 1 
Arguments: {α : Type u}
Goal: default = 1
-- Equiv.Perm.equivUnitsEnd_symm_apply_symm_apply
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
Arguments: {α : Type u} (u : (Function.End α)ˣ)
Goal: ⇑(Equiv.symm (Equiv.Perm.equivUnitsEnd.symm u)) = ↑u⁻¹
-- Equiv.Perm.val_inv_equivUnitsEnd_apply
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: ∀ (a : α), ↑(Equiv.Perm.equivUnitsEnd e)⁻¹ a = (Equiv.symm e).toFun a
-- Equiv.Perm.val_equivUnitsEnd_apply
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: ∀ (a : α), ↑(Equiv.Perm.equivUnitsEnd e) a = e.toFun a
-- Equiv.Perm.equivUnitsEnd_symm_apply_apply
@[simps]
def equivUnitsEnd : Perm α ≃* Units (Function.End α) 
Arguments: {α : Type u} (u : (Function.End α)ˣ)
Goal: ⇑(Equiv.Perm.equivUnitsEnd.symm u) = ↑u
-- MonoidHom.toHomPerm_apply_symm_apply
@[simps!]
def _root_.MonoidHom.toHomPerm {G : Type*} [Group G] (f : G →* Function.End α) : G →* Perm α 
Arguments: {α : Type u} {G : Type u_1} [Group G] (f : G →* Function.End α)
Goal: ∀ (a : G), ⇑(Equiv.symm (f.toHomPerm a)) = ↑(f.toHomUnits a)⁻¹
-- MonoidHom.toHomPerm_apply_apply
@[simps!]
def _root_.MonoidHom.toHomPerm {G : Type*} [Group G] (f : G →* Function.End α) : G →* Perm α 
Arguments: {α : Type u} {G : Type u_1} [Group G] (f : G →* Function.End α)
Goal: ∀ (a : G), ⇑(f.toHomPerm a) = f a
-- Equiv.Perm.mul_apply
theorem mul_apply (f g : Perm α) (x) : (f * g) x = f (g x) 
Arguments: {α : Type u} (f g : Equiv.Perm α) (x : α)
Goal: (f * g) x = f (g x)
-- Equiv.Perm.one_apply
theorem one_apply (x) : (1 : Perm α) x = x 
Arguments: {α : Type u} (x : α)
Goal: 1 x = x
-- Equiv.Perm.inv_apply_self
@[simp]
theorem inv_apply_self (f : Perm α) (x) : f⁻¹ (f x) = x 
Arguments: {α : Type u} (f : Equiv.Perm α) (x : α)
Goal: f⁻¹ (f x) = x
-- Equiv.Perm.apply_inv_self
@[simp]
theorem apply_inv_self (f : Perm α) (x) : f (f⁻¹ x) = x 
Arguments: {α : Type u} (f : Equiv.Perm α) (x : α)
Goal: f (f⁻¹ x) = x
-- Equiv.Perm.one_def
theorem one_def : (1 : Perm α) = Equiv.refl α 
Arguments: {α : Type u}
Goal: 1 = Equiv.refl α
-- Equiv.Perm.mul_def
theorem mul_def (f g : Perm α) : f * g = g.trans f 
Arguments: {α : Type u} (f g : Equiv.Perm α)
Goal: f * g = Equiv.trans g f
-- Equiv.Perm.inv_def
theorem inv_def (f : Perm α) : f⁻¹ = f.symm 
Arguments: {α : Type u} (f : Equiv.Perm α)
Goal: f⁻¹ = Equiv.symm f
-- Equiv.Perm.coe_one
@[simp, norm_cast] lemma coe_one : ⇑(1 : Perm α) = id 
Arguments: {α : Type u}
Goal: ⇑1 = id
-- Equiv.Perm.coe_mul
@[simp, norm_cast] lemma coe_mul (f g : Perm α) : ⇑(f * g) = f ∘ g 
Arguments: {α : Type u} (f g : Equiv.Perm α)
Goal: ⇑(f * g) = ⇑f ∘ ⇑g
-- Equiv.Perm.coe_pow
@[norm_cast] lemma coe_pow (f : Perm α) (n : ℕ) : ⇑(f ^ n) = f^[n] 
Arguments: {α : Type u} (f : Equiv.Perm α) (n : ℕ)
Goal: ⇑(f ^ n) = (⇑f)^[n]
-- Equiv.Perm.iterate_eq_pow
@[simp] lemma iterate_eq_pow (f : Perm α) (n : ℕ) : f^[n] = ⇑(f ^ n) 
Arguments: {α : Type u} (f : Equiv.Perm α) (n : ℕ)
Goal: (⇑f)^[n] = ⇑(f ^ n)
-- Equiv.Perm.eq_inv_iff_eq
theorem eq_inv_iff_eq {f : Perm α} {x y : α} : x = f⁻¹ y ↔ f x = y 
Arguments: {α : Type u} {f : Equiv.Perm α} {x y : α}
Goal: x = f⁻¹ y ↔ f x = y
-- Equiv.Perm.inv_eq_iff_eq
theorem inv_eq_iff_eq {f : Perm α} {x y : α} : f⁻¹ x = y ↔ x = f y 
Arguments: {α : Type u} {f : Equiv.Perm α} {x y : α}
Goal: f⁻¹ x = y ↔ x = f y
-- Equiv.Perm.zpow_apply_comm
theorem zpow_apply_comm {α : Type*} (σ : Perm α) (m n : ℤ) {x : α} :
    (σ ^ m) ((σ ^ n) x) = (σ ^ n) ((σ ^ m) x) 
Arguments: {α : Type u_1} (σ : Equiv.Perm α) (m n : ℤ) {x : α}
Goal: (σ ^ m) ((σ ^ n) x) = (σ ^ n) ((σ ^ m) x)
-- Equiv.Perm.image_inv
@[simp] lemma image_inv (f : Perm α) (s : Set α) : ↑f⁻¹ '' s = f ⁻¹' s 
Arguments: {α : Type u} (f : Equiv.Perm α) (s : Set α)
Goal: ⇑f⁻¹ '' s = ⇑f ⁻¹' s
-- Equiv.Perm.preimage_inv
@[simp] lemma preimage_inv (f : Perm α) (s : Set α) : ↑f⁻¹ ⁻¹' s = f '' s 
Arguments: {α : Type u} (f : Equiv.Perm α) (s : Set α)
Goal: ⇑f⁻¹ ⁻¹' s = ⇑f '' s
-- Equiv.Perm.trans_one
@[simp]
theorem trans_one {α : Sort*} {β : Type*} (e : α ≃ β) : e.trans (1 : Perm β) = e 
Arguments: {α : Sort u_1} {β : Type u_2} (e : α ≃ β)
Goal: e.trans 1 = e
-- Equiv.Perm.mul_refl
@[simp]
theorem mul_refl (e : Perm α) : e * Equiv.refl α = e 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: e * Equiv.refl α = e
-- Equiv.Perm.one_symm
@[simp]
theorem one_symm : (1 : Perm α).symm = 1 
Arguments: {α : Type u}
Goal: Equiv.symm 1 = 1
-- Equiv.Perm.refl_inv
@[simp]
theorem refl_inv : (Equiv.refl α : Perm α)⁻¹ = 1 
Arguments: {α : Type u}
Goal: (Equiv.refl α)⁻¹ = 1
-- Equiv.Perm.one_trans
@[simp]
theorem one_trans {α : Type*} {β : Sort*} (e : α ≃ β) : (1 : Perm α).trans e = e 
Arguments: {α : Type u_1} {β : Sort u_2} (e : α ≃ β)
Goal: Equiv.trans 1 e = e
-- Equiv.Perm.refl_mul
@[simp]
theorem refl_mul (e : Perm α) : Equiv.refl α * e = e 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: Equiv.refl α * e = e
-- Equiv.Perm.inv_trans_self
@[simp]
theorem inv_trans_self (e : Perm α) : e⁻¹.trans e = 1 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: Equiv.trans e⁻¹ e = 1
-- Equiv.Perm.mul_symm
@[simp]
theorem mul_symm (e : Perm α) : e * e.symm = 1 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: e * Equiv.symm e = 1
-- Equiv.Perm.self_trans_inv
@[simp]
theorem self_trans_inv (e : Perm α) : e.trans e⁻¹ = 1 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: Equiv.trans e e⁻¹ = 1
-- Equiv.Perm.symm_mul
@[simp]
theorem symm_mul (e : Perm α) : e.symm * e = 1 
Arguments: {α : Type u} (e : Equiv.Perm α)
Goal: Equiv.symm e * e = 1
-- Equiv.Perm.sumCongr_mul
@[simp]
theorem sumCongr_mul {α β : Type*} (e : Perm α) (f : Perm β) (g : Perm α) (h : Perm β) :
    sumCongr e f * sumCongr g h = sumCongr (e * g) (f * h) 
Arguments: {α : Type u_1} {β : Type u_2} (e : Equiv.Perm α) (f : Equiv.Perm β) (g : Equiv.Perm α) (h : Equiv.Perm β)
Goal: e.sumCongr f * g.sumCongr h = (e * g).sumCongr (f * h)
-- Equiv.Perm.sumCongr_inv
@[simp]
theorem sumCongr_inv {α β : Type*} (e : Perm α) (f : Perm β) :
    (sumCongr e f)⁻¹ = sumCongr e⁻¹ f⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} (e : Equiv.Perm α) (f : Equiv.Perm β)
Goal: (e.sumCongr f)⁻¹ = e⁻¹.sumCongr f⁻¹
-- Equiv.Perm.sumCongr_one
@[simp]
theorem sumCongr_one {α β : Type*} : sumCongr (1 : Perm α) (1 : Perm β) = 1 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Equiv.Perm.sumCongr 1 1 = 1
-- Equiv.Perm.sumCongrHom_apply
@[simps]
def sumCongrHom (α β : Type*) : Perm α × Perm β →* Perm (α ⊕ β) 
Arguments: (α : Type u_1) (β : Type u_2) (a : Equiv.Perm α × Equiv.Perm β)
Goal: (Equiv.Perm.sumCongrHom α β) a = a.1.sumCongr a.2
-- Equiv.Perm.sumCongrHom_injective
theorem sumCongrHom_injective {α β : Type*} : Function.Injective (sumCongrHom α β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.Injective ⇑(Equiv.Perm.sumCongrHom α β)
-- Equiv.Perm.sumCongr_swap_one
@[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) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (i j : α)
Goal: (Equiv.swap i j).sumCongr 1 = Equiv.swap (Sum.inl i) (Sum.inl j)
-- Equiv.Perm.sumCongr_one_swap
@[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) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (i j : β)
Goal: Equiv.Perm.sumCongr 1 (Equiv.swap i j) = Equiv.swap (Sum.inr i) (Sum.inr j)
-- Equiv.Perm.sigmaCongrRight_mul
@[simp]
theorem sigmaCongrRight_mul {α : Type*} {β : α → Type*} (F : ∀ a, Perm (β a))
    (G : ∀ a, Perm (β a)) : sigmaCongrRight F * sigmaCongrRight G = sigmaCongrRight (F * G) 
Arguments: {α : Type u_1} {β : α → Type u_2} (F G : (a : α) → Equiv.Perm (β a))
Goal: Equiv.Perm.sigmaCongrRight F * Equiv.Perm.sigmaCongrRight G = Equiv.Perm.sigmaCongrRight (F * G)
-- Equiv.Perm.sigmaCongrRight_inv
@[simp]
theorem sigmaCongrRight_inv {α : Type*} {β : α → Type*} (F : ∀ a, Perm (β a)) :
    (sigmaCongrRight F)⁻¹ = sigmaCongrRight fun a => (F a)⁻¹ 
Arguments: {α : Type u_1} {β : α → Type u_2} (F : (a : α) → Equiv.Perm (β a))
Goal: (Equiv.Perm.sigmaCongrRight F)⁻¹ = Equiv.Perm.sigmaCongrRight fun a => (F a)⁻¹
-- Equiv.Perm.sigmaCongrRight_one
@[simp]
theorem sigmaCongrRight_one {α : Type*} {β : α → Type*} :
    sigmaCongrRight (1 : ∀ a, Equiv.Perm <| β a) = 1 
Arguments: {α : Type u_1} {β : α → Type u_2}
Goal: Equiv.Perm.sigmaCongrRight 1 = 1
-- Equiv.Perm.sigmaCongrRightHom_apply
@[simps]
def sigmaCongrRightHom {α : Type*} (β : α → Type*) : (∀ a, Perm (β a)) →* Perm (Σa, β a) 
Arguments: {α : Type u_1} (β : α → Type u_2) (F : (a : α) → Equiv.Perm (β a))
Goal: (Equiv.Perm.sigmaCongrRightHom β) F = Equiv.Perm.sigmaCongrRight F
-- Equiv.Perm.sigmaCongrRightHom_injective
theorem sigmaCongrRightHom_injective {α : Type*} {β : α → Type*} :
    Function.Injective (sigmaCongrRightHom β) 
Arguments: {α : Type u_1} {β : α → Type u_2}
Goal: Function.Injective ⇑(Equiv.Perm.sigmaCongrRightHom β)
-- Equiv.Perm.subtypeCongrHom_apply
@[simps]
def subtypeCongrHom (p : α → Prop) [DecidablePred p] :
    Perm { a // p a } × Perm { a // ¬p a } →* Perm α 
Arguments: {α : Type u} (p : α → Prop) [DecidablePred p] (pair : Equiv.Perm { a // p a } × Equiv.Perm { a // ¬p a })
Goal: (Equiv.Perm.subtypeCongrHom p) pair = pair.1.subtypeCongr pair.2
-- Equiv.Perm.subtypeCongrHom_injective
theorem subtypeCongrHom_injective (p : α → Prop) [DecidablePred p] :
    Function.Injective (subtypeCongrHom p) 
Arguments: {α : Type u} (p : α → Prop) [DecidablePred p]
Goal: Function.Injective ⇑(Equiv.Perm.subtypeCongrHom p)
-- Equiv.Perm.permCongr_eq_mul
@[simp]
theorem permCongr_eq_mul (e p : Perm α) : e.permCongr p = e * p * e⁻¹ 
Arguments: {α : Type u} (e p : Equiv.Perm α)
Goal: (Equiv.permCongr e) p = e * p * e⁻¹
-- Equiv.Perm.extendDomain_one
@[simp]
theorem extendDomain_one : extendDomain 1 f = 1 
Arguments: {α : Type u} {β : Type v} {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
Goal: Equiv.Perm.extendDomain 1 f = 1
-- Equiv.Perm.extendDomain_inv
@[simp]
theorem extendDomain_inv : (e.extendDomain f)⁻¹ = e⁻¹.extendDomain f 
Arguments: {α : Type u} {β : Type v} (e : Equiv.Perm α) {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
Goal: (e.extendDomain f)⁻¹ = e⁻¹.extendDomain f
-- Equiv.Perm.extendDomain_mul
@[simp]
theorem extendDomain_mul (e e' : Perm α) :
    e.extendDomain f * e'.extendDomain f = (e * e').extendDomain f 
Arguments: {α : Type u} {β : Type v} {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) (e e' : Equiv.Perm α)
Goal: e.extendDomain f * e'.extendDomain f = (e * e').extendDomain f
-- Equiv.Perm.extendDomainHom_apply
@[simps]
def extendDomainHom : Perm α →* Perm β 
Arguments: {α : Type u} {β : Type v} {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) (e : Equiv.Perm α)
Goal: (Equiv.Perm.extendDomainHom f) e = e.extendDomain f
-- Equiv.Perm.extendDomainHom_injective
theorem extendDomainHom_injective : Function.Injective (extendDomainHom f) 
Arguments: {α : Type u} {β : Type v} {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
Goal: Function.Injective ⇑(Equiv.Perm.extendDomainHom f)
-- Equiv.Perm.extendDomain_eq_one_iff
@[simp]
theorem extendDomain_eq_one_iff {e : Perm α} {f : α ≃ Subtype p} : e.extendDomain f = 1 ↔ e = 1 
Arguments: {α : Type u} {β : Type v} {p : β → Prop} [DecidablePred p] {e : Equiv.Perm α} {f : α ≃ Subtype p}
Goal: e.extendDomain f = 1 ↔ e = 1
-- Equiv.Perm.extendDomain_pow
@[simp]
lemma extendDomain_pow (n : ℕ) : (e ^ n).extendDomain f = e.extendDomain f ^ n 
Arguments: {α : Type u} {β : Type v} (e : Equiv.Perm α) {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) (n : ℕ)
Goal: (e ^ n).extendDomain f = e.extendDomain f ^ n
-- Equiv.Perm.extendDomain_zpow
@[simp]
lemma extendDomain_zpow (n : ℤ) : (e ^ n).extendDomain f = e.extendDomain f ^ n 
Arguments: {α : Type u} {β : Type v} (e : Equiv.Perm α) {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) (n : ℤ)
Goal: (e ^ n).extendDomain f = e.extendDomain f ^ n
-- Equiv.Perm.subtypePerm_apply
@[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⟩ 
Arguments: {α : Type u} {p : α → Prop} (f : Equiv.Perm α) (h : ∀ (x : α), p x ↔ p (f x)) (x : { x // p x })
Goal: (f.subtypePerm h) x = ⟨f ↑x, ⋯⟩
-- Equiv.Perm.subtypePerm_one
@[simp]
theorem subtypePerm_one (p : α → Prop) (h := fun _ => Iff.rfl) : @subtypePerm α p 1 h = 1 
Arguments: {α : Type u} (p : α → Prop) (h : ∀ (x : α), p x ↔ p x := ⋯)
Goal: Equiv.Perm.subtypePerm 1 h = 1
-- Equiv.Perm.subtypePerm_mul
@[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 _ 
Arguments: {α : Type u} {p : α → Prop} (f g : Equiv.Perm α) (hf : ∀ (x : α), p x ↔ p (f x)) (hg : ∀ (x : α), p x ↔ p (g x))
Goal: f.subtypePerm hf * g.subtypePerm hg = (f * g).subtypePerm ⋯
-- _private.Mathlib.GroupTheory.Perm.Basic.0.Equiv.Perm.inv_aux
private theorem inv_aux : (∀ x, p x ↔ p (f x)) ↔ ∀ x, p x ↔ p (f⁻¹ x) 
Arguments: {α : Type u} {p : α → Prop} {f : Equiv.Perm α}
Goal: (∀ (x : α), p x ↔ p (f x)) ↔ ∀ (x : α), p x ↔ p (f⁻¹ x)
-- Equiv.Perm.subtypePerm_inv
theorem subtypePerm_inv (f : Perm α) (hf) :
    f⁻¹.subtypePerm hf = (f.subtypePerm <| inv_aux.2 hf : Perm { x // p x })⁻¹ 
Arguments: {α : Type u} {p : α → Prop} (f : Equiv.Perm α) (hf : ∀ (x : α), p x ↔ p (f⁻¹ x))
Goal: f⁻¹.subtypePerm hf = (f.subtypePerm ⋯)⁻¹
-- Equiv.Perm.inv_subtypePerm
@[simp]
theorem inv_subtypePerm (f : Perm α) (hf) :
    (f.subtypePerm hf : Perm { x // p x })⁻¹ = f⁻¹.subtypePerm (inv_aux.1 hf) 
Arguments: {α : Type u} {p : α → Prop} (f : Equiv.Perm α) (hf : ∀ (x : α), p x ↔ p (f x))
Goal: (f.subtypePerm hf)⁻¹ = f⁻¹.subtypePerm ⋯
-- _private.Mathlib.GroupTheory.Perm.Basic.0.Equiv.Perm.pow_aux
private theorem pow_aux (hf : ∀ x, p x ↔ p (f x)) : ∀ {n : ℕ} (x), p x ↔ p ((f ^ n) x)
  
Arguments: {α : Type u} {p : α → Prop} {f : Equiv.Perm α} (hf : ∀ (x : α), p x ↔ p (f x)) {n : ℕ} (x : α)
Goal: p x ↔ p ((f ^ n) x)
-- Equiv.Perm.subtypePerm_pow
@[simp]
theorem subtypePerm_pow (f : Perm α) (n : ℕ) (hf) :
    (f.subtypePerm hf : Perm { x // p x }) ^ n = (f ^ n).subtypePerm (pow_aux hf) 
Arguments: {α : Type u} {p : α → Prop} (f : Equiv.Perm α) (n : ℕ) (hf : ∀ (x : α), p x ↔ p (f x))
Goal: f.subtypePerm hf ^ n = (f ^ n).subtypePerm ⋯
-- _private.Mathlib.GroupTheory.Perm.Basic.0.Equiv.Perm.zpow_aux
private theorem zpow_aux (hf : ∀ x, p x ↔ p (f x)) : ∀ {n : ℤ} (x), p x ↔ p ((f ^ n) x)
  
Arguments: {α : Type u} {p : α → Prop} {f : Equiv.Perm α} (hf : ∀ (x : α), p x ↔ p (f x)) {n : ℤ} (x : α)
Goal: p x ↔ p ((f ^ n) x)
-- Equiv.Perm.subtypePerm_zpow
@[simp]
theorem subtypePerm_zpow (f : Perm α) (n : ℤ) (hf) :
    (f.subtypePerm hf ^ n : Perm { x // p x }) = (f ^ n).subtypePerm (zpow_aux hf) 
Arguments: {α : Type u} {p : α → Prop} (f : Equiv.Perm α) (n : ℤ) (hf : ∀ (x : α), p x ↔ p (f x))
Goal: f.subtypePerm hf ^ n = (f ^ n).subtypePerm ⋯
-- Equiv.Perm.ofSubtype_subtypePerm
theorem ofSubtype_subtypePerm {f : Perm α} (h₁ : ∀ x, p x ↔ p (f x)) (h₂ : ∀ x, f x ≠ x → p x) :
    ofSubtype (subtypePerm f h₁) = f 
Arguments: {α : Type u} {p : α → Prop} [DecidablePred p] {f : Equiv.Perm α} (h₁ : ∀ (x : α), p x ↔ p (f x)) (h₂ : ∀ (x : α), f x ≠ x → p x)
Goal: Equiv.Perm.ofSubtype (f.subtypePerm h₁) = f
-- Equiv.Perm.ofSubtype_apply_of_mem
theorem ofSubtype_apply_of_mem (f : Perm (Subtype p)) (ha : p a) : ofSubtype f a = f ⟨a, ha⟩ 
Arguments: {α : Type u} {p : α → Prop} [DecidablePred p] {a : α} (f : Equiv.Perm (Subtype p)) (ha : p a)
Goal: (Equiv.Perm.ofSubtype f) a = ↑(f ⟨a, ha⟩)
-- Equiv.Perm.ofSubtype_apply_coe
@[simp]
theorem ofSubtype_apply_coe (f : Perm (Subtype p)) (x : Subtype p) : ofSubtype f x = f x 
Arguments: {α : Type u} {p : α → Prop} [DecidablePred p] (f : Equiv.Perm (Subtype p)) (x : Subtype p)
Goal: (Equiv.Perm.ofSubtype f) ↑x = ↑(f x)