/-

Copyright (c) 2020 Kexing Ying. All rights reserved.

Released under Apache 2.0 license as described in the file LICENSE.

Authors: Kexing Ying

-/

import algebra.group.conj

import algebra.module.basic

import algebra.order.group.inj_surj

import data.countable.basic

import group_theory.submonoid.centralizer

import logic.encodable.basic

import order.atoms

import tactic.apply_fun

/-!

# Subgroups

> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.

> Any changes to this file require a corresponding PR to mathlib4.

This file defines multiplicative and additive subgroups as an extension of submonoids, in a bundled

form (unbundled subgroups are in `deprecated/subgroups.lean`).

We prove subgroups of a group form a complete lattice, and results about images and preimages of

subgroups under group homomorphisms. The bundled subgroups use bundled monoid homomorphisms.

There are also theorems about the subgroups generated by an element or a subset of a group,

defined both inductively and as the infimum of the set of subgroups containing a given

element/subset.

Special thanks goes to Amelia Livingston and Yury Kudryashov for their help and inspiration.

## Main definitions

Notation used here:

- `G N` are `group`s

- `A` is an `add_group`

- `H K` are `subgroup`s of `G` or `add_subgroup`s of `A`

- `x` is an element of type `G` or type `A`

- `f g : N →* G` are group homomorphisms

- `s k` are sets of elements of type `G`

Definitions in the file:

* `subgroup G` : the type of subgroups of a group `G`

* `add_subgroup A` : the type of subgroups of an additive group `A`

* `complete_lattice (subgroup G)` : the subgroups of `G` form a complete lattice

* `subgroup.closure k` : the minimal subgroup that includes the set `k`

* `subgroup.subtype` : the natural group homomorphism from a subgroup of group `G` to `G`

* `subgroup.gi` : `closure` forms a Galois insertion with the coercion to set

* `subgroup.comap H f` : the preimage of a subgroup `H` along the group homomorphism `f` is also a

subgroup

* `subgroup.map f H` : the image of a subgroup `H` along the group homomorphism `f` is also a

subgroup

* `subgroup.prod H K` : the product of subgroups `H`, `K` of groups `G`, `N` respectively, `H × K`

is a subgroup of `G × N`

* `monoid_hom.range f` : the range of the group homomorphism `f` is a subgroup

* `monoid_hom.ker f` : the kernel of a group homomorphism `f` is the subgroup of elements `x : G`

such that `f x = 1`

* `monoid_hom.eq_locus f g` : given group homomorphisms `f`, `g`, the elements of `G` such that

`f x = g x` form a subgroup of `G`

## Implementation notes

Subgroup inclusion is denoted `≤` rather than `⊆`, although `∈` is defined as

membership of a subgroup's underlying set.

## Tags

subgroup, subgroups

-/

open function

variables {G G' : Type*} [group G] [group G']

variables {A : Type*} [add_group A]

section subgroup_class

/-- `inv_mem_class S G` states `S` is a type of subsets `s ⊆ G` closed under inverses. -/

class inv_mem_class (S G : Type*) [has_inv G] [set_like S G] : Prop :=

(inv_mem : ∀ {s : S} {x}, x ∈ s → x⁻¹ ∈ s)

export inv_mem_class (inv_mem)

/-- `neg_mem_class S G` states `S` is a type of subsets `s ⊆ G` closed under negation. -/

class neg_mem_class (S G : Type*) [has_neg G] [set_like S G] : Prop :=

(neg_mem : ∀ {s : S} {x}, x ∈ s → -x ∈ s)

export neg_mem_class (neg_mem)

/-- `subgroup_class S G` states `S` is a type of subsets `s ⊆ G` that are subgroups of `G`. -/

class subgroup_class (S G : Type*) [div_inv_monoid G] [set_like S G]

extends submonoid_class S G, inv_mem_class S G : Prop

/-- `add_subgroup_class S G` states `S` is a type of subsets `s ⊆ G` that are

additive subgroups of `G`. -/

class add_subgroup_class (S G : Type*) [sub_neg_monoid G] [set_like S G]

extends add_submonoid_class S G, neg_mem_class S G : Prop

attribute [to_additive] inv_mem_class subgroup_class

@[simp, to_additive]

theorem inv_mem_iff {S G} [has_involutive_inv G] [set_like S G] [inv_mem_class S G] {H : S}

{x : G} : x⁻¹ ∈ H ↔ x ∈ H :=

⟨λ h, inv_inv x ▸ inv_mem h, inv_mem⟩

variables {M S : Type*} [div_inv_monoid M] [set_like S M] [hSM : subgroup_class S M] {H K : S}

include hSM

/-- A subgroup is closed under division. -/

@[to_additive "An additive subgroup is closed under subtraction."]

theorem div_mem {x y : M} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H :=

by rw [div_eq_mul_inv]; exact mul_mem hx (inv_mem hy)

@[to_additive]

lemma zpow_mem {x : M} (hx : x ∈ K) : ∀ n : ℤ, x ^ n ∈ K

| (n : ℕ) := by { rw [zpow_coe_nat], exact pow_mem hx n }

| -[1+ n] := by { rw [zpow_neg_succ_of_nat], exact inv_mem (pow_mem hx n.succ) }

omit hSM

variables [set_like S G] [hSG : subgroup_class S G]

include hSG

@[to_additive] lemma div_mem_comm_iff {a b : G} : a / b ∈ H ↔ b / a ∈ H :=

by rw [← inv_mem_iff, div_eq_mul_inv, div_eq_mul_inv, mul_inv_rev, inv_inv]

@[simp, to_additive]

lemma exists_inv_mem_iff_exists_mem {P : G → Prop} :

(∃ (x : G), x ∈ H ∧ P x⁻¹) ↔ ∃ x ∈ H, P x :=

by split; { rintros ⟨x, x_in, hx⟩, exact ⟨x⁻¹, inv_mem x_in, by simp [hx]⟩ }

@[to_additive]

lemma mul_mem_cancel_right {x y : G} (h : x ∈ H) : y * x ∈ H ↔ y ∈ H :=

⟨λ hba, by simpa using mul_mem hba (inv_mem h), λ hb, mul_mem hb h⟩

@[to_additive]

lemma mul_mem_cancel_left {x y : G} (h : x ∈ H) : x * y ∈ H ↔ y ∈ H :=

⟨λ hab, by simpa using mul_mem (inv_mem h) hab, mul_mem h⟩

namespace subgroup_class

omit hSG

include hSM

/-- A subgroup of a group inherits an inverse. -/

@[to_additive "An additive subgroup of a `add_group` inherits an inverse."]

instance has_inv : has_inv H := ⟨λ a, ⟨a⁻¹, inv_mem a.2⟩⟩

/-- A subgroup of a group inherits a division -/

@[to_additive "An additive subgroup of an `add_group` inherits a subtraction."]

instance has_div : has_div H := ⟨λ a b, ⟨a / b, div_mem a.2 b.2⟩⟩

omit hSM

/-- An additive subgroup of an `add_group` inherits an integer scaling. -/

instance _root_.add_subgroup_class.has_zsmul {M S} [sub_neg_monoid M] [set_like S M]

[add_subgroup_class S M] {H : S} : has_smul ℤ H :=

⟨λ n a, ⟨n • a, zsmul_mem a.2 n⟩⟩

include hSM

/-- A subgroup of a group inherits an integer power. -/

@[to_additive]

instance has_zpow : has_pow H ℤ := ⟨λ a n, ⟨a ^ n, zpow_mem a.2 n⟩⟩

@[simp, norm_cast, to_additive] lemma coe_inv (x : H) : ↑(x⁻¹ : H) = (x⁻¹ : M) := rfl

@[simp, norm_cast, to_additive] lemma coe_div (x y : H) : (↑(x / y) : M) = ↑x / ↑y := rfl

omit hSM

variables (H)

include hSG

/-- A subgroup of a group inherits a group structure. -/

@[to_additive "An additive subgroup of an `add_group` inherits an `add_group` structure.",

priority 75] -- Prefer subclasses of `group` over subclasses of `subgroup_class`.

instance to_group : group H :=

subtype.coe_injective.group _ rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

omit hSG

/-- A subgroup of a `comm_group` is a `comm_group`. -/

@[to_additive "An additive subgroup of an `add_comm_group` is an `add_comm_group`.",

priority 75] -- Prefer subclasses of `comm_group` over subclasses of `subgroup_class`.

instance to_comm_group {G : Type*} [comm_group G] [set_like S G] [subgroup_class S G] :

comm_group H :=

subtype.coe_injective.comm_group _ rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

(λ _ _, rfl)

/-- A subgroup of an `ordered_comm_group` is an `ordered_comm_group`. -/

@[to_additive "An additive subgroup of an `add_ordered_comm_group` is an `add_ordered_comm_group`.",

priority 75] -- Prefer subclasses of `group` over subclasses of `subgroup_class`.

instance to_ordered_comm_group {G : Type*} [ordered_comm_group G] [set_like S G]

[subgroup_class S G] : ordered_comm_group H :=

subtype.coe_injective.ordered_comm_group _ rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

(λ _ _, rfl)

/-- A subgroup of a `linear_ordered_comm_group` is a `linear_ordered_comm_group`. -/

@[to_additive "An additive subgroup of a `linear_ordered_add_comm_group` is a

`linear_ordered_add_comm_group`.",

priority 75] -- Prefer subclasses of `group` over subclasses of `subgroup_class`.

instance to_linear_ordered_comm_group {G : Type*} [linear_ordered_comm_group G] [set_like S G]

[subgroup_class S G] : linear_ordered_comm_group H :=

subtype.coe_injective.linear_ordered_comm_group _ rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl)

(λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

include hSG

/-- The natural group hom from a subgroup of group `G` to `G`. -/

@[to_additive "The natural group hom from an additive subgroup of `add_group` `G` to `G`."]

protected def subtype : H →* G := ⟨coe, rfl, λ _ _, rfl⟩

@[simp, to_additive] theorem coe_subtype : (subgroup_class.subtype H : H → G) = coe := rfl

variables {H}

@[simp, norm_cast, to_additive coe_smul]

lemma coe_pow (x : H) (n : ℕ) : ((x ^ n : H) : G) = x ^ n :=

(subgroup_class.subtype H : H →* G).map_pow _ _

@[simp, norm_cast, to_additive] lemma coe_zpow (x : H) (n : ℤ) : ((x ^ n : H) : G) = x ^ n :=

(subgroup_class.subtype H : H →* G).map_zpow _ _

/-- The inclusion homomorphism from a subgroup `H` contained in `K` to `K`. -/

@[to_additive "The inclusion homomorphism from a additive subgroup `H` contained in `K` to `K`."]

def inclusion {H K : S} (h : H ≤ K) : H →* K :=

monoid_hom.mk' (λ x, ⟨x, h x.prop⟩) (λ ⟨a, ha⟩ ⟨b, hb⟩, rfl)

@[simp, to_additive] lemma inclusion_self (x : H) : inclusion le_rfl x = x := by { cases x, refl }

@[simp, to_additive] lemma inclusion_mk {h : H ≤ K} (x : G) (hx : x ∈ H) :

inclusion h ⟨x, hx⟩ = ⟨x, h hx⟩ := rfl

@[to_additive]

lemma inclusion_right (h : H ≤ K) (x : K) (hx : (x : G) ∈ H) : inclusion h ⟨x, hx⟩ = x :=

by { cases x, refl }

@[simp] lemma inclusion_inclusion {L : S} (hHK : H ≤ K) (hKL : K ≤ L) (x : H) :

inclusion hKL (inclusion hHK x) = inclusion (hHK.trans hKL) x :=

by { cases x, refl }

@[simp, to_additive]

lemma coe_inclusion {H K : S} {h : H ≤ K} (a : H) : (inclusion h a : G) = a :=

by { cases a, simp only [inclusion, set_like.coe_mk, monoid_hom.mk'_apply] }

@[simp, to_additive]

lemma subtype_comp_inclusion {H K : S} (hH : H ≤ K) :

(subgroup_class.subtype K).comp (inclusion hH) = subgroup_class.subtype H :=

by { ext, simp only [monoid_hom.comp_apply, coe_subtype, coe_inclusion] }

end subgroup_class

end subgroup_class

set_option old_structure_cmd true

/-- A subgroup of a group `G` is a subset containing 1, closed under multiplication

and closed under multiplicative inverse. -/

structure subgroup (G : Type*) [group G] extends submonoid G :=

(inv_mem' {x} : x ∈ carrier → x⁻¹ ∈ carrier)

/-- An additive subgroup of an additive group `G` is a subset containing 0, closed

under addition and additive inverse. -/

structure add_subgroup (G : Type*) [add_group G] extends add_submonoid G:=

(neg_mem' {x} : x ∈ carrier → -x ∈ carrier)

attribute [to_additive] subgroup

attribute [to_additive add_subgroup.to_add_submonoid] subgroup.to_submonoid

/-- Reinterpret a `subgroup` as a `submonoid`. -/

add_decl_doc subgroup.to_submonoid

/-- Reinterpret an `add_subgroup` as an `add_submonoid`. -/

add_decl_doc add_subgroup.to_add_submonoid

namespace subgroup

@[to_additive]

instance : set_like (subgroup G) G :=

{ coe := subgroup.carrier,

coe_injective' := λ p q h, by cases p; cases q; congr' }

@[to_additive]

instance : subgroup_class (subgroup G) G :=

{ mul_mem := subgroup.mul_mem',

one_mem := subgroup.one_mem',

inv_mem := subgroup.inv_mem' }

@[simp, to_additive]

lemma mem_carrier {s : subgroup G} {x : G} : x ∈ s.carrier ↔ x ∈ s := iff.rfl

@[simp, to_additive]

lemma mem_mk {s : set G} {x : G} (h_one) (h_mul) (h_inv) :

x ∈ mk s h_one h_mul h_inv ↔ x ∈ s := iff.rfl

@[simp, to_additive]

lemma coe_set_mk {s : set G} (h_one) (h_mul) (h_inv) :

(mk s h_one h_mul h_inv : set G) = s := rfl

@[simp, to_additive]

lemma mk_le_mk {s t : set G} (h_one) (h_mul) (h_inv) (h_one') (h_mul') (h_inv') :

mk s h_one h_mul h_inv ≤ mk t h_one' h_mul' h_inv' ↔ s ⊆ t := iff.rfl

/-- See Note [custom simps projection] -/

@[to_additive "See Note [custom simps projection]"]

def simps.coe (S : subgroup G) : set G := S

initialize_simps_projections subgroup (carrier → coe)

initialize_simps_projections add_subgroup (carrier → coe)

@[simp, to_additive]

lemma coe_to_submonoid (K : subgroup G) : (K.to_submonoid : set G) = K := rfl

@[simp, to_additive]

lemma mem_to_submonoid (K : subgroup G) (x : G) : x ∈ K.to_submonoid ↔ x ∈ K := iff.rfl

@[to_additive]

theorem to_submonoid_injective :

function.injective (to_submonoid : subgroup G → submonoid G) :=

λ p q h, set_like.ext'_iff.2 (show _, from set_like.ext'_iff.1 h)

@[simp, to_additive]

theorem to_submonoid_eq {p q : subgroup G} : p.to_submonoid = q.to_submonoid ↔ p = q :=

to_submonoid_injective.eq_iff

@[to_additive, mono] lemma to_submonoid_strict_mono :

strict_mono (to_submonoid : subgroup G → submonoid G) := λ _ _, id

attribute [mono] add_subgroup.to_add_submonoid_strict_mono

@[to_additive, mono]

lemma to_submonoid_mono : monotone (to_submonoid : subgroup G → submonoid G) :=

to_submonoid_strict_mono.monotone

attribute [mono] add_subgroup.to_add_submonoid_mono

@[simp, to_additive]

lemma to_submonoid_le {p q : subgroup G} : p.to_submonoid ≤ q.to_submonoid ↔ p ≤ q :=

iff.rfl

end subgroup

/-!

### Conversion to/from `additive`/`multiplicative`

-/

section mul_add

/-- Supgroups of a group `G` are isomorphic to additive subgroups of `additive G`. -/

@[simps]

def subgroup.to_add_subgroup : subgroup G ≃o add_subgroup (additive G) :=

{ to_fun := λ S,

{ neg_mem' := λ _, S.inv_mem',

..S.to_submonoid.to_add_submonoid },

inv_fun := λ S,

{ inv_mem' := λ _, S.neg_mem',

..S.to_add_submonoid.to_submonoid' },

left_inv := λ x, by cases x; refl,

right_inv := λ x, by cases x; refl,

map_rel_iff' := λ a b, iff.rfl, }

/-- Additive subgroup of an additive group `additive G` are isomorphic to subgroup of `G`. -/

abbreviation add_subgroup.to_subgroup' : add_subgroup (additive G) ≃o subgroup G :=

subgroup.to_add_subgroup.symm

/-- Additive supgroups of an additive group `A` are isomorphic to subgroups of `multiplicative A`.

-/

@[simps]

def add_subgroup.to_subgroup : add_subgroup A ≃o subgroup (multiplicative A) :=

{ to_fun := λ S,

{ inv_mem' := λ _, S.neg_mem',

..S.to_add_submonoid.to_submonoid },

inv_fun := λ S,

{ neg_mem' := λ _, S.inv_mem',

..S.to_submonoid.to_add_submonoid' },

left_inv := λ x, by cases x; refl,

right_inv := λ x, by cases x; refl,

map_rel_iff' := λ a b, iff.rfl, }

/-- Subgroups of an additive group `multiplicative A` are isomorphic to additive subgroups of `A`.

-/

abbreviation subgroup.to_add_subgroup' : subgroup (multiplicative A) ≃o add_subgroup A :=

add_subgroup.to_subgroup.symm

end mul_add

namespace subgroup

variables (H K : subgroup G)

/-- Copy of a subgroup with a new `carrier` equal to the old one. Useful to fix definitional

equalities.-/

@[to_additive "Copy of an additive subgroup with a new `carrier` equal to the old one.

Useful to fix definitional equalities"]

protected def copy (K : subgroup G) (s : set G) (hs : s = K) : subgroup G :=

{ carrier := s,

one_mem' := hs.symm ▸ K.one_mem',

mul_mem' := λ _ _, hs.symm ▸ K.mul_mem',

inv_mem' := λ _, hs.symm ▸ K.inv_mem' }

@[simp, to_additive] lemma coe_copy (K : subgroup G) (s : set G) (hs : s = ↑K) :

(K.copy s hs : set G) = s := rfl

@[to_additive]

lemma copy_eq (K : subgroup G) (s : set G) (hs : s = ↑K) : K.copy s hs = K :=

set_like.coe_injective hs

/-- Two subgroups are equal if they have the same elements. -/

@[ext, to_additive "Two `add_subgroup`s are equal if they have the same elements."]

theorem ext {H K : subgroup G} (h : ∀ x, x ∈ H ↔ x ∈ K) : H = K := set_like.ext h

/-- A subgroup contains the group's 1. -/

@[to_additive "An `add_subgroup` contains the group's 0."]

protected theorem one_mem : (1 : G) ∈ H := one_mem _

/-- A subgroup is closed under multiplication. -/

@[to_additive "An `add_subgroup` is closed under addition."]

protected theorem mul_mem {x y : G} : x ∈ H → y ∈ H → x * y ∈ H := mul_mem

/-- A subgroup is closed under inverse. -/

@[to_additive "An `add_subgroup` is closed under inverse."]

protected theorem inv_mem {x : G} : x ∈ H → x⁻¹ ∈ H := inv_mem

/-- A subgroup is closed under division. -/

@[to_additive "An `add_subgroup` is closed under subtraction."]

protected theorem div_mem {x y : G} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H := div_mem hx hy

@[to_additive] protected theorem inv_mem_iff {x : G} : x⁻¹ ∈ H ↔ x ∈ H := inv_mem_iff

@[to_additive] protected lemma div_mem_comm_iff {a b : G} : a / b ∈ H ↔ b / a ∈ H :=

div_mem_comm_iff

@[to_additive] protected lemma exists_inv_mem_iff_exists_mem (K : subgroup G) {P : G → Prop} :

(∃ (x : G), x ∈ K ∧ P x⁻¹) ↔ ∃ x ∈ K, P x :=

exists_inv_mem_iff_exists_mem

@[to_additive] protected lemma mul_mem_cancel_right {x y : G} (h : x ∈ H) : y * x ∈ H ↔ y ∈ H :=

mul_mem_cancel_right h

@[to_additive] protected lemma mul_mem_cancel_left {x y : G} (h : x ∈ H) : x * y ∈ H ↔ y ∈ H :=

mul_mem_cancel_left h

@[to_additive add_subgroup.nsmul_mem]

protected lemma pow_mem {x : G} (hx : x ∈ K) : ∀ n : ℕ, x ^ n ∈ K := pow_mem hx

@[to_additive]

protected lemma zpow_mem {x : G} (hx : x ∈ K) : ∀ n : ℤ, x ^ n ∈ K := zpow_mem hx

/-- Construct a subgroup from a nonempty set that is closed under division. -/

@[to_additive "Construct a subgroup from a nonempty set that is closed under subtraction"]

def of_div (s : set G) (hsn : s.nonempty) (hs : ∀ x y ∈ s, x * y⁻¹ ∈ s) : subgroup G :=

have one_mem : (1 : G) ∈ s, from let ⟨x, hx⟩ := hsn in by simpa using hs x hx x hx,

have inv_mem : ∀ x, x ∈ s → x⁻¹ ∈ s, from λ x hx, by simpa using hs 1 one_mem x hx,

{ carrier := s,

one_mem' := one_mem,

inv_mem' := inv_mem,

mul_mem' := λ x y hx hy, by simpa using hs x hx y⁻¹ (inv_mem y hy) }

/-- A subgroup of a group inherits a multiplication. -/

@[to_additive "An `add_subgroup` of an `add_group` inherits an addition."]

instance has_mul : has_mul H := H.to_submonoid.has_mul

/-- A subgroup of a group inherits a 1. -/

@[to_additive "An `add_subgroup` of an `add_group` inherits a zero."]

instance has_one : has_one H := H.to_submonoid.has_one

/-- A subgroup of a group inherits an inverse. -/

@[to_additive "A `add_subgroup` of a `add_group` inherits an inverse."]

instance has_inv : has_inv H := ⟨λ a, ⟨a⁻¹, H.inv_mem a.2⟩⟩

/-- A subgroup of a group inherits a division -/

@[to_additive "An `add_subgroup` of an `add_group` inherits a subtraction."]

instance has_div : has_div H := ⟨λ a b, ⟨a / b, H.div_mem a.2 b.2⟩⟩

/-- An `add_subgroup` of an `add_group` inherits a natural scaling. -/

instance _root_.add_subgroup.has_nsmul {G} [add_group G] {H : add_subgroup G} : has_smul ℕ H :=

⟨λ n a, ⟨n • a, H.nsmul_mem a.2 n⟩⟩

/-- A subgroup of a group inherits a natural power -/

@[to_additive]

instance has_npow : has_pow H ℕ := ⟨λ a n, ⟨a ^ n, H.pow_mem a.2 n⟩⟩

/-- An `add_subgroup` of an `add_group` inherits an integer scaling. -/

instance _root_.add_subgroup.has_zsmul {G} [add_group G] {H : add_subgroup G} : has_smul ℤ H :=

⟨λ n a, ⟨n • a, H.zsmul_mem a.2 n⟩⟩

/-- A subgroup of a group inherits an integer power -/

@[to_additive]

instance has_zpow : has_pow H ℤ := ⟨λ a n, ⟨a ^ n, H.zpow_mem a.2 n⟩⟩

@[simp, norm_cast, to_additive] lemma coe_mul (x y : H) : (↑(x * y) : G) = ↑x * ↑y := rfl

@[simp, norm_cast, to_additive] lemma coe_one : ((1 : H) : G) = 1 := rfl

@[simp, norm_cast, to_additive] lemma coe_inv (x : H) : ↑(x⁻¹ : H) = (x⁻¹ : G) := rfl

@[simp, norm_cast, to_additive] lemma coe_div (x y : H) : (↑(x / y) : G) = ↑x / ↑y := rfl

@[simp, norm_cast, to_additive] lemma coe_mk (x : G) (hx : x ∈ H) : ((⟨x, hx⟩ : H) : G) = x := rfl

@[simp, norm_cast, to_additive] lemma coe_pow (x : H) (n : ℕ) : ((x ^ n : H) : G) = x ^ n := rfl

@[simp, norm_cast, to_additive] lemma coe_zpow (x : H) (n : ℤ) : ((x ^ n : H) : G) = x ^ n := rfl

@[simp, to_additive] lemma mk_eq_one_iff {g : G} {h} : (⟨g, h⟩ : H) = 1 ↔ g = 1 :=

show (⟨g, h⟩ : H) = (⟨1, H.one_mem⟩ : H) ↔ g = 1, by simp

/-- A subgroup of a group inherits a group structure. -/

@[to_additive "An `add_subgroup` of an `add_group` inherits an `add_group` structure."]

instance to_group {G : Type*} [group G] (H : subgroup G) : group H :=

subtype.coe_injective.group _ rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

/-- A subgroup of a `comm_group` is a `comm_group`. -/

@[to_additive "An `add_subgroup` of an `add_comm_group` is an `add_comm_group`."]

instance to_comm_group {G : Type*} [comm_group G] (H : subgroup G) : comm_group H :=

subtype.coe_injective.comm_group _

rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

/-- A subgroup of an `ordered_comm_group` is an `ordered_comm_group`. -/

@[to_additive "An `add_subgroup` of an `add_ordered_comm_group` is an `add_ordered_comm_group`."]

instance to_ordered_comm_group {G : Type*} [ordered_comm_group G] (H : subgroup G) :

ordered_comm_group H :=

subtype.coe_injective.ordered_comm_group _

rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

/-- A subgroup of a `linear_ordered_comm_group` is a `linear_ordered_comm_group`. -/

@[to_additive "An `add_subgroup` of a `linear_ordered_add_comm_group` is a

`linear_ordered_add_comm_group`."]

instance to_linear_ordered_comm_group {G : Type*} [linear_ordered_comm_group G]

(H : subgroup G) : linear_ordered_comm_group H :=

subtype.coe_injective.linear_ordered_comm_group _

rfl (λ _ _, rfl) (λ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl) (λ _ _, rfl)

/-- The natural group hom from a subgroup of group `G` to `G`. -/

@[to_additive "The natural group hom from an `add_subgroup` of `add_group` `G` to `G`."]

protected def subtype : H →* G := ⟨coe, rfl, λ _ _, rfl⟩

@[simp, to_additive] theorem coe_subtype : ⇑H.subtype = coe := rfl

@[to_additive] lemma subtype_injective : injective (subgroup.subtype H) := subtype.coe_injective

/-- The inclusion homomorphism from a subgroup `H` contained in `K` to `K`. -/

@[to_additive "The inclusion homomorphism from a additive subgroup `H` contained in `K` to `K`."]

def inclusion {H K : subgroup G} (h : H ≤ K) : H →* K :=

monoid_hom.mk' (λ x, ⟨x, h x.prop⟩) (λ ⟨a, ha⟩ ⟨b, hb⟩, rfl)

@[simp, to_additive]

lemma coe_inclusion {H K : subgroup G} {h : H ≤ K} (a : H) : (inclusion h a : G) = a :=

by { cases a, simp only [inclusion, coe_mk, monoid_hom.mk'_apply] }

@[to_additive] lemma inclusion_injective {H K : subgroup G} (h : H ≤ K) :

function.injective $ inclusion h :=

set.inclusion_injective h

@[simp, to_additive]

lemma subtype_comp_inclusion {H K : subgroup G} (hH : H ≤ K) :

K.subtype.comp (inclusion hH) = H.subtype :=

rfl

/-- The subgroup `G` of the group `G`. -/

@[to_additive "The `add_subgroup G` of the `add_group G`."]

instance : has_top (subgroup G) :=

⟨{ inv_mem' := λ _ _, set.mem_univ _ , .. (⊤ : submonoid G) }⟩

/-- The top subgroup is isomorphic to the group.

This is the group version of `submonoid.top_equiv`. -/

@[to_additive "The top additive subgroup is isomorphic to the additive group.

This is the additive group version of `add_submonoid.top_equiv`.", simps]

def top_equiv : (⊤ : subgroup G) ≃* G := submonoid.top_equiv

/-- The trivial subgroup `{1}` of an group `G`. -/

@[to_additive "The trivial `add_subgroup` `{0}` of an `add_group` `G`."]

instance : has_bot (subgroup G) :=

⟨{ inv_mem' := λ _, by simp *, .. (⊥ : submonoid G) }⟩

@[to_additive]

instance : inhabited (subgroup G) := ⟨⊥⟩

@[simp, to_additive] lemma mem_bot {x : G} : x ∈ (⊥ : subgroup G) ↔ x = 1 := iff.rfl

@[simp, to_additive] lemma mem_top (x : G) : x ∈ (⊤ : subgroup G) := set.mem_univ x

@[simp, to_additive] lemma coe_top : ((⊤ : subgroup G) : set G) = set.univ := rfl

@[simp, to_additive] lemma coe_bot : ((⊥ : subgroup G) : set G) = {1} := rfl

@[to_additive] instance : unique (⊥ : subgroup G) := ⟨⟨1⟩, λ g, subtype.ext g.2⟩

@[simp, to_additive] lemma top_to_submonoid : (⊤ : subgroup G).to_submonoid = ⊤ := rfl

@[simp, to_additive] lemma bot_to_submonoid : (⊥ : subgroup G).to_submonoid = ⊥ := rfl

@[to_additive] lemma eq_bot_iff_forall : H = ⊥ ↔ ∀ x ∈ H, x = (1 : G) :=

to_submonoid_injective.eq_iff.symm.trans $ submonoid.eq_bot_iff_forall _

@[to_additive] lemma eq_bot_of_subsingleton [subsingleton H] : H = ⊥ :=

begin

rw subgroup.eq_bot_iff_forall,

intros y hy,

rw [← subgroup.coe_mk H y hy, subsingleton.elim (⟨y, hy⟩ : H) 1, subgroup.coe_one],

end

@[to_additive] lemma coe_eq_univ {H : subgroup G} : (H : set G) = set.univ ↔ H = ⊤ :=

(set_like.ext'_iff.trans (by refl)).symm

@[to_additive] lemma coe_eq_singleton {H : subgroup G} : (∃ g : G, (H : set G) = {g}) ↔ H = ⊥ :=

⟨λ ⟨g, hg⟩, by { haveI : subsingleton (H : set G) := by { rw hg, apply_instance },

exact H.eq_bot_of_subsingleton }, λ h, ⟨1, set_like.ext'_iff.mp h⟩⟩

@[to_additive] lemma nontrivial_iff_exists_ne_one (H : subgroup G) :

nontrivial H ↔ ∃ x ∈ H, x ≠ (1:G) :=

subtype.nontrivial_iff_exists_ne (λ x, x ∈ H) (1 : H)

/-- A subgroup is either the trivial subgroup or nontrivial. -/

@[to_additive "A subgroup is either the trivial subgroup or nontrivial."]

lemma bot_or_nontrivial (H : subgroup G) : H = ⊥ ∨ nontrivial H :=

begin

classical,

by_cases h : ∀ x ∈ H, x = (1 : G),

{ left,

exact H.eq_bot_iff_forall.mpr h },

{ right,

simp only [not_forall] at h,

simpa only [nontrivial_iff_exists_ne_one] }

end

/-- A subgroup is either the trivial subgroup or contains a non-identity element. -/

@[to_additive "A subgroup is either the trivial subgroup or contains a nonzero element."]

lemma bot_or_exists_ne_one (H : subgroup G) : H = ⊥ ∨ ∃ x ∈ H, x ≠ (1:G) :=

begin

convert H.bot_or_nontrivial,

rw nontrivial_iff_exists_ne_one

end

/-- The inf of two subgroups is their intersection. -/

@[to_additive "The inf of two `add_subgroups`s is their intersection."]

instance : has_inf (subgroup G) :=

⟨λ H₁ H₂,

{ inv_mem' := λ _ ⟨hx, hx'⟩, ⟨H₁.inv_mem hx, H₂.inv_mem hx'⟩,

.. H₁.to_submonoid ⊓ H₂.to_submonoid }⟩

@[simp, to_additive]

lemma coe_inf (p p' : subgroup G) : ((p ⊓ p' : subgroup G) : set G) = p ∩ p' := rfl

@[simp, to_additive]

lemma mem_inf {p p' : subgroup G} {x : G} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' := iff.rfl

@[to_additive]

instance : has_Inf (subgroup G) :=

⟨λ s,

{ inv_mem' := λ x hx, set.mem_bInter $ λ i h, i.inv_mem (by apply set.mem_Inter₂.1 hx i h),

.. (⨅ S ∈ s, subgroup.to_submonoid S).copy (⋂ S ∈ s, ↑S) (by simp) }⟩

@[simp, norm_cast, to_additive]

lemma coe_Inf (H : set (subgroup G)) : ((Inf H : subgroup G) : set G) = ⋂ s ∈ H, ↑s := rfl

@[simp, to_additive]

lemma mem_Inf {S : set (subgroup G)} {x : G} : x ∈ Inf S ↔ ∀ p ∈ S, x ∈ p := set.mem_Inter₂

@[to_additive]

lemma mem_infi {ι : Sort*} {S : ι → subgroup G} {x : G} : (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i :=

by simp only [infi, mem_Inf, set.forall_range_iff]

@[simp, norm_cast, to_additive]

lemma coe_infi {ι : Sort*} {S : ι → subgroup G} : (↑(⨅ i, S i) : set G) = ⋂ i, S i :=

by simp only [infi, coe_Inf, set.bInter_range]

/-- Subgroups of a group form a complete lattice. -/

@[to_additive "The `add_subgroup`s of an `add_group` form a complete lattice."]

instance : complete_lattice (subgroup G) :=

{ bot := (⊥),

bot_le := λ S x hx, (mem_bot.1 hx).symm ▸ S.one_mem,

top := (⊤),

le_top := λ S x hx, mem_top x,

inf := (⊓),

le_inf := λ a b c ha hb x hx, ⟨ha hx, hb hx⟩,

inf_le_left := λ a b x, and.left,

inf_le_right := λ a b x, and.right,

.. complete_lattice_of_Inf (subgroup G) $ λ s, is_glb.of_image

(λ H K, show (H : set G) ≤ K ↔ H ≤ K, from set_like.coe_subset_coe) is_glb_binfi }

@[to_additive]

lemma mem_sup_left {S T : subgroup G} : ∀ {x : G}, x ∈ S → x ∈ S ⊔ T :=

show S ≤ S ⊔ T, from le_sup_left

@[to_additive]

lemma mem_sup_right {S T : subgroup G} : ∀ {x : G}, x ∈ T → x ∈ S ⊔ T :=

show T ≤ S ⊔ T, from le_sup_right

@[to_additive]

lemma mul_mem_sup {S T : subgroup G} {x y : G} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T :=

(S ⊔ T).mul_mem (mem_sup_left hx) (mem_sup_right hy)

@[to_additive]

lemma mem_supr_of_mem {ι : Sort*} {S : ι → subgroup G} (i : ι) :

∀ {x : G}, x ∈ S i → x ∈ supr S :=

show S i ≤ supr S, from le_supr _ _

@[to_additive]

lemma mem_Sup_of_mem {S : set (subgroup G)} {s : subgroup G}

(hs : s ∈ S) : ∀ {x : G}, x ∈ s → x ∈ Sup S :=

show s ≤ Sup S, from le_Sup hs

@[simp, to_additive]

lemma subsingleton_iff : subsingleton (subgroup G) ↔ subsingleton G :=

⟨ λ h, by exactI ⟨λ x y,

have ∀ i : G, i = 1 := λ i, mem_bot.mp $ subsingleton.elim (⊤ : subgroup G) ⊥ ▸ mem_top i,

(this x).trans (this y).symm⟩,

λ h, by exactI ⟨λ x y, subgroup.ext $ λ i, subsingleton.elim 1 i ▸ by simp [subgroup.one_mem]⟩⟩

@[simp, to_additive]

lemma nontrivial_iff : nontrivial (subgroup G) ↔ nontrivial G :=

not_iff_not.mp (

(not_nontrivial_iff_subsingleton.trans subsingleton_iff).trans

not_nontrivial_iff_subsingleton.symm)

@[to_additive]

instance [subsingleton G] : unique (subgroup G) :=

⟨⟨⊥⟩, λ a, @subsingleton.elim _ (subsingleton_iff.mpr ‹_›) a _⟩

@[to_additive]

instance [nontrivial G] : nontrivial (subgroup G) := nontrivial_iff.mpr ‹_›

@[to_additive] lemma eq_top_iff' : H = ⊤ ↔ ∀ x : G, x ∈ H :=

eq_top_iff.trans ⟨λ h m, h $ mem_top m, λ h m _, h m⟩

/-- The `subgroup` generated by a set. -/

@[to_additive "The `add_subgroup` generated by a set"]

def closure (k : set G) : subgroup G := Inf {K | k ⊆ K}

variable {k : set G}

@[to_additive]

lemma mem_closure {x : G} : x ∈ closure k ↔ ∀ K : subgroup G, k ⊆ K → x ∈ K :=

mem_Inf

/-- The subgroup generated by a set includes the set. -/

@[simp, to_additive "The `add_subgroup` generated by a set includes the set."]

lemma subset_closure : k ⊆ closure k := λ x hx, mem_closure.2 $ λ K hK, hK hx

@[to_additive]

lemma not_mem_of_not_mem_closure {P : G} (hP : P ∉ closure k) : P ∉ k := λ h, hP (subset_closure h)

open set

/-- A subgroup `K` includes `closure k` if and only if it includes `k`. -/

@[simp, to_additive "An additive subgroup `K` includes `closure k` if and only if it includes `k`"]

lemma closure_le : closure k ≤ K ↔ k ⊆ K :=

⟨subset.trans subset_closure, λ h, Inf_le h⟩

@[to_additive]

lemma closure_eq_of_le (h₁ : k ⊆ K) (h₂ : K ≤ closure k) : closure k = K :=

le_antisymm ((closure_le $ K).2 h₁) h₂

/-- An induction principle for closure membership. If `p` holds for `1` and all elements of `k`, and

is preserved under multiplication and inverse, then `p` holds for all elements of the closure

of `k`. -/

@[elab_as_eliminator, to_additive "An induction principle for additive closure membership. If `p`

holds for `0` and all elements of `k`, and is preserved under addition and inverses, then `p` holds

for all elements of the additive closure of `k`."]

lemma closure_induction {p : G → Prop} {x} (h : x ∈ closure k)

(Hk : ∀ x ∈ k, p x) (H1 : p 1)

(Hmul : ∀ x y, p x → p y → p (x * y))

(Hinv : ∀ x, p x → p x⁻¹) : p x :=

(@closure_le _ _ ⟨p, Hmul, H1, Hinv⟩ _).2 Hk h

/-- A dependent version of `subgroup.closure_induction`. -/

@[elab_as_eliminator, to_additive "A dependent version of `add_subgroup.closure_induction`. "]

lemma closure_induction' {p : Π x, x ∈ closure k → Prop}

(Hs : ∀ x (h : x ∈ k), p x (subset_closure h))

(H1 : p 1 (one_mem _))

(Hmul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))

(Hinv : ∀ x hx, p x hx → p x⁻¹ (inv_mem hx))

{x} (hx : x ∈ closure k) :

p x hx :=

begin

refine exists.elim _ (λ (hx : x ∈ closure k) (hc : p x hx), hc),

exact closure_induction hx

(λ x hx, ⟨_, Hs x hx⟩) ⟨_, H1⟩ (λ x y ⟨hx', hx⟩ ⟨hy', hy⟩, ⟨_, Hmul _ _ _ _ hx hy⟩)

(λ x ⟨hx', hx⟩, ⟨_, Hinv _ _ hx⟩),

end

/-- An induction principle for closure membership for predicates with two arguments. -/

@[elab_as_eliminator, to_additive "An induction principle for additive closure membership, for

predicates with two arguments."]

lemma closure_induction₂ {p : G → G → Prop} {x} {y : G} (hx : x ∈ closure k) (hy : y ∈ closure k)

(Hk : ∀ (x ∈ k) (y ∈ k), p x y)

(H1_left : ∀ x, p 1 x)

(H1_right : ∀ x, p x 1)

(Hmul_left : ∀ x₁ x₂ y, p x₁ y → p x₂ y → p (x₁ * x₂) y)

(Hmul_right : ∀ x y₁ y₂, p x y₁ → p x y₂ → p x (y₁ * y₂))

(Hinv_left : ∀ x y, p x y → p x⁻¹ y)

(Hinv_right : ∀ x y, p x y → p x y⁻¹) : p x y :=

closure_induction hx

(λ x xk, closure_induction hy (Hk x xk) (H1_right x) (Hmul_right x) (Hinv_right x))

(H1_left y) (λ z z', Hmul_left z z' y) (λ z, Hinv_left z y)

@[simp, to_additive]

lemma closure_closure_coe_preimage {k : set G} : closure ((coe : closure k → G) ⁻¹' k) = ⊤ :=

eq_top_iff.2 $ λ x, subtype.rec_on x $ λ x hx _, begin

refine closure_induction' (λ g hg, _) _ (λ g₁ g₂ hg₁ hg₂, _) (λ g hg, _) hx,

{ exact subset_closure hg },

{ exact one_mem _ },

{ exact mul_mem },

{ exact inv_mem }

end

/-- If all the elements of a set `s` commute, then `closure s` is a commutative group. -/

@[to_additive "If all the elements of a set `s` commute, then `closure s` is an additive

commutative group."]

def closure_comm_group_of_comm {k : set G} (hcomm : ∀ (x ∈ k) (y ∈ k), x * y = y * x) :

comm_group (closure k) :=

{ mul_comm := λ x y,

begin

ext,

simp only [subgroup.coe_mul],

refine closure_induction₂ x.prop y.prop hcomm

(λ x, by simp only [mul_one, one_mul])

(λ x, by simp only [mul_one, one_mul])

(λ x y z h₁ h₂, by rw [mul_assoc, h₂, ←mul_assoc, h₁, mul_assoc])

(λ x y z h₁ h₂, by rw [←mul_assoc, h₁, mul_assoc, h₂, ←mul_assoc])

(λ x y h, by rw [inv_mul_eq_iff_eq_mul, ←mul_assoc, h, mul_assoc, mul_inv_self, mul_one])

(λ x y h, by rw [mul_inv_eq_iff_eq_mul, mul_assoc, h, ←mul_assoc, inv_mul_self, one_mul])

end,

..(closure k).to_group }

variable (G)

/-- `closure` forms a Galois insertion with the coercion to set. -/

@[to_additive "`closure` forms a Galois insertion with the coercion to set."]

protected def gi : galois_insertion (@closure G _) coe :=

{ choice := λ s _, closure s,

gc := λ s t, @closure_le _ _ t s,

le_l_u := λ s, subset_closure,

choice_eq := λ s h, rfl }

variable {G}

/-- Subgroup closure of a set is monotone in its argument: if `h ⊆ k`,

then `closure h ≤ closure k`. -/

@[to_additive "Additive subgroup closure of a set is monotone in its argument: if `h ⊆ k`,

then `closure h ≤ closure k`"]

lemma closure_mono ⦃h k : set G⦄ (h' : h ⊆ k) : closure h ≤ closure k :=

(subgroup.gi G).gc.monotone_l h'

/-- Closure of a subgroup `K` equals `K`. -/

@[simp, to_additive "Additive closure of an additive subgroup `K` equals `K`"]

lemma closure_eq : closure (K : set G) = K := (subgroup.gi G).l_u_eq K

@[simp, to_additive] lemma closure_empty : closure (∅ : set G) = ⊥ :=

(subgroup.gi G).gc.l_bot

@[simp, to_additive] lemma closure_univ : closure (univ : set G) = ⊤ :=

@coe_top G _ ▸ closure_eq ⊤

@[to_additive]

lemma closure_union (s t : set G) : closure (s ∪ t) = closure s ⊔ closure t :=

(subgroup.gi G).gc.l_sup

@[to_additive]

lemma closure_Union {ι} (s : ι → set G) : closure (⋃ i, s i) = ⨆ i, closure (s i) :=

(subgroup.gi G).gc.l_supr

@[to_additive]

lemma closure_eq_bot_iff (G : Type*) [group G] (S : set G) :

closure S = ⊥ ↔ S ⊆ {1} :=

by { rw [← le_bot_iff], exact closure_le _}

@[to_additive]

lemma supr_eq_closure {ι : Sort*} (p : ι → subgroup G) :

(⨆ i, p i) = closure (⋃ i, (p i : set G)) :=

by simp_rw [closure_Union, closure_eq]

/-- The subgroup generated by an element of a group equals the set of integer number powers of

the element. -/

@[to_additive /-"The `add_subgroup` generated by an element of an `add_group` equals the set of

natural number multiples of the element."-/]

lemma mem_closure_singleton {x y : G} : y ∈ closure ({x} : set G) ↔ ∃ n : ℤ, x ^ n = y :=

begin

refine ⟨λ hy, closure_induction hy _ _ _ _,

λ ⟨n, hn⟩, hn ▸ zpow_mem (subset_closure $ mem_singleton x) n⟩,

{ intros y hy,

rw [eq_of_mem_singleton hy],

exact ⟨1, zpow_one x⟩ },

{ exact ⟨0, zpow_zero x⟩ },

{ rintros _ _ ⟨n, rfl⟩ ⟨m, rfl⟩,

exact ⟨n + m, zpow_add x n m⟩ },

rintros _ ⟨n, rfl⟩,

exact ⟨-n, zpow_neg x n⟩

end

@[to_additive]

lemma closure_singleton_one : closure ({1} : set G) = ⊥ :=

by simp [eq_bot_iff_forall, mem_closure_singleton]

@[to_additive]

lemma le_closure_to_submonoid (S : set G) : submonoid.closure S ≤ (closure S).to_submonoid :=

submonoid.closure_le.2 subset_closure

@[to_additive] lemma closure_eq_top_of_mclosure_eq_top {S : set G} (h : submonoid.closure S = ⊤) :

closure S = ⊤ :=

(eq_top_iff' _).2 $ λ x, le_closure_to_submonoid _ $ h.symm ▸ trivial

@[to_additive]

lemma mem_supr_of_directed {ι} [hι : nonempty ι] {K : ι → subgroup G} (hK : directed (≤) K)

{x : G} :

x ∈ (supr K : subgroup G) ↔ ∃ i, x ∈ K i :=

begin

refine ⟨_, λ ⟨i, hi⟩, (set_like.le_def.1 $ le_supr K i) hi⟩,

suffices : x ∈ closure (⋃ i, (K i : set G)) → ∃ i, x ∈ K i,

by simpa only [closure_Union, closure_eq (K _)] using this,

refine (λ hx, closure_induction hx (λ _, mem_Union.1) _ _ _),

{ exact hι.elim (λ i, ⟨i, (K i).one_mem⟩) },

{ rintros x y ⟨i, hi⟩ ⟨j, hj⟩,

rcases hK i j with ⟨k, hki, hkj⟩,

exact ⟨k, mul_mem (hki hi) (hkj hj)⟩ },

rintros _ ⟨i, hi⟩, exact ⟨i, inv_mem hi⟩

end

@[to_additive]

lemma coe_supr_of_directed {ι} [nonempty ι] {S : ι → subgroup G} (hS : directed (≤) S) :

((⨆ i, S i : subgroup G) : set G) = ⋃ i, ↑(S i) :=

set.ext $ λ x, by simp [mem_supr_of_directed hS]

@[to_additive]

lemma mem_Sup_of_directed_on {K : set (subgroup G)} (Kne : K.nonempty)

(hK : directed_on (≤) K) {x : G} :

x ∈ Sup K ↔ ∃ s ∈ K, x ∈ s :=

begin

haveI : nonempty K := Kne.to_subtype,

simp only [Sup_eq_supr', mem_supr_of_directed hK.directed_coe, set_coe.exists, subtype.coe_mk]

end

variables {N : Type*} [group N] {P : Type*} [group P]

/-- The preimage of a subgroup along a monoid homomorphism is a subgroup. -/

@[to_additive "The preimage of an `add_subgroup` along an `add_monoid` homomorphism

is an `add_subgroup`."]

def comap {N : Type*} [group N] (f : G →* N)

(H : subgroup N) : subgroup G :=

{ carrier := (f ⁻¹' H),

inv_mem' := λ a ha,

show f a⁻¹ ∈ H, by rw f.map_inv; exact H.inv_mem ha,

.. H.to_submonoid.comap f }

@[simp, to_additive]

lemma coe_comap (K : subgroup N) (f : G →* N) : (K.comap f : set G) = f ⁻¹' K := rfl

@[simp, to_additive]

lemma mem_comap {K : subgroup N} {f : G →* N} {x : G} : x ∈ K.comap f ↔ f x ∈ K := iff.rfl

@[to_additive]

lemma comap_mono {f : G →* N} {K K' : subgroup N} : K ≤ K' → comap f K ≤ comap f K' :=

preimage_mono

@[to_additive]

lemma comap_comap (K : subgroup P) (g : N →* P) (f : G →* N) :

(K.comap g).comap f = K.comap (g.comp f) :=

rfl

@[simp, to_additive] lemma comap_id (K : subgroup N) :

K.comap (monoid_hom.id _) = K :=

by { ext, refl }

/-- The image of a subgroup along a monoid homomorphism is a subgroup. -/

@[to_additive "The image of an `add_subgroup` along an `add_monoid` homomorphism

is an `add_subgroup`."]

def map (f : G →* N) (H : subgroup G) : subgroup N :=

{ carrier := (f '' H),

inv_mem' := by { rintros _ ⟨x, hx, rfl⟩, exact ⟨x⁻¹, H.inv_mem hx, f.map_inv x⟩ },

.. H.to_submonoid.map f }

@[simp, to_additive]

lemma coe_map (f : G →* N) (K : subgroup G) :

(K.map f : set N) = f '' K := rfl

@[simp, to_additive]

lemma mem_map {f : G →* N} {K : subgroup G} {y : N} :

y ∈ K.map f ↔ ∃ x ∈ K, f x = y :=

mem_image_iff_bex

@[to_additive]

lemma mem_map_of_mem (f : G →* N) {K : subgroup G} {x : G} (hx : x ∈ K) : f x ∈ K.map f :=

mem_image_of_mem f hx

@[to_additive]

lemma apply_coe_mem_map (f : G →* N) (K : subgroup G) (x : K) : f x ∈ K.map f :=

mem_map_of_mem f x.prop

@[to_additive]

lemma map_mono {f : G →* N} {K K' : subgroup G} : K ≤ K' → map f K ≤ map f K' :=

image_subset _