File: Mathlib/GroupTheory/SemidirectProduct.lean

full_name: SemidirectProduct
code: /-- The semidirect product of groups `N` and `G`, given a map `φ` from `G` to the automorphism
  group of `N`. It the product of sets with the group operation
  `⟨n₁, g₁⟩ * ⟨n₂, g₂⟩ = ⟨n₁ * φ g₁ n₂, g₁ * g₂⟩` -/
@[ext]
structure SemidirectProduct (φ : G →* MulAut N) where
  /-- The element of N -/
  left : N
  /-- The element of G -/
  right : G
  deriving DecidableEq
goal: Type (max u_1 u_2)

full_name: SemidirectProduct.left
code: /-- The semidirect product of groups `N` and `G`, given a map `φ` from `G` to the automorphism
  group of `N`. It the product of sets with the group operation
  `⟨n₁, g₁⟩ * ⟨n₂, g₂⟩ = ⟨n₁ * φ g₁ n₂, g₁ * g₂⟩` -/
@[ext]
structure SemidirectProduct (φ : G →* MulAut N) where
  /-- The element of N -/
  left : N
  /-- The element of G -/
  right : G
  deriving DecidableEq
goal: N

full_name: SemidirectProduct.right
code: /-- The semidirect product of groups `N` and `G`, given a map `φ` from `G` to the automorphism
  group of `N`. It the product of sets with the group operation
  `⟨n₁, g₁⟩ * ⟨n₂, g₂⟩ = ⟨n₁ * φ g₁ n₂, g₁ * g₂⟩` -/
@[ext]
structure SemidirectProduct (φ : G →* MulAut N) where
  /-- The element of N -/
  left : N
  /-- The element of G -/
  right : G
  deriving DecidableEq
goal: G

full_name: _aux_Mathlib_GroupTheory_SemidirectProduct___unexpand_SemidirectProduct_1
code: @[inherit_doc]
notation:35 N " ⋊[" φ:35 "] " G:35 => SemidirectProduct N G φ
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_GroupTheory_SemidirectProduct___macroRules_term_⋊[_]__1»
code: @[inherit_doc]
notation:35 N " ⋊[" φ:35 "] " G:35 => SemidirectProduct N G φ
goal: Lean.Macro

full_name: SemidirectProduct.instMul
code: instance : Mul (SemidirectProduct N G φ) 
goal: Mul (N ⋊[φ] G)

full_name: SemidirectProduct.mul_def
code: lemma mul_def (a b : SemidirectProduct N G φ) : a * b = ⟨a.1 * φ a.2 b.1, a.2 * b.2⟩ 
goal: a * b = { left := a.left * (φ a.right) b.left, right := a.right * b.right }

full_name: SemidirectProduct.mul_left
code: @[simp]
theorem mul_left (a b : N ⋊[φ] G) : (a * b).left = a.left * φ a.right b.left 
goal: (a * b).left = a.left * (φ a.right) b.left

full_name: SemidirectProduct.mul_right
code: @[simp]
theorem mul_right (a b : N ⋊[φ] G) : (a * b).right = a.right * b.right 
goal: (a * b).right = a.right * b.right

full_name: SemidirectProduct.instOne
code: instance : One (SemidirectProduct N G φ) 
goal: One (N ⋊[φ] G)

full_name: SemidirectProduct.one_left
code: @[simp]
theorem one_left : (1 : N ⋊[φ] G).left = 1 
goal: SemidirectProduct.left 1 = 1

full_name: SemidirectProduct.one_right
code: @[simp]
theorem one_right : (1 : N ⋊[φ] G).right = 1 
goal: SemidirectProduct.right 1 = 1

full_name: SemidirectProduct.instInv
code: instance : Inv (SemidirectProduct N G φ) 
goal: Inv (N ⋊[φ] G)

full_name: SemidirectProduct.inv_left
code: @[simp]
theorem inv_left (a : N ⋊[φ] G) : a⁻¹.left = φ a.right⁻¹ a.left⁻¹ 
goal: a⁻¹.left = (φ a.right⁻¹) a.left⁻¹

full_name: SemidirectProduct.inv_right
code: @[simp]
theorem inv_right (a : N ⋊[φ] G) : a⁻¹.right = a.right⁻¹ 
goal: a⁻¹.right = a.right⁻¹

full_name: SemidirectProduct.instGroup
code: instance : Group (N ⋊[φ] G) 
goal: Group (N ⋊[φ] G)

full_name: SemidirectProduct.instInhabited
code: instance : Inhabited (N ⋊[φ] G) 
goal: Inhabited (N ⋊[φ] G)

full_name: SemidirectProduct.inl
code: /-- The canonical map `N →* N ⋊[φ] G` sending `n` to `⟨n, 1⟩` -/
def inl : N →* N ⋊[φ] G 
goal: N →* N ⋊[φ] G

full_name: SemidirectProduct.left_inl
code: @[simp]
theorem left_inl (n : N) : (inl n : N ⋊[φ] G).left = n 
goal: (SemidirectProduct.inl n).left = n

full_name: SemidirectProduct.right_inl
code: @[simp]
theorem right_inl (n : N) : (inl n : N ⋊[φ] G).right = 1 
goal: (SemidirectProduct.inl n).right = 1

full_name: SemidirectProduct.inl_injective
code: theorem inl_injective : Function.Injective (inl : N → N ⋊[φ] G) 
goal: Function.Injective ⇑SemidirectProduct.inl

full_name: SemidirectProduct.inl_inj
code: @[simp]
theorem inl_inj {n₁ n₂ : N} : (inl n₁ : N ⋊[φ] G) = inl n₂ ↔ n₁ = n₂ 
goal: SemidirectProduct.inl n₁ = SemidirectProduct.inl n₂ ↔ n₁ = n₂

full_name: SemidirectProduct.inr
code: /-- The canonical map `G →* N ⋊[φ] G` sending `g` to `⟨1, g⟩` -/
def inr : G →* N ⋊[φ] G 
goal: G →* N ⋊[φ] G

full_name: SemidirectProduct.left_inr
code: @[simp]
theorem left_inr (g : G) : (inr g : N ⋊[φ] G).left = 1 
goal: (SemidirectProduct.inr g).left = 1

full_name: SemidirectProduct.right_inr
code: @[simp]
theorem right_inr (g : G) : (inr g : N ⋊[φ] G).right = g 
goal: (SemidirectProduct.inr g).right = g

full_name: SemidirectProduct.inr_injective
code: theorem inr_injective : Function.Injective (inr : G → N ⋊[φ] G) 
goal: Function.Injective ⇑SemidirectProduct.inr

full_name: SemidirectProduct.inr_inj
code: @[simp]
theorem inr_inj {g₁ g₂ : G} : (inr g₁ : N ⋊[φ] G) = inr g₂ ↔ g₁ = g₂ 
goal: SemidirectProduct.inr g₁ = SemidirectProduct.inr g₂ ↔ g₁ = g₂

full_name: SemidirectProduct.inl_aut
code: theorem inl_aut (g : G) (n : N) : (inl (φ g n) : N ⋊[φ] G) = inr g * inl n * inr g⁻¹ 
goal: SemidirectProduct.inl ((φ g) n) = SemidirectProduct.inr g * SemidirectProduct.inl n * SemidirectProduct.inr g⁻¹

full_name: SemidirectProduct.inl_aut_inv
code: theorem inl_aut_inv (g : G) (n : N) : (inl ((φ g)⁻¹ n) : N ⋊[φ] G) = inr g⁻¹ * inl n * inr g 
goal: SemidirectProduct.inl ((φ g)⁻¹ n) = SemidirectProduct.inr g⁻¹ * SemidirectProduct.inl n * SemidirectProduct.inr g

full_name: SemidirectProduct.mk_eq_inl_mul_inr
code: @[simp]
theorem mk_eq_inl_mul_inr (g : G) (n : N) : (⟨n, g⟩ : N ⋊[φ] G) = inl n * inr g 
goal: { left := n, right := g } = SemidirectProduct.inl n * SemidirectProduct.inr g

full_name: SemidirectProduct.inl_left_mul_inr_right
code: @[simp]
theorem inl_left_mul_inr_right (x : N ⋊[φ] G) : inl x.left * inr x.right = x 
goal: SemidirectProduct.inl x.left * SemidirectProduct.inr x.right = x

full_name: SemidirectProduct.rightHom
code: /-- The canonical projection map `N ⋊[φ] G →* G`, as a group hom. -/
def rightHom : N ⋊[φ] G →* G 
goal: N ⋊[φ] G →* G

full_name: SemidirectProduct.rightHom_eq_right
code: @[simp]
theorem rightHom_eq_right : (rightHom : N ⋊[φ] G → G) = right 
goal: ⇑SemidirectProduct.rightHom = SemidirectProduct.right

full_name: SemidirectProduct.rightHom_comp_inl
code: @[simp]
theorem rightHom_comp_inl : (rightHom : N ⋊[φ] G →* G).comp inl = 1 
goal: SemidirectProduct.rightHom.comp SemidirectProduct.inl = 1

full_name: SemidirectProduct.rightHom_comp_inr
code: @[simp]
theorem rightHom_comp_inr : (rightHom : N ⋊[φ] G →* G).comp inr = MonoidHom.id _ 
goal: SemidirectProduct.rightHom.comp SemidirectProduct.inr = MonoidHom.id G

full_name: SemidirectProduct.rightHom_inl
code: @[simp]
theorem rightHom_inl (n : N) : rightHom (inl n : N ⋊[φ] G) = 1 
goal: SemidirectProduct.rightHom (SemidirectProduct.inl n) = 1

full_name: SemidirectProduct.rightHom_inr
code: @[simp]
theorem rightHom_inr (g : G) : rightHom (inr g : N ⋊[φ] G) = g 
goal: SemidirectProduct.rightHom (SemidirectProduct.inr g) = g

full_name: SemidirectProduct.rightHom_surjective
code: theorem rightHom_surjective : Function.Surjective (rightHom : N ⋊[φ] G → G) 
goal: Function.Surjective ⇑SemidirectProduct.rightHom

full_name: SemidirectProduct.range_inl_eq_ker_rightHom
code: theorem range_inl_eq_ker_rightHom : (inl : N →* N ⋊[φ] G).range = rightHom.ker 
goal: SemidirectProduct.inl.range = SemidirectProduct.rightHom.ker

full_name: SemidirectProduct.lift
code: /-- Define a group hom `N ⋊[φ] G →* H`, by defining maps `N →* H` and `G →* H`  -/
def lift (f₁ : N →* H) (f₂ : G →* H)
    (h : ∀ g, f₁.comp (φ g).toMonoidHom = (MulAut.conj (f₂ g)).toMonoidHom.comp f₁) :
    N ⋊[φ] G →* H 
goal: N ⋊[φ] G →* H

full_name: SemidirectProduct.lift_inl
code: @[simp]
theorem lift_inl (n : N) : lift f₁ f₂ h (inl n) = f₁ n 
goal: (SemidirectProduct.lift f₁ f₂ h) (SemidirectProduct.inl n) = f₁ n

full_name: SemidirectProduct.lift_comp_inl
code: @[simp]
theorem lift_comp_inl : (lift f₁ f₂ h).comp inl = f₁ 
goal: (SemidirectProduct.lift f₁ f₂ h).comp SemidirectProduct.inl = f₁

full_name: SemidirectProduct.lift_inr
code: @[simp]
theorem lift_inr (g : G) : lift f₁ f₂ h (inr g) = f₂ g 
goal: (SemidirectProduct.lift f₁ f₂ h) (SemidirectProduct.inr g) = f₂ g

full_name: SemidirectProduct.lift_comp_inr
code: @[simp]
theorem lift_comp_inr : (lift f₁ f₂ h).comp inr = f₂ 
goal: (SemidirectProduct.lift f₁ f₂ h).comp SemidirectProduct.inr = f₂

full_name: SemidirectProduct.lift_unique
code: theorem lift_unique (F : N ⋊[φ] G →* H) :
    F = lift (F.comp inl) (F.comp inr) fun _ ↦ by ext; simp [inl_aut] 
goal: F = SemidirectProduct.lift (F.comp SemidirectProduct.inl) (F.comp SemidirectProduct.inr) ⋯

full_name: SemidirectProduct.hom_ext
code: /-- Two maps out of the semidirect product are equal if they're equal after composition
  with both `inl` and `inr` -/
theorem hom_ext {f g : N ⋊[φ] G →* H} (hl : f.comp inl = g.comp inl)
    (hr : f.comp inr = g.comp inr) : f = g 
goal: f = g

full_name: SemidirectProduct.map
code: /-- Define a map from `N ⋊[φ] G` to `N₁ ⋊[φ₁] G₁` given maps `N →* N₁` and `G →* G₁` that
  satisfy a commutativity condition `∀ n g, f₁ (φ g n) = φ₁ (f₂ g) (f₁ n)`.  -/
def map (f₁ : N →* N₁) (f₂ : G →* G₁)
    (h : ∀ g : G, f₁.comp (φ g).toMonoidHom = (φ₁ (f₂ g)).toMonoidHom.comp f₁) :
    N ⋊[φ] G →* N₁ ⋊[φ₁] G₁ 
goal: N ⋊[φ] G →* N₁ ⋊[φ₁] G₁

full_name: SemidirectProduct.map_left
code: @[simp]
theorem map_left (g : N ⋊[φ] G) : (map f₁ f₂ h g).left = f₁ g.left 
goal: ((SemidirectProduct.map f₁ f₂ h) g).left = f₁ g.left

full_name: SemidirectProduct.map_right
code: @[simp]
theorem map_right (g : N ⋊[φ] G) : (map f₁ f₂ h g).right = f₂ g.right 
goal: ((SemidirectProduct.map f₁ f₂ h) g).right = f₂ g.right

full_name: SemidirectProduct.rightHom_comp_map
code: @[simp]
theorem rightHom_comp_map : rightHom.comp (map f₁ f₂ h) = f₂.comp rightHom 
goal: SemidirectProduct.rightHom.comp (SemidirectProduct.map f₁ f₂ h) = f₂.comp SemidirectProduct.rightHom

full_name: SemidirectProduct.map_inl
code: @[simp]
theorem map_inl (n : N) : map f₁ f₂ h (inl n) = inl (f₁ n) 
goal: (SemidirectProduct.map f₁ f₂ h) (SemidirectProduct.inl n) = SemidirectProduct.inl (f₁ n)

full_name: SemidirectProduct.map_comp_inl
code: @[simp]
theorem map_comp_inl : (map f₁ f₂ h).comp inl = inl.comp f₁ 
goal: (SemidirectProduct.map f₁ f₂ h).comp SemidirectProduct.inl = SemidirectProduct.inl.comp f₁

full_name: SemidirectProduct.map_inr
code: @[simp]
theorem map_inr (g : G) : map f₁ f₂ h (inr g) = inr (f₂ g) 
goal: (SemidirectProduct.map f₁ f₂ h) (SemidirectProduct.inr g) = SemidirectProduct.inr (f₂ g)

full_name: SemidirectProduct.map_comp_inr
code: @[simp]
theorem map_comp_inr : (map f₁ f₂ h).comp inr = inr.comp f₂ 
goal: (SemidirectProduct.map f₁ f₂ h).comp SemidirectProduct.inr = SemidirectProduct.inr.comp f₂