File: Mathlib/GroupTheory/Coset.lean

full_name: mem_leftCoset
code: @[to_additive mem_leftAddCoset]
theorem mem_leftCoset {s : Set α} {x : α} (a : α) (hxS : x ∈ s) : a * x ∈ a • s 
goal: a * x ∈ a • s

full_name: mem_leftAddCoset
code: @[to_additive mem_leftAddCoset]
theorem mem_leftCoset {s : Set α} {x : α} (a : α) (hxS : x ∈ s) : a * x ∈ a • s 
goal: a + x ∈ a +ᵥ s

full_name: mem_rightCoset
code: @[to_additive mem_rightAddCoset]
theorem mem_rightCoset {s : Set α} {x : α} (a : α) (hxS : x ∈ s) : x * a ∈ op a • s 
goal: x * a ∈ MulOpposite.op a • s

full_name: mem_rightAddCoset
code: @[to_additive mem_rightAddCoset]
theorem mem_rightCoset {s : Set α} {x : α} (a : α) (hxS : x ∈ s) : x * a ∈ op a • s 
goal: x + a ∈ AddOpposite.op a +ᵥ s

full_name: LeftAddCosetEquivalence
code: /-- Equality of two left cosets `a * s` and `b * s`. -/
@[to_additive LeftAddCosetEquivalence "Equality of two left cosets `a + s` and `b + s`."]
def LeftCosetEquivalence (s : Set α) (a b : α) 
goal: Prop

full_name: LeftCosetEquivalence
code: /-- Equality of two left cosets `a * s` and `b * s`. -/
@[to_additive LeftAddCosetEquivalence "Equality of two left cosets `a + s` and `b + s`."]
def LeftCosetEquivalence (s : Set α) (a b : α) 
goal: Prop

full_name: leftAddCosetEquivalence_rel
code: @[to_additive leftAddCosetEquivalence_rel]
theorem leftCosetEquivalence_rel (s : Set α) : Equivalence (LeftCosetEquivalence s) 
goal: Equivalence (LeftAddCosetEquivalence s)

full_name: leftCosetEquivalence_rel
code: @[to_additive leftAddCosetEquivalence_rel]
theorem leftCosetEquivalence_rel (s : Set α) : Equivalence (LeftCosetEquivalence s) 
goal: Equivalence (LeftCosetEquivalence s)

full_name: RightCosetEquivalence
code: /-- Equality of two right cosets `s * a` and `s * b`. -/
@[to_additive RightAddCosetEquivalence "Equality of two right cosets `s + a` and `s + b`."]
def RightCosetEquivalence (s : Set α) (a b : α) 
goal: Prop

full_name: RightAddCosetEquivalence
code: /-- Equality of two right cosets `s * a` and `s * b`. -/
@[to_additive RightAddCosetEquivalence "Equality of two right cosets `s + a` and `s + b`."]
def RightCosetEquivalence (s : Set α) (a b : α) 
goal: Prop

full_name: rightCosetEquivalence_rel
code: @[to_additive rightAddCosetEquivalence_rel]
theorem rightCosetEquivalence_rel (s : Set α) : Equivalence (RightCosetEquivalence s) 
goal: Equivalence (RightCosetEquivalence s)

full_name: rightAddCosetEquivalence_rel
code: @[to_additive rightAddCosetEquivalence_rel]
theorem rightCosetEquivalence_rel (s : Set α) : Equivalence (RightCosetEquivalence s) 
goal: Equivalence (RightAddCosetEquivalence s)

full_name: leftCoset_assoc
code: @[to_additive leftAddCoset_assoc]
theorem leftCoset_assoc (s : Set α) (a b : α) : a • (b • s) = (a * b) • s 
goal: a • b • s = (a * b) • s

full_name: leftAddCoset_assoc
code: @[to_additive leftAddCoset_assoc]
theorem leftCoset_assoc (s : Set α) (a b : α) : a • (b • s) = (a * b) • s 
goal: a +ᵥ (b +ᵥ s) = a + b +ᵥ s

full_name: rightCoset_assoc
code: @[to_additive rightAddCoset_assoc]
theorem rightCoset_assoc (s : Set α) (a b : α) : op b • op a • s = op (a * b) • s 
goal: MulOpposite.op b • MulOpposite.op a • s = MulOpposite.op (a * b) • s

full_name: rightAddCoset_assoc
code: @[to_additive rightAddCoset_assoc]
theorem rightCoset_assoc (s : Set α) (a b : α) : op b • op a • s = op (a * b) • s 
goal: AddOpposite.op b +ᵥ (AddOpposite.op a +ᵥ s) = AddOpposite.op (a + b) +ᵥ s

full_name: leftAddCoset_rightAddCoset
code: @[to_additive leftAddCoset_rightAddCoset]
theorem leftCoset_rightCoset (s : Set α) (a b : α) : op b • a • s = a • (op b • s) 
goal: AddOpposite.op b +ᵥ (a +ᵥ s) = a +ᵥ (AddOpposite.op b +ᵥ s)

full_name: leftCoset_rightCoset
code: @[to_additive leftAddCoset_rightAddCoset]
theorem leftCoset_rightCoset (s : Set α) (a b : α) : op b • a • s = a • (op b • s) 
goal: MulOpposite.op b • a • s = a • MulOpposite.op b • s

full_name: zero_leftAddCoset
code: @[to_additive zero_leftAddCoset]
theorem one_leftCoset : (1 : α) • s = s 
goal: 0 +ᵥ s = s

full_name: one_leftCoset
code: @[to_additive zero_leftAddCoset]
theorem one_leftCoset : (1 : α) • s = s 
goal: 1 • s = s

full_name: rightCoset_one
code: @[to_additive rightAddCoset_zero]
theorem rightCoset_one : op (1 : α) • s = s 
goal: MulOpposite.op 1 • s = s

full_name: rightAddCoset_zero
code: @[to_additive rightAddCoset_zero]
theorem rightCoset_one : op (1 : α) • s = s 
goal: AddOpposite.op 0 +ᵥ s = s

full_name: mem_own_leftCoset
code: @[to_additive mem_own_leftAddCoset]
theorem mem_own_leftCoset (a : α) : a ∈ a • (s : Set α) 
goal: a ∈ a • ↑s

full_name: mem_own_leftAddCoset
code: @[to_additive mem_own_leftAddCoset]
theorem mem_own_leftCoset (a : α) : a ∈ a • (s : Set α) 
goal: a ∈ a +ᵥ ↑s

full_name: mem_own_rightCoset
code: @[to_additive mem_own_rightAddCoset]
theorem mem_own_rightCoset (a : α) : a ∈ op a • (s : Set α) 
goal: a ∈ MulOpposite.op a • ↑s

full_name: mem_own_rightAddCoset
code: @[to_additive mem_own_rightAddCoset]
theorem mem_own_rightCoset (a : α) : a ∈ op a • (s : Set α) 
goal: a ∈ AddOpposite.op a +ᵥ ↑s

full_name: mem_leftAddCoset_leftAddCoset
code: @[to_additive mem_leftAddCoset_leftAddCoset]
theorem mem_leftCoset_leftCoset {a : α} (ha : a • (s : Set α) = s) : a ∈ s 
goal: a ∈ s

full_name: mem_leftCoset_leftCoset
code: @[to_additive mem_leftAddCoset_leftAddCoset]
theorem mem_leftCoset_leftCoset {a : α} (ha : a • (s : Set α) = s) : a ∈ s 
goal: a ∈ s

full_name: mem_rightAddCoset_rightAddCoset
code: @[to_additive mem_rightAddCoset_rightAddCoset]
theorem mem_rightCoset_rightCoset {a : α} (ha : op a • (s : Set α) = s) : a ∈ s 
goal: a ∈ s

full_name: mem_rightCoset_rightCoset
code: @[to_additive mem_rightAddCoset_rightAddCoset]
theorem mem_rightCoset_rightCoset {a : α} (ha : op a • (s : Set α) = s) : a ∈ s 
goal: a ∈ s

full_name: mem_leftAddCoset_iff
code: @[to_additive mem_leftAddCoset_iff]
theorem mem_leftCoset_iff (a : α) : x ∈ a • s ↔ a⁻¹ * x ∈ s 
goal: x ∈ a +ᵥ s ↔ -a + x ∈ s

full_name: mem_leftCoset_iff
code: @[to_additive mem_leftAddCoset_iff]
theorem mem_leftCoset_iff (a : α) : x ∈ a • s ↔ a⁻¹ * x ∈ s 
goal: x ∈ a • s ↔ a⁻¹ * x ∈ s

full_name: mem_rightCoset_iff
code: @[to_additive mem_rightAddCoset_iff]
theorem mem_rightCoset_iff (a : α) : x ∈ op a • s ↔ x * a⁻¹ ∈ s 
goal: x ∈ MulOpposite.op a • s ↔ x * a⁻¹ ∈ s

full_name: mem_rightAddCoset_iff
code: @[to_additive mem_rightAddCoset_iff]
theorem mem_rightCoset_iff (a : α) : x ∈ op a • s ↔ x * a⁻¹ ∈ s 
goal: x ∈ AddOpposite.op a +ᵥ s ↔ x + -a ∈ s

full_name: leftAddCoset_mem_leftAddCoset
code: @[to_additive leftAddCoset_mem_leftAddCoset]
theorem leftCoset_mem_leftCoset {a : α} (ha : a ∈ s) : a • (s : Set α) = s 
goal: a +ᵥ ↑s = ↑s

full_name: leftCoset_mem_leftCoset
code: @[to_additive leftAddCoset_mem_leftAddCoset]
theorem leftCoset_mem_leftCoset {a : α} (ha : a ∈ s) : a • (s : Set α) = s 
goal: a • ↑s = ↑s

full_name: rightAddCoset_mem_rightAddCoset
code: @[to_additive rightAddCoset_mem_rightAddCoset]
theorem rightCoset_mem_rightCoset {a : α} (ha : a ∈ s) : op a • (s : Set α) = s 
goal: AddOpposite.op a +ᵥ ↑s = ↑s

full_name: rightCoset_mem_rightCoset
code: @[to_additive rightAddCoset_mem_rightAddCoset]
theorem rightCoset_mem_rightCoset {a : α} (ha : a ∈ s) : op a • (s : Set α) = s 
goal: MulOpposite.op a • ↑s = ↑s

full_name: orbit_addSubgroup_eq_rightCoset
code: @[to_additive]
theorem orbit_subgroup_eq_rightCoset (a : α) : MulAction.orbit s a = op a • s 
goal: AddAction.orbit (↥s) a = AddOpposite.op a +ᵥ ↑s

full_name: orbit_subgroup_eq_rightCoset
code: @[to_additive]
theorem orbit_subgroup_eq_rightCoset (a : α) : MulAction.orbit s a = op a • s 
goal: MulAction.orbit (↥s) a = MulOpposite.op a • ↑s

full_name: orbit_addSubgroup_eq_self_of_mem
code: @[to_additive]
theorem orbit_subgroup_eq_self_of_mem {a : α} (ha : a ∈ s) : MulAction.orbit s a = s 
goal: AddAction.orbit (↥s) a = ↑s

full_name: orbit_subgroup_eq_self_of_mem
code: @[to_additive]
theorem orbit_subgroup_eq_self_of_mem {a : α} (ha : a ∈ s) : MulAction.orbit s a = s 
goal: MulAction.orbit (↥s) a = ↑s

full_name: orbit_subgroup_one_eq_self
code: @[to_additive]
theorem orbit_subgroup_one_eq_self : MulAction.orbit s (1 : α) = s 
goal: MulAction.orbit (↥s) 1 = ↑s

full_name: orbit_addSubgroup_zero_eq_self
code: @[to_additive]
theorem orbit_subgroup_one_eq_self : MulAction.orbit s (1 : α) = s 
goal: AddAction.orbit (↥s) 0 = ↑s

full_name: eq_cosets_of_normal
code: @[to_additive eq_addCosets_of_normal]
theorem eq_cosets_of_normal (N : s.Normal) (g : α) : g • (s : Set α) = op g • s 
goal: g • ↑s = MulOpposite.op g • ↑s

full_name: eq_addCosets_of_normal
code: @[to_additive eq_addCosets_of_normal]
theorem eq_cosets_of_normal (N : s.Normal) (g : α) : g • (s : Set α) = op g • s 
goal: g +ᵥ ↑s = AddOpposite.op g +ᵥ ↑s

full_name: normal_of_eq_addCosets
code: @[to_additive normal_of_eq_addCosets]
theorem normal_of_eq_cosets (h : ∀ g : α, g • (s : Set α) = op g • s) : s.Normal 
goal: s.Normal

full_name: normal_of_eq_cosets
code: @[to_additive normal_of_eq_addCosets]
theorem normal_of_eq_cosets (h : ∀ g : α, g • (s : Set α) = op g • s) : s.Normal 
goal: s.Normal

full_name: normal_iff_eq_cosets
code: @[to_additive normal_iff_eq_addCosets]
theorem normal_iff_eq_cosets : s.Normal ↔ ∀ g : α, g • (s : Set α) = op g • s 
goal: s.Normal ↔ ∀ (g : α), g • ↑s = MulOpposite.op g • ↑s

full_name: normal_iff_eq_addCosets
code: @[to_additive normal_iff_eq_addCosets]
theorem normal_iff_eq_cosets : s.Normal ↔ ∀ g : α, g • (s : Set α) = op g • s 
goal: s.Normal ↔ ∀ (g : α), g +ᵥ ↑s = AddOpposite.op g +ᵥ ↑s

full_name: leftCoset_eq_iff
code: @[to_additive leftAddCoset_eq_iff]
theorem leftCoset_eq_iff {x y : α} : x • (s : Set α) = y • s ↔ x⁻¹ * y ∈ s 
goal: x • ↑s = y • ↑s ↔ x⁻¹ * y ∈ s

full_name: leftAddCoset_eq_iff
code: @[to_additive leftAddCoset_eq_iff]
theorem leftCoset_eq_iff {x y : α} : x • (s : Set α) = y • s ↔ x⁻¹ * y ∈ s 
goal: x +ᵥ ↑s = y +ᵥ ↑s ↔ -x + y ∈ s

full_name: rightCoset_eq_iff
code: @[to_additive rightAddCoset_eq_iff]
theorem rightCoset_eq_iff {x y : α} : op x • (s : Set α) = op y • s ↔ y * x⁻¹ ∈ s 
goal: MulOpposite.op x • ↑s = MulOpposite.op y • ↑s ↔ y * x⁻¹ ∈ s

full_name: rightAddCoset_eq_iff
code: @[to_additive rightAddCoset_eq_iff]
theorem rightCoset_eq_iff {x y : α} : op x • (s : Set α) = op y • s ↔ y * x⁻¹ ∈ s 
goal: AddOpposite.op x +ᵥ ↑s = AddOpposite.op y +ᵥ ↑s ↔ y + -x ∈ s

full_name: QuotientGroup.leftRel
code: /-- The equivalence relation corresponding to the partition of a group by left cosets
of a subgroup. -/
@[to_additive "The equivalence relation corresponding to the partition of a group by left cosets
 of a subgroup."]
def leftRel : Setoid α 
goal: Setoid α

full_name: QuotientAddGroup.leftRel
code: /-- The equivalence relation corresponding to the partition of a group by left cosets
of a subgroup. -/
@[to_additive "The equivalence relation corresponding to the partition of a group by left cosets
 of a subgroup."]
def leftRel : Setoid α 
goal: Setoid α

full_name: QuotientAddGroup.leftRel_apply
code: @[to_additive]
theorem leftRel_apply {x y : α} : @Setoid.r _ (leftRel s) x y ↔ x⁻¹ * y ∈ s 
goal: Setoid.r x y ↔ -x + y ∈ s

full_name: QuotientGroup.leftRel_apply
code: @[to_additive]
theorem leftRel_apply {x y : α} : @Setoid.r _ (leftRel s) x y ↔ x⁻¹ * y ∈ s 
goal: Setoid.r x y ↔ x⁻¹ * y ∈ s

full_name: QuotientGroup.leftRel_eq
code: @[to_additive]
theorem leftRel_eq : @Setoid.r _ (leftRel s) = fun x y => x⁻¹ * y ∈ s 
goal: Setoid.r = fun x y => x⁻¹ * y ∈ s

full_name: QuotientAddGroup.leftRel_eq
code: @[to_additive]
theorem leftRel_eq : @Setoid.r _ (leftRel s) = fun x y => x⁻¹ * y ∈ s 
goal: Setoid.r = fun x y => -x + y ∈ s

full_name: QuotientGroup.leftRel_r_eq_leftCosetEquivalence
code: theorem leftRel_r_eq_leftCosetEquivalence :
    @Setoid.r _ (QuotientGroup.leftRel s) = LeftCosetEquivalence s 
goal: Setoid.r = LeftCosetEquivalence ↑s

full_name: QuotientGroup.leftRelDecidable
code: @[to_additive]
instance leftRelDecidable [DecidablePred (· ∈ s)] : DecidableRel (leftRel s).r 
goal: DecidableRel Setoid.r

full_name: QuotientAddGroup.leftRelDecidable
code: @[to_additive]
instance leftRelDecidable [DecidablePred (· ∈ s)] : DecidableRel (leftRel s).r 
goal: DecidableRel Setoid.r

full_name: QuotientGroup.instHasQuotientSubgroup
code: /-- `α ⧸ s` is the quotient type representing the left cosets of `s`.
  If `s` is a normal subgroup, `α ⧸ s` is a group -/
@[to_additive "`α ⧸ s` is the quotient type representing the left cosets of `s`.  If `s` is a normal
 subgroup, `α ⧸ s` is a group"]
instance instHasQuotientSubgroup : HasQuotient α (Subgroup α) 
goal: HasQuotient α (Subgroup α)

full_name: QuotientAddGroup.instHasQuotientAddSubgroup
code: /-- `α ⧸ s` is the quotient type representing the left cosets of `s`.
  If `s` is a normal subgroup, `α ⧸ s` is a group -/
@[to_additive "`α ⧸ s` is the quotient type representing the left cosets of `s`.  If `s` is a normal
 subgroup, `α ⧸ s` is a group"]
instance instHasQuotientSubgroup : HasQuotient α (Subgroup α) 
goal: HasQuotient α (AddSubgroup α)

full_name: QuotientGroup.rightRel
code: /-- The equivalence relation corresponding to the partition of a group by right cosets of a
subgroup. -/
@[to_additive "The equivalence relation corresponding to the partition of a group by right cosets
 of a subgroup."]
def rightRel : Setoid α 
goal: Setoid α

full_name: QuotientAddGroup.rightRel
code: /-- The equivalence relation corresponding to the partition of a group by right cosets of a
subgroup. -/
@[to_additive "The equivalence relation corresponding to the partition of a group by right cosets
 of a subgroup."]
def rightRel : Setoid α 
goal: Setoid α

full_name: QuotientGroup.rightRel_apply
code: @[to_additive]
theorem rightRel_apply {x y : α} : @Setoid.r _ (rightRel s) x y ↔ y * x⁻¹ ∈ s 
goal: Setoid.r x y ↔ y * x⁻¹ ∈ s

full_name: QuotientAddGroup.rightRel_apply
code: @[to_additive]
theorem rightRel_apply {x y : α} : @Setoid.r _ (rightRel s) x y ↔ y * x⁻¹ ∈ s 
goal: Setoid.r x y ↔ y + -x ∈ s

full_name: QuotientGroup.rightRel_eq
code: @[to_additive]
theorem rightRel_eq : @Setoid.r _ (rightRel s) = fun x y => y * x⁻¹ ∈ s 
goal: Setoid.r = fun x y => y * x⁻¹ ∈ s

full_name: QuotientAddGroup.rightRel_eq
code: @[to_additive]
theorem rightRel_eq : @Setoid.r _ (rightRel s) = fun x y => y * x⁻¹ ∈ s 
goal: Setoid.r = fun x y => y + -x ∈ s

full_name: QuotientGroup.rightRel_r_eq_rightCosetEquivalence
code: theorem rightRel_r_eq_rightCosetEquivalence :
    @Setoid.r _ (QuotientGroup.rightRel s) = RightCosetEquivalence s 
goal: Setoid.r = RightCosetEquivalence ↑s

full_name: QuotientGroup.rightRelDecidable
code: @[to_additive]
instance rightRelDecidable [DecidablePred (· ∈ s)] : DecidableRel (rightRel s).r 
goal: DecidableRel Setoid.r

full_name: QuotientAddGroup.rightRelDecidable
code: @[to_additive]
instance rightRelDecidable [DecidablePred (· ∈ s)] : DecidableRel (rightRel s).r 
goal: DecidableRel Setoid.r

full_name: QuotientGroup.quotientRightRelEquivQuotientLeftRel
code: /-- Right cosets are in bijection with left cosets. -/
@[to_additive "Right cosets are in bijection with left cosets."]
def quotientRightRelEquivQuotientLeftRel : Quotient (QuotientGroup.rightRel s) ≃ α ⧸ s 
goal: Quotient (QuotientGroup.rightRel s) ≃ α ⧸ s

full_name: QuotientAddGroup.quotientRightRelEquivQuotientLeftRel
code: /-- Right cosets are in bijection with left cosets. -/
@[to_additive "Right cosets are in bijection with left cosets."]
def quotientRightRelEquivQuotientLeftRel : Quotient (QuotientGroup.rightRel s) ≃ α ⧸ s 
goal: Quotient (QuotientAddGroup.rightRel s) ≃ α ⧸ s

full_name: QuotientGroup.fintypeQuotientRightRel
code: @[to_additive]
instance fintypeQuotientRightRel [Fintype (α ⧸ s)] :
    Fintype (Quotient (QuotientGroup.rightRel s)) 
goal: Fintype (Quotient (QuotientGroup.rightRel s))

full_name: QuotientAddGroup.fintypeQuotientRightRel
code: @[to_additive]
instance fintypeQuotientRightRel [Fintype (α ⧸ s)] :
    Fintype (Quotient (QuotientGroup.rightRel s)) 
goal: Fintype (Quotient (QuotientAddGroup.rightRel s))

full_name: QuotientGroup.card_quotient_rightRel
code: @[to_additive]
theorem card_quotient_rightRel [Fintype (α ⧸ s)] :
    Fintype.card (Quotient (QuotientGroup.rightRel s)) = Fintype.card (α ⧸ s) 
goal: Fintype.card (Quotient (QuotientGroup.rightRel s)) = Fintype.card (α ⧸ s)

full_name: QuotientAddGroup.card_quotient_rightRel
code: @[to_additive]
theorem card_quotient_rightRel [Fintype (α ⧸ s)] :
    Fintype.card (Quotient (QuotientGroup.rightRel s)) = Fintype.card (α ⧸ s) 
goal: Fintype.card (Quotient (QuotientAddGroup.rightRel s)) = Fintype.card (α ⧸ s)

full_name: QuotientAddGroup.fintype
code: @[to_additive]
instance fintype [Fintype α] (s : Subgroup α) [DecidableRel (leftRel s).r] : Fintype (α ⧸ s) 
goal: Fintype (α ⧸ s)

full_name: QuotientGroup.fintype
code: @[to_additive]
instance fintype [Fintype α] (s : Subgroup α) [DecidableRel (leftRel s).r] : Fintype (α ⧸ s) 
goal: Fintype (α ⧸ s)

full_name: QuotientGroup.mk
code: /-- The canonical map from a group `α` to the quotient `α ⧸ s`. -/
@[to_additive (attr := coe) "The canonical map from an `AddGroup` `α` to the quotient `α ⧸ s`."]
abbrev mk (a : α) : α ⧸ s 
goal: α ⧸ s

full_name: QuotientAddGroup.mk
code: /-- The canonical map from a group `α` to the quotient `α ⧸ s`. -/
@[to_additive (attr := coe) "The canonical map from an `AddGroup` `α` to the quotient `α ⧸ s`."]
abbrev mk (a : α) : α ⧸ s 
goal: α ⧸ s

full_name: QuotientAddGroup.mk_surjective
code: @[to_additive]
theorem mk_surjective : Function.Surjective <| @mk _ _ s 
goal: Function.Surjective QuotientAddGroup.mk

full_name: QuotientGroup.mk_surjective
code: @[to_additive]
theorem mk_surjective : Function.Surjective <| @mk _ _ s 
goal: Function.Surjective QuotientGroup.mk

full_name: QuotientAddGroup.range_mk
code: @[to_additive (attr := simp)]
lemma range_mk : range (QuotientGroup.mk (s := s)) = univ 
goal: Set.range QuotientAddGroup.mk = Set.univ

full_name: QuotientGroup.range_mk
code: @[to_additive (attr := simp)]
lemma range_mk : range (QuotientGroup.mk (s := s)) = univ 
goal: Set.range QuotientGroup.mk = Set.univ

full_name: QuotientAddGroup.induction_on
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on {C : α ⧸ s → Prop} (x : α ⧸ s) (H : ∀ z, C (QuotientGroup.mk z)) : C x 
goal: C x

full_name: QuotientGroup.induction_on
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on {C : α ⧸ s → Prop} (x : α ⧸ s) (H : ∀ z, C (QuotientGroup.mk z)) : C x 
goal: C x

full_name: QuotientGroup.instCoeQuotientSubgroup
code: @[to_additive]
instance : Coe α (α ⧸ s) 
goal: Coe α (α ⧸ s)

full_name: QuotientAddGroup.instCoeQuotientAddSubgroup
code: @[to_additive]
instance : Coe α (α ⧸ s) 
goal: Coe α (α ⧸ s)

full_name: QuotientGroup.induction_on'
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on' {C : α ⧸ s → Prop} (x : α ⧸ s) (H : ∀ z : α, C z) : C x 
goal: C x

full_name: QuotientAddGroup.induction_on'
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on' {C : α ⧸ s → Prop} (x : α ⧸ s) (H : ∀ z : α, C z) : C x 
goal: C x

full_name: QuotientAddGroup.quotient_liftOn_mk
code: @[to_additive (attr := simp)]
theorem quotient_liftOn_mk {β} (f : α → β) (h) (x : α) : Quotient.liftOn' (x : α ⧸ s) f h = f x 
goal: Quotient.liftOn' (↑x) f h = f x

full_name: QuotientGroup.quotient_liftOn_mk
code: @[to_additive (attr := simp)]
theorem quotient_liftOn_mk {β} (f : α → β) (h) (x : α) : Quotient.liftOn' (x : α ⧸ s) f h = f x 
goal: Quotient.liftOn' (↑x) f h = f x

full_name: QuotientGroup.forall_mk
code: @[to_additive]
theorem forall_mk {C : α ⧸ s → Prop} : (∀ x : α ⧸ s, C x) ↔ ∀ x : α, C x 
goal: (∀ (x : α ⧸ s), C x) ↔ ∀ (x : α), C ↑x

full_name: QuotientAddGroup.forall_mk
code: @[to_additive]
theorem forall_mk {C : α ⧸ s → Prop} : (∀ x : α ⧸ s, C x) ↔ ∀ x : α, C x 
goal: (∀ (x : α ⧸ s), C x) ↔ ∀ (x : α), C ↑x

full_name: QuotientGroup.exists_mk
code: @[to_additive]
theorem exists_mk {C : α ⧸ s → Prop} : (∃ x : α ⧸ s, C x) ↔ ∃ x : α, C x 
goal: (∃ x, C x) ↔ ∃ x, C ↑x

full_name: QuotientAddGroup.exists_mk
code: @[to_additive]
theorem exists_mk {C : α ⧸ s → Prop} : (∃ x : α ⧸ s, C x) ↔ ∃ x : α, C x 
goal: (∃ x, C x) ↔ ∃ x, C ↑x

full_name: QuotientAddGroup.instInhabitedQuotientAddSubgroup
code: @[to_additive]
instance (s : Subgroup α) : Inhabited (α ⧸ s) 
goal: Inhabited (α ⧸ s)

full_name: QuotientGroup.instInhabitedQuotientSubgroup
code: @[to_additive]
instance (s : Subgroup α) : Inhabited (α ⧸ s) 
goal: Inhabited (α ⧸ s)

full_name: QuotientAddGroup.eq
code: @[to_additive]
protected theorem eq {a b : α} : (a : α ⧸ s) = b ↔ a⁻¹ * b ∈ s 
goal: ↑a = ↑b ↔ -a + b ∈ s

full_name: QuotientGroup.eq
code: @[to_additive]
protected theorem eq {a b : α} : (a : α ⧸ s) = b ↔ a⁻¹ * b ∈ s 
goal: ↑a = ↑b ↔ a⁻¹ * b ∈ s

full_name: QuotientGroup.eq'
code: @[to_additive]
theorem eq' {a b : α} : (mk a : α ⧸ s) = mk b ↔ a⁻¹ * b ∈ s 
goal: ↑a = ↑b ↔ a⁻¹ * b ∈ s

full_name: QuotientAddGroup.eq'
code: @[to_additive]
theorem eq' {a b : α} : (mk a : α ⧸ s) = mk b ↔ a⁻¹ * b ∈ s 
goal: ↑a = ↑b ↔ -a + b ∈ s

full_name: QuotientGroup.out_eq'
code: @[to_additive] -- Porting note (#10618): `simp` can prove this.
theorem out_eq' (a : α ⧸ s) : mk a.out' = a 
goal: ↑(Quotient.out' a) = a

full_name: QuotientAddGroup.out_eq'
code: @[to_additive] -- Porting note (#10618): `simp` can prove this.
theorem out_eq' (a : α ⧸ s) : mk a.out' = a 
goal: ↑(Quotient.out' a) = a

full_name: QuotientGroup.mk_out'_eq_mul
code: @[to_additive QuotientAddGroup.mk_out'_eq_mul]
theorem mk_out'_eq_mul (g : α) : ∃ h : s, (mk g : α ⧸ s).out' = g * h 
goal: ∃ h, Quotient.out' ↑g = g * ↑h

full_name: QuotientAddGroup.mk_out'_eq_mul
code: @[to_additive QuotientAddGroup.mk_out'_eq_mul]
theorem mk_out'_eq_mul (g : α) : ∃ h : s, (mk g : α ⧸ s).out' = g * h 
goal: ∃ h, Quotient.out' ↑g = g + ↑h

full_name: QuotientGroup.mk_mul_of_mem
code: @[to_additive (attr := simp)]
theorem mk_mul_of_mem (a : α) (hb : b ∈ s) : (mk (a * b) : α ⧸ s) = mk a 
goal: ↑(a * b) = ↑a

full_name: QuotientAddGroup.mk_add_of_mem
code: @[to_additive (attr := simp)]
theorem mk_mul_of_mem (a : α) (hb : b ∈ s) : (mk (a * b) : α ⧸ s) = mk a 
goal: ↑(a + b) = ↑a

full_name: QuotientGroup.eq_class_eq_leftCoset
code: @[to_additive]
theorem eq_class_eq_leftCoset (s : Subgroup α) (g : α) :
    { x : α | (x : α ⧸ s) = g } = g • s 
goal: {x | ↑x = ↑g} = g • ↑s

full_name: QuotientAddGroup.eq_class_eq_leftCoset
code: @[to_additive]
theorem eq_class_eq_leftCoset (s : Subgroup α) (g : α) :
    { x : α | (x : α ⧸ s) = g } = g • s 
goal: {x | ↑x = ↑g} = g +ᵥ ↑s

full_name: QuotientAddGroup.preimage_image_mk
code: @[to_additive]
theorem preimage_image_mk (N : Subgroup α) (s : Set α) :
    mk ⁻¹' ((mk : α → α ⧸ N) '' s) = ⋃ x : N, (· * (x : α)) ⁻¹' s 
goal: QuotientAddGroup.mk ⁻¹' (QuotientAddGroup.mk '' s) = ⋃ x, (fun x_1 => x_1 + ↑x) ⁻¹' s

full_name: QuotientGroup.preimage_image_mk
code: @[to_additive]
theorem preimage_image_mk (N : Subgroup α) (s : Set α) :
    mk ⁻¹' ((mk : α → α ⧸ N) '' s) = ⋃ x : N, (· * (x : α)) ⁻¹' s 
goal: QuotientGroup.mk ⁻¹' (QuotientGroup.mk '' s) = ⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s

full_name: QuotientGroup.preimage_image_mk_eq_iUnion_image
code: @[to_additive]
theorem preimage_image_mk_eq_iUnion_image (N : Subgroup α) (s : Set α) :
    mk ⁻¹' ((mk : α → α ⧸ N) '' s) = ⋃ x : N, (· * (x : α)) '' s 
goal: QuotientGroup.mk ⁻¹' (QuotientGroup.mk '' s) = ⋃ x, (fun x_1 => x_1 * ↑x) '' s

full_name: QuotientAddGroup.preimage_image_mk_eq_iUnion_image
code: @[to_additive]
theorem preimage_image_mk_eq_iUnion_image (N : Subgroup α) (s : Set α) :
    mk ⁻¹' ((mk : α → α ⧸ N) '' s) = ⋃ x : N, (· * (x : α)) '' s 
goal: QuotientAddGroup.mk ⁻¹' (QuotientAddGroup.mk '' s) = ⋃ x, (fun x_1 => x_1 + ↑x) '' s

full_name: Subgroup.leftCosetEquivSubgroup
code: /-- The natural bijection between a left coset `g * s` and `s`. -/
@[to_additive "The natural bijection between the cosets `g + s` and `s`."]
def leftCosetEquivSubgroup (g : α) : (g • s : Set α) ≃ s 
goal: ↑(g • ↑s) ≃ ↥s

full_name: AddSubgroup.leftCosetEquivAddSubgroup
code: /-- The natural bijection between a left coset `g * s` and `s`. -/
@[to_additive "The natural bijection between the cosets `g + s` and `s`."]
def leftCosetEquivSubgroup (g : α) : (g • s : Set α) ≃ s 
goal: ↑(g +ᵥ ↑s) ≃ ↥s

full_name: AddSubgroup.rightCosetEquivAddSubgroup
code: /-- The natural bijection between a right coset `s * g` and `s`. -/
@[to_additive "The natural bijection between the cosets `s + g` and `s`."]
def rightCosetEquivSubgroup (g : α) : (op g • s : Set α) ≃ s 
goal: ↑(AddOpposite.op g +ᵥ ↑s) ≃ ↥s

full_name: Subgroup.rightCosetEquivSubgroup
code: /-- The natural bijection between a right coset `s * g` and `s`. -/
@[to_additive "The natural bijection between the cosets `s + g` and `s`."]
def rightCosetEquivSubgroup (g : α) : (op g • s : Set α) ≃ s 
goal: ↑(MulOpposite.op g • ↑s) ≃ ↥s

full_name: Subgroup.groupEquivQuotientProdSubgroup
code: /-- A (non-canonical) bijection between a group `α` and the product `(α/s) × s` -/
@[to_additive addGroupEquivQuotientProdAddSubgroup
  "A (non-canonical) bijection between an add_group `α` and the product `(α/s) × s`"]
noncomputable def groupEquivQuotientProdSubgroup : α ≃ (α ⧸ s) × s 
goal: α ≃ (α ⧸ s) × ↥s

full_name: AddSubgroup.addGroupEquivQuotientProdAddSubgroup
code: /-- A (non-canonical) bijection between a group `α` and the product `(α/s) × s` -/
@[to_additive addGroupEquivQuotientProdAddSubgroup
  "A (non-canonical) bijection between an add_group `α` and the product `(α/s) × s`"]
noncomputable def groupEquivQuotientProdSubgroup : α ≃ (α ⧸ s) × s 
goal: α ≃ (α ⧸ s) × ↥s

full_name: Subgroup.quotientEquivOfEq
code: /-- If two subgroups `M` and `N` of `G` are equal, their quotients are in bijection. -/
@[to_additive "If two subgroups `M` and `N` of `G` are equal, their quotients are in bijection."]
def quotientEquivOfEq (h : s = t) : α ⧸ s ≃ α ⧸ t 
goal: α ⧸ s ≃ α ⧸ t

full_name: AddSubgroup.quotientEquivOfEq
code: /-- If two subgroups `M` and `N` of `G` are equal, their quotients are in bijection. -/
@[to_additive "If two subgroups `M` and `N` of `G` are equal, their quotients are in bijection."]
def quotientEquivOfEq (h : s = t) : α ⧸ s ≃ α ⧸ t 
goal: α ⧸ s ≃ α ⧸ t

full_name: Subgroup.quotientEquivOfEq_mk
code: theorem quotientEquivOfEq_mk (h : s = t) (a : α) :
    quotientEquivOfEq h (QuotientGroup.mk a) = QuotientGroup.mk a 
goal: (Subgroup.quotientEquivOfEq h) ↑a = ↑a

full_name: AddSubgroup.quotientEquivSumOfLE'_symm_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. -/
@[to_additive (attr := simps)
  "If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
  of the quotient map `G → G/K`. The classical version is `AddSubgroup.quotientEquivSumOfLE`."]
def quotientEquivProdOfLE' (h_le : s ≤ t) (f : α ⧸ t → α)
    (hf : Function.RightInverse f QuotientGroup.mk) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (AddSubgroup.quotientEquivSumOfLE' h_le f hf).symm a = Quotient.map' (fun b => f a.1 + ↑b) ⋯ a.2

full_name: Subgroup.quotientEquivProdOfLE'
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. -/
@[to_additive (attr := simps)
  "If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
  of the quotient map `G → G/K`. The classical version is `AddSubgroup.quotientEquivSumOfLE`."]
def quotientEquivProdOfLE' (h_le : s ≤ t) (f : α ⧸ t → α)
    (hf : Function.RightInverse f QuotientGroup.mk) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: α ⧸ s ≃ (α ⧸ t) × ↥t ⧸ s.subgroupOf t

full_name: AddSubgroup.quotientEquivSumOfLE'_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. -/
@[to_additive (attr := simps)
  "If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
  of the quotient map `G → G/K`. The classical version is `AddSubgroup.quotientEquivSumOfLE`."]
def quotientEquivProdOfLE' (h_le : s ≤ t) (f : α ⧸ t → α)
    (hf : Function.RightInverse f QuotientGroup.mk) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (AddSubgroup.quotientEquivSumOfLE' h_le f hf) a =
  (Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨-f (Quotient.mk'' g) + g, ⋯⟩) ⋯ a)

full_name: AddSubgroup.quotientEquivSumOfLE'
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. -/
@[to_additive (attr := simps)
  "If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
  of the quotient map `G → G/K`. The classical version is `AddSubgroup.quotientEquivSumOfLE`."]
def quotientEquivProdOfLE' (h_le : s ≤ t) (f : α ⧸ t → α)
    (hf : Function.RightInverse f QuotientGroup.mk) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: α ⧸ s ≃ (α ⧸ t) × ↥t ⧸ s.addSubgroupOf t

full_name: Subgroup.quotientEquivProdOfLE'_symm_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. -/
@[to_additive (attr := simps)
  "If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
  of the quotient map `G → G/K`. The classical version is `AddSubgroup.quotientEquivSumOfLE`."]
def quotientEquivProdOfLE' (h_le : s ≤ t) (f : α ⧸ t → α)
    (hf : Function.RightInverse f QuotientGroup.mk) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (Subgroup.quotientEquivProdOfLE' h_le f hf).symm a = Quotient.map' (fun b => f a.1 * ↑b) ⋯ a.2

full_name: Subgroup.quotientEquivProdOfLE'_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. -/
@[to_additive (attr := simps)
  "If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
  of the quotient map `G → G/K`. The classical version is `AddSubgroup.quotientEquivSumOfLE`."]
def quotientEquivProdOfLE' (h_le : s ≤ t) (f : α ⧸ t → α)
    (hf : Function.RightInverse f QuotientGroup.mk) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (Subgroup.quotientEquivProdOfLE' h_le f hf) a =
  (Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨(f (Quotient.mk'' g))⁻¹ * g, ⋯⟩) ⋯ a)

full_name: AddSubgroup.quotientEquivSumOfLE_symm_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively.
The constructive version is `quotientEquivProdOfLE'`. -/
@[to_additive (attr := simps!) "If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively. The
 constructive version is `quotientEquivProdOfLE'`."]
noncomputable def quotientEquivProdOfLE (h_le : s ≤ t) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (AddSubgroup.quotientEquivSumOfLE h_le).symm a = Quotient.map' (fun b => Quotient.out' a.1 + ↑b) ⋯ a.2

full_name: AddSubgroup.quotientEquivSumOfLE
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively.
The constructive version is `quotientEquivProdOfLE'`. -/
@[to_additive (attr := simps!) "If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively. The
 constructive version is `quotientEquivProdOfLE'`."]
noncomputable def quotientEquivProdOfLE (h_le : s ≤ t) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: α ⧸ s ≃ (α ⧸ t) × ↥t ⧸ s.addSubgroupOf t

full_name: AddSubgroup.quotientEquivSumOfLE_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively.
The constructive version is `quotientEquivProdOfLE'`. -/
@[to_additive (attr := simps!) "If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively. The
 constructive version is `quotientEquivProdOfLE'`."]
noncomputable def quotientEquivProdOfLE (h_le : s ≤ t) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (AddSubgroup.quotientEquivSumOfLE h_le) a =
  (Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨-(Quotient.mk'' g).out' + g, ⋯⟩) ⋯ a)

full_name: Subgroup.quotientEquivProdOfLE
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively.
The constructive version is `quotientEquivProdOfLE'`. -/
@[to_additive (attr := simps!) "If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively. The
 constructive version is `quotientEquivProdOfLE'`."]
noncomputable def quotientEquivProdOfLE (h_le : s ≤ t) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: α ⧸ s ≃ (α ⧸ t) × ↥t ⧸ s.subgroupOf t

full_name: Subgroup.quotientEquivProdOfLE_symm_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively.
The constructive version is `quotientEquivProdOfLE'`. -/
@[to_additive (attr := simps!) "If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively. The
 constructive version is `quotientEquivProdOfLE'`."]
noncomputable def quotientEquivProdOfLE (h_le : s ≤ t) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (Subgroup.quotientEquivProdOfLE h_le).symm a = Quotient.map' (fun b => Quotient.out' a.1 * ↑b) ⋯ a.2

full_name: Subgroup.quotientEquivProdOfLE_apply
code: /-- If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively.
The constructive version is `quotientEquivProdOfLE'`. -/
@[to_additive (attr := simps!) "If `H ≤ K`, then `G/H ≃ G/K × K/H` nonconstructively. The
 constructive version is `quotientEquivProdOfLE'`."]
noncomputable def quotientEquivProdOfLE (h_le : s ≤ t) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t 
goal: (Subgroup.quotientEquivProdOfLE h_le) a =
  (Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨(Quotient.mk'' g).out'⁻¹ * g, ⋯⟩) ⋯ a)

full_name: Subgroup.quotientSubgroupOfEmbeddingOfLE
code: /-- If `s ≤ t`, then there is an embedding `s ⧸ H.subgroupOf s ↪ t ⧸ H.subgroupOf t`. -/
@[to_additive "If `s ≤ t`, then there is an embedding
 `s ⧸ H.addSubgroupOf s ↪ t ⧸ H.addSubgroupOf t`."]
def quotientSubgroupOfEmbeddingOfLE (H : Subgroup α) (h : s ≤ t) :
    s ⧸ H.subgroupOf s ↪ t ⧸ H.subgroupOf t 
goal: ↥s ⧸ H.subgroupOf s ↪ ↥t ⧸ H.subgroupOf t

full_name: AddSubgroup.quotientAddSubgroupOfEmbeddingOfLE
code: /-- If `s ≤ t`, then there is an embedding `s ⧸ H.subgroupOf s ↪ t ⧸ H.subgroupOf t`. -/
@[to_additive "If `s ≤ t`, then there is an embedding
 `s ⧸ H.addSubgroupOf s ↪ t ⧸ H.addSubgroupOf t`."]
def quotientSubgroupOfEmbeddingOfLE (H : Subgroup α) (h : s ≤ t) :
    s ⧸ H.subgroupOf s ↪ t ⧸ H.subgroupOf t 
goal: ↥s ⧸ H.addSubgroupOf s ↪ ↥t ⧸ H.addSubgroupOf t

full_name: AddSubgroup.quotientAddSubgroupOfEmbeddingOfLE_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientSubgroupOfEmbeddingOfLE_apply_mk (H : Subgroup α) (h : s ≤ t) (g : s) :
    quotientSubgroupOfEmbeddingOfLE H h (QuotientGroup.mk g) =
      (QuotientGroup.mk (inclusion h g) : (fun _ => { x // x ∈ t } ⧸ subgroupOf H t) ↑g) 
goal: (AddSubgroup.quotientAddSubgroupOfEmbeddingOfLE H h) ↑g = ↑((AddSubgroup.inclusion h) g)

full_name: Subgroup.quotientSubgroupOfEmbeddingOfLE_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientSubgroupOfEmbeddingOfLE_apply_mk (H : Subgroup α) (h : s ≤ t) (g : s) :
    quotientSubgroupOfEmbeddingOfLE H h (QuotientGroup.mk g) =
      (QuotientGroup.mk (inclusion h g) : (fun _ => { x // x ∈ t } ⧸ subgroupOf H t) ↑g) 
goal: (Subgroup.quotientSubgroupOfEmbeddingOfLE H h) ↑g = ↑((Subgroup.inclusion h) g)

full_name: Subgroup.quotientSubgroupOfMapOfLE
code: /-- If `s ≤ t`, then there is a map `H ⧸ s.subgroupOf H → H ⧸ t.subgroupOf H`. -/
@[to_additive "If `s ≤ t`, then there is a map `H ⧸ s.addSubgroupOf H → H ⧸ t.addSubgroupOf H`."]
def quotientSubgroupOfMapOfLE (H : Subgroup α) (h : s ≤ t) :
    H ⧸ s.subgroupOf H → H ⧸ t.subgroupOf H 
goal: ↥H ⧸ s.subgroupOf H → ↥H ⧸ t.subgroupOf H

full_name: AddSubgroup.quotientAddSubgroupOfMapOfLE
code: /-- If `s ≤ t`, then there is a map `H ⧸ s.subgroupOf H → H ⧸ t.subgroupOf H`. -/
@[to_additive "If `s ≤ t`, then there is a map `H ⧸ s.addSubgroupOf H → H ⧸ t.addSubgroupOf H`."]
def quotientSubgroupOfMapOfLE (H : Subgroup α) (h : s ≤ t) :
    H ⧸ s.subgroupOf H → H ⧸ t.subgroupOf H 
goal: ↥H ⧸ s.addSubgroupOf H → ↥H ⧸ t.addSubgroupOf H

full_name: Subgroup.quotientSubgroupOfMapOfLE_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientSubgroupOfMapOfLE_apply_mk (H : Subgroup α) (h : s ≤ t) (g : H) :
    quotientSubgroupOfMapOfLE H h (QuotientGroup.mk g) =
      (QuotientGroup.mk g : { x // x ∈ H } ⧸ subgroupOf t H) 
goal: Subgroup.quotientSubgroupOfMapOfLE H h ↑g = ↑g

full_name: AddSubgroup.quotientAddSubgroupOfMapOfLE_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientSubgroupOfMapOfLE_apply_mk (H : Subgroup α) (h : s ≤ t) (g : H) :
    quotientSubgroupOfMapOfLE H h (QuotientGroup.mk g) =
      (QuotientGroup.mk g : { x // x ∈ H } ⧸ subgroupOf t H) 
goal: AddSubgroup.quotientAddSubgroupOfMapOfLE H h ↑g = ↑g

full_name: Subgroup.quotientMapOfLE
code: /-- If `s ≤ t`, then there is a map `α ⧸ s → α ⧸ t`. -/
@[to_additive "If `s ≤ t`, then there is a map `α ⧸ s → α ⧸ t`."]
def quotientMapOfLE (h : s ≤ t) : α ⧸ s → α ⧸ t 
goal: α ⧸ s → α ⧸ t

full_name: AddSubgroup.quotientMapOfLE
code: /-- If `s ≤ t`, then there is a map `α ⧸ s → α ⧸ t`. -/
@[to_additive "If `s ≤ t`, then there is a map `α ⧸ s → α ⧸ t`."]
def quotientMapOfLE (h : s ≤ t) : α ⧸ s → α ⧸ t 
goal: α ⧸ s → α ⧸ t

full_name: Subgroup.quotientMapOfLE_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientMapOfLE_apply_mk (h : s ≤ t) (g : α) :
    quotientMapOfLE h (QuotientGroup.mk g) = QuotientGroup.mk g 
goal: Subgroup.quotientMapOfLE h ↑g = ↑g

full_name: AddSubgroup.quotientMapOfLE_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientMapOfLE_apply_mk (h : s ≤ t) (g : α) :
    quotientMapOfLE h (QuotientGroup.mk g) = QuotientGroup.mk g 
goal: AddSubgroup.quotientMapOfLE h ↑g = ↑g

full_name: AddSubgroup.quotientiInfAddSubgroupOfEmbedding
code: /-- The natural embedding `H ⧸ (⨅ i, f i).subgroupOf H ↪ Π i, H ⧸ (f i).subgroupOf H`. -/
@[to_additive (attr := simps) "The natural embedding
 `H ⧸ (⨅ i, f i).addSubgroupOf H) ↪ Π i, H ⧸ (f i).addSubgroupOf H`."]
def quotientiInfSubgroupOfEmbedding {ι : Type*} (f : ι → Subgroup α) (H : Subgroup α) :
    H ⧸ (⨅ i, f i).subgroupOf H ↪ ∀ i, H ⧸ (f i).subgroupOf H 
goal: ↥H ⧸ (⨅ i, f i).addSubgroupOf H ↪ (i : ι) → ↥H ⧸ (f i).addSubgroupOf H

full_name: Subgroup.quotientiInfSubgroupOfEmbedding_apply
code: /-- The natural embedding `H ⧸ (⨅ i, f i).subgroupOf H ↪ Π i, H ⧸ (f i).subgroupOf H`. -/
@[to_additive (attr := simps) "The natural embedding
 `H ⧸ (⨅ i, f i).addSubgroupOf H) ↪ Π i, H ⧸ (f i).addSubgroupOf H`."]
def quotientiInfSubgroupOfEmbedding {ι : Type*} (f : ι → Subgroup α) (H : Subgroup α) :
    H ⧸ (⨅ i, f i).subgroupOf H ↪ ∀ i, H ⧸ (f i).subgroupOf H 
goal: (Subgroup.quotientiInfSubgroupOfEmbedding f H) q i = Subgroup.quotientSubgroupOfMapOfLE H ⋯ q

full_name: Subgroup.quotientiInfSubgroupOfEmbedding
code: /-- The natural embedding `H ⧸ (⨅ i, f i).subgroupOf H ↪ Π i, H ⧸ (f i).subgroupOf H`. -/
@[to_additive (attr := simps) "The natural embedding
 `H ⧸ (⨅ i, f i).addSubgroupOf H) ↪ Π i, H ⧸ (f i).addSubgroupOf H`."]
def quotientiInfSubgroupOfEmbedding {ι : Type*} (f : ι → Subgroup α) (H : Subgroup α) :
    H ⧸ (⨅ i, f i).subgroupOf H ↪ ∀ i, H ⧸ (f i).subgroupOf H 
goal: ↥H ⧸ (⨅ i, f i).subgroupOf H ↪ (i : ι) → ↥H ⧸ (f i).subgroupOf H

full_name: AddSubgroup.quotientiInfAddSubgroupOfEmbedding_apply
code: /-- The natural embedding `H ⧸ (⨅ i, f i).subgroupOf H ↪ Π i, H ⧸ (f i).subgroupOf H`. -/
@[to_additive (attr := simps) "The natural embedding
 `H ⧸ (⨅ i, f i).addSubgroupOf H) ↪ Π i, H ⧸ (f i).addSubgroupOf H`."]
def quotientiInfSubgroupOfEmbedding {ι : Type*} (f : ι → Subgroup α) (H : Subgroup α) :
    H ⧸ (⨅ i, f i).subgroupOf H ↪ ∀ i, H ⧸ (f i).subgroupOf H 
goal: (AddSubgroup.quotientiInfAddSubgroupOfEmbedding f H) q i = AddSubgroup.quotientAddSubgroupOfMapOfLE H ⋯ q

full_name: Subgroup.quotientiInfSubgroupOfEmbedding_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientiInfSubgroupOfEmbedding_apply_mk {ι : Type*} (f : ι → Subgroup α) (H : Subgroup α)
    (g : H) (i : ι) :
    quotientiInfSubgroupOfEmbedding f H (QuotientGroup.mk g) i =
      (QuotientGroup.mk g : { x // x ∈ H } ⧸ subgroupOf (f i) H) 
goal: (Subgroup.quotientiInfSubgroupOfEmbedding f H) (↑g) i = ↑g

full_name: AddSubgroup.quotientiInfAddSubgroupOfEmbedding_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientiInfSubgroupOfEmbedding_apply_mk {ι : Type*} (f : ι → Subgroup α) (H : Subgroup α)
    (g : H) (i : ι) :
    quotientiInfSubgroupOfEmbedding f H (QuotientGroup.mk g) i =
      (QuotientGroup.mk g : { x // x ∈ H } ⧸ subgroupOf (f i) H) 
goal: (AddSubgroup.quotientiInfAddSubgroupOfEmbedding f H) (↑g) i = ↑g

full_name: Subgroup.quotientiInfEmbedding_apply
code: /-- The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`. -/
@[to_additive (attr := simps) "The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`."]
def quotientiInfEmbedding {ι : Type*} (f : ι → Subgroup α) : (α ⧸ ⨅ i, f i) ↪ ∀ i, α ⧸ f i 
goal: (Subgroup.quotientiInfEmbedding f) q i = Subgroup.quotientMapOfLE ⋯ q

full_name: AddSubgroup.quotientiInfEmbedding_apply
code: /-- The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`. -/
@[to_additive (attr := simps) "The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`."]
def quotientiInfEmbedding {ι : Type*} (f : ι → Subgroup α) : (α ⧸ ⨅ i, f i) ↪ ∀ i, α ⧸ f i 
goal: (AddSubgroup.quotientiInfEmbedding f) q i = AddSubgroup.quotientMapOfLE ⋯ q

full_name: AddSubgroup.quotientiInfEmbedding
code: /-- The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`. -/
@[to_additive (attr := simps) "The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`."]
def quotientiInfEmbedding {ι : Type*} (f : ι → Subgroup α) : (α ⧸ ⨅ i, f i) ↪ ∀ i, α ⧸ f i 
goal: α ⧸ ⨅ i, f i ↪ (i : ι) → α ⧸ f i

full_name: Subgroup.quotientiInfEmbedding
code: /-- The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`. -/
@[to_additive (attr := simps) "The natural embedding `α ⧸ (⨅ i, f i) ↪ Π i, α ⧸ f i`."]
def quotientiInfEmbedding {ι : Type*} (f : ι → Subgroup α) : (α ⧸ ⨅ i, f i) ↪ ∀ i, α ⧸ f i 
goal: α ⧸ ⨅ i, f i ↪ (i : ι) → α ⧸ f i

full_name: AddSubgroup.quotientiInfEmbedding_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientiInfEmbedding_apply_mk {ι : Type*} (f : ι → Subgroup α) (g : α) (i : ι) :
    quotientiInfEmbedding f (QuotientGroup.mk g) i = QuotientGroup.mk g 
goal: (AddSubgroup.quotientiInfEmbedding f) (↑g) i = ↑g

full_name: Subgroup.quotientiInfEmbedding_apply_mk
code: @[to_additive (attr := simp)]
theorem quotientiInfEmbedding_apply_mk {ι : Type*} (f : ι → Subgroup α) (g : α) (i : ι) :
    quotientiInfEmbedding f (QuotientGroup.mk g) i = QuotientGroup.mk g 
goal: (Subgroup.quotientiInfEmbedding f) (↑g) i = ↑g

full_name: AddSubgroup.card_eq_card_quotient_mul_card_addSubgroup
code: @[to_additive AddSubgroup.card_eq_card_quotient_mul_card_addSubgroup]
theorem card_eq_card_quotient_mul_card_subgroup (s : Subgroup α) :
    Nat.card α = Nat.card (α ⧸ s) * Nat.card s 
goal: Nat.card α = Nat.card (α ⧸ s) * Nat.card ↥s

full_name: Subgroup.card_eq_card_quotient_mul_card_subgroup
code: @[to_additive AddSubgroup.card_eq_card_quotient_mul_card_addSubgroup]
theorem card_eq_card_quotient_mul_card_subgroup (s : Subgroup α) :
    Nat.card α = Nat.card (α ⧸ s) * Nat.card s 
goal: Nat.card α = Nat.card (α ⧸ s) * Nat.card ↥s

full_name: AddSubgroup.card_addSubgroup_dvd_card
code: /-- **Lagrange's Theorem**: The order of a subgroup divides the order of its ambient group. -/
@[to_additive "**Lagrange's Theorem**: The order of an additive subgroup divides the order of its
 ambient additive group."]
theorem card_subgroup_dvd_card (s : Subgroup α) : Nat.card s ∣ Nat.card α 
goal: Nat.card ↥s ∣ Nat.card α

full_name: Subgroup.card_subgroup_dvd_card
code: /-- **Lagrange's Theorem**: The order of a subgroup divides the order of its ambient group. -/
@[to_additive "**Lagrange's Theorem**: The order of an additive subgroup divides the order of its
 ambient additive group."]
theorem card_subgroup_dvd_card (s : Subgroup α) : Nat.card s ∣ Nat.card α 
goal: Nat.card ↥s ∣ Nat.card α

full_name: AddSubgroup.card_quotient_dvd_card
code: @[to_additive]
theorem card_quotient_dvd_card (s : Subgroup α) : Nat.card (α ⧸ s) ∣ Nat.card α 
goal: Nat.card (α ⧸ s) ∣ Nat.card α

full_name: Subgroup.card_quotient_dvd_card
code: @[to_additive]
theorem card_quotient_dvd_card (s : Subgroup α) : Nat.card (α ⧸ s) ∣ Nat.card α 
goal: Nat.card (α ⧸ s) ∣ Nat.card α

full_name: AddSubgroup.card_dvd_of_injective
code: @[to_additive]
theorem card_dvd_of_injective (f : α →* H) (hf : Function.Injective f) :
    Nat.card α ∣ Nat.card H 
goal: Nat.card α ∣ Nat.card H

full_name: Subgroup.card_dvd_of_injective
code: @[to_additive]
theorem card_dvd_of_injective (f : α →* H) (hf : Function.Injective f) :
    Nat.card α ∣ Nat.card H 
goal: Nat.card α ∣ Nat.card H

full_name: AddSubgroup.card_dvd_of_le
code: @[to_additive]
theorem card_dvd_of_le {H K : Subgroup α} (hHK : H ≤ K) : Nat.card H ∣ Nat.card K 
goal: Nat.card ↥H ∣ Nat.card ↥K

full_name: Subgroup.card_dvd_of_le
code: @[to_additive]
theorem card_dvd_of_le {H K : Subgroup α} (hHK : H ≤ K) : Nat.card H ∣ Nat.card K 
goal: Nat.card ↥H ∣ Nat.card ↥K

full_name: Subgroup.card_comap_dvd_of_injective
code: @[to_additive]
theorem card_comap_dvd_of_injective (K : Subgroup H) (f : α →* H)
    (hf : Function.Injective f) : Nat.card (K.comap f) ∣ Nat.card K 
goal: Nat.card ↥(Subgroup.comap f K) ∣ Nat.card ↥K

full_name: AddSubgroup.card_comap_dvd_of_injective
code: @[to_additive]
theorem card_comap_dvd_of_injective (K : Subgroup H) (f : α →* H)
    (hf : Function.Injective f) : Nat.card (K.comap f) ∣ Nat.card K 
goal: Nat.card ↥(AddSubgroup.comap f K) ∣ Nat.card ↥K

full_name: AddMonoidHom.fiberEquivKer
code: /-- An equivalence between any non-empty fiber of a `MonoidHom` and its kernel. -/
@[to_additive "An equivalence between any non-empty fiber of an `AddMonoidHom` and its kernel."]
def fiberEquivKer (f : α →* H) (a : α) : f ⁻¹' {f a} ≃ f.ker 
goal: ↑(⇑f ⁻¹' {f a}) ≃ ↥f.ker

full_name: MonoidHom.fiberEquivKer
code: /-- An equivalence between any non-empty fiber of a `MonoidHom` and its kernel. -/
@[to_additive "An equivalence between any non-empty fiber of an `AddMonoidHom` and its kernel."]
def fiberEquivKer (f : α →* H) (a : α) : f ⁻¹' {f a} ≃ f.ker 
goal: ↑(⇑f ⁻¹' {f a}) ≃ ↥f.ker

full_name: MonoidHom.fiberEquivKer_apply
code: @[to_additive (attr := simp)]
lemma fiberEquivKer_apply (f : α →* H) (a : α) (g : f ⁻¹' {f a}) : f.fiberEquivKer a g = a⁻¹ * g 
goal: ↑((f.fiberEquivKer a) g) = a⁻¹ * ↑g

full_name: AddMonoidHom.fiberEquivKer_apply
code: @[to_additive (attr := simp)]
lemma fiberEquivKer_apply (f : α →* H) (a : α) (g : f ⁻¹' {f a}) : f.fiberEquivKer a g = a⁻¹ * g 
goal: ↑((f.fiberEquivKer a) g) = -a + ↑g

full_name: AddMonoidHom.fiberEquivKer_symm_apply
code: @[to_additive (attr := simp)]
lemma fiberEquivKer_symm_apply (f : α →* H) (a : α) (g : f.ker) :
    (f.fiberEquivKer a).symm g = a * g 
goal: ↑((f.fiberEquivKer a).symm g) = a + ↑g

full_name: MonoidHom.fiberEquivKer_symm_apply
code: @[to_additive (attr := simp)]
lemma fiberEquivKer_symm_apply (f : α →* H) (a : α) (g : f.ker) :
    (f.fiberEquivKer a).symm g = a * g 
goal: ↑((f.fiberEquivKer a).symm g) = a * ↑g

full_name: AddMonoidHom.fiberEquivKerOfSurjective
code: /-- An equivalence between any fiber of a surjective `MonoidHom` and its kernel. -/
@[to_additive "An equivalence between any fiber of a surjective `AddMonoidHom` and its kernel."]
noncomputable def fiberEquivKerOfSurjective {f : α →* H} (hf : Function.Surjective f) (h : H) :
    f ⁻¹' {h} ≃ f.ker 
goal: ↑(⇑f ⁻¹' {h}) ≃ ↥f.ker

full_name: MonoidHom.fiberEquivKerOfSurjective
code: /-- An equivalence between any fiber of a surjective `MonoidHom` and its kernel. -/
@[to_additive "An equivalence between any fiber of a surjective `AddMonoidHom` and its kernel."]
noncomputable def fiberEquivKerOfSurjective {f : α →* H} (hf : Function.Surjective f) (h : H) :
    f ⁻¹' {h} ≃ f.ker 
goal: ↑(⇑f ⁻¹' {h}) ≃ ↥f.ker

full_name: MonoidHom.fiberEquiv
code: /-- An equivalence between any two non-empty fibers of a `MonoidHom`. -/
@[to_additive "An equivalence between any two non-empty fibers of an `AddMonoidHom`."]
def fiberEquiv (f : α →* H) (a b : α) : f ⁻¹' {f a} ≃ f ⁻¹' {f b} 
goal: ↑(⇑f ⁻¹' {f a}) ≃ ↑(⇑f ⁻¹' {f b})

full_name: AddMonoidHom.fiberEquiv
code: /-- An equivalence between any two non-empty fibers of a `MonoidHom`. -/
@[to_additive "An equivalence between any two non-empty fibers of an `AddMonoidHom`."]
def fiberEquiv (f : α →* H) (a b : α) : f ⁻¹' {f a} ≃ f ⁻¹' {f b} 
goal: ↑(⇑f ⁻¹' {f a}) ≃ ↑(⇑f ⁻¹' {f b})

full_name: MonoidHom.fiberEquiv_apply
code: @[to_additive (attr := simp)]
lemma fiberEquiv_apply (f : α →* H) (a b : α) (g : f ⁻¹' {f a}) :
    f.fiberEquiv a b g = b * (a⁻¹ * g) 
goal: ↑((f.fiberEquiv a b) g) = b * (a⁻¹ * ↑g)

full_name: AddMonoidHom.fiberEquiv_apply
code: @[to_additive (attr := simp)]
lemma fiberEquiv_apply (f : α →* H) (a b : α) (g : f ⁻¹' {f a}) :
    f.fiberEquiv a b g = b * (a⁻¹ * g) 
goal: ↑((f.fiberEquiv a b) g) = b + (-a + ↑g)

full_name: AddMonoidHom.fiberEquiv_symm_apply
code: @[to_additive (attr := simp)]
lemma fiberEquiv_symm_apply (f : α →* H) (a b : α) (g : f ⁻¹' {f b}) :
    (f.fiberEquiv a b).symm g = a * (b⁻¹ * g) 
goal: ↑((f.fiberEquiv a b).symm g) = a + (-b + ↑g)

full_name: MonoidHom.fiberEquiv_symm_apply
code: @[to_additive (attr := simp)]
lemma fiberEquiv_symm_apply (f : α →* H) (a b : α) (g : f ⁻¹' {f b}) :
    (f.fiberEquiv a b).symm g = a * (b⁻¹ * g) 
goal: ↑((f.fiberEquiv a b).symm g) = a * (b⁻¹ * ↑g)

full_name: AddMonoidHom.fiberEquivOfSurjective
code: /-- An equivalence between any two fibers of a surjective `MonoidHom`. -/
@[to_additive "An equivalence between any two fibers of a surjective `AddMonoidHom`."]
noncomputable def fiberEquivOfSurjective {f : α →* H} (hf : Function.Surjective f) (h h' : H) :
    f ⁻¹' {h} ≃ f ⁻¹' {h'} 
goal: ↑(⇑f ⁻¹' {h}) ≃ ↑(⇑f ⁻¹' {h'})

full_name: MonoidHom.fiberEquivOfSurjective
code: /-- An equivalence between any two fibers of a surjective `MonoidHom`. -/
@[to_additive "An equivalence between any two fibers of a surjective `AddMonoidHom`."]
noncomputable def fiberEquivOfSurjective {f : α →* H} (hf : Function.Surjective f) (h h' : H) :
    f ⁻¹' {h} ≃ f ⁻¹' {h'} 
goal: ↑(⇑f ⁻¹' {h}) ≃ ↑(⇑f ⁻¹' {h'})

full_name: QuotientGroup.preimageMkEquivSubgroupProdSet
code: /-- If `s` is a subgroup of the group `α`, and `t` is a subset of `α ⧸ s`, then there is a
(typically non-canonical) bijection between the preimage of `t` in `α` and the product `s × t`. -/
@[to_additive preimageMkEquivAddSubgroupProdSet
"If `s` is a subgroup of the additive group `α`, and `t` is a subset of `α ⧸ s`, then
 there is a (typically non-canonical) bijection between the preimage of `t` in `α` and the product
 `s × t`."]
noncomputable def preimageMkEquivSubgroupProdSet (s : Subgroup α) (t : Set (α ⧸ s)) :
    QuotientGroup.mk ⁻¹' t ≃ s × t 
goal: ↑(QuotientGroup.mk ⁻¹' t) ≃ ↥s × ↑t

full_name: QuotientAddGroup.preimageMkEquivAddSubgroupProdSet
code: /-- If `s` is a subgroup of the group `α`, and `t` is a subset of `α ⧸ s`, then there is a
(typically non-canonical) bijection between the preimage of `t` in `α` and the product `s × t`. -/
@[to_additive preimageMkEquivAddSubgroupProdSet
"If `s` is a subgroup of the additive group `α`, and `t` is a subset of `α ⧸ s`, then
 there is a (typically non-canonical) bijection between the preimage of `t` in `α` and the product
 `s × t`."]
noncomputable def preimageMkEquivSubgroupProdSet (s : Subgroup α) (t : Set (α ⧸ s)) :
    QuotientGroup.mk ⁻¹' t ≃ s × t 
goal: ↑(QuotientAddGroup.mk ⁻¹' t) ≃ ↥s × ↑t