Built with
doc-gen4 , running Lean4.
Bubbles (
) indicate interactive fragments: hover for details, tap to reveal contents.
Use
Ctrl+β Ctrl+β to navigate,
Ctrl+π±οΈ to focus.
On Mac, use
Cmd instead of
Ctrl .
import Mathlib.Algebra.Hom.Group
import Mathlib.GroupTheory.Submonoid.Operations
import UnitConjecture.Cocycle
/-!
## Metabelian groups
Metabelian groups are group extensions `1 β K β G β Q β 1` with both the kernel and the quotient Abelian.
Such an extension is determined by data:
* a group action of `Q` on `K` by automorphisms
* a cocyle `c: Q β Q β K`
We define the cocycle condition and construct a group structure on a structure extending `K Γ Q`.
The main step is to show that the cocyle condition implies associativity.
-/
namespace MetabelianGroup
variable { Q K : Type _ : Type (?u.93304+1) Type _} [ AddGroup Q ] [ AddCommGroup : Type ?u.2673 β Type ?u.2673 AddCommGroup K ]
variable ( c : Q β Q β K ) [ ccl : Cocycle : {Q : Type ?u.1221} β
{K : Type ?u.1220} β [inst : AddGroup Q ] β [inst : AddGroup K ] β (Q β Q β K ) β Type (max?u.1221?u.1220) Cocycle c ]
declare_aesop_rule_sets [Metabelian]
/-- The multiplication operation defined using the cocycle.
The cocycle condition is crucially used in showing associativity and other properties. -/
@[reducible, aesop norm unfold ( rule_sets [Metabelian])]
def mul : K Γ Q β K Γ Q β K Γ Q mul : ( K Γ Q ) β ( K Γ Q ) β ( K Γ Q )
| ( k , q ), ( k' , q' ) => ( k + ( q +α΅₯ k' ) + c q q' , q + q' )
/-- The identity element of the Metabelian group,
which is the ordered pair of the identities of the individual groups. -/
@[reducible, aesop norm unfold ( rule_sets [Metabelian])]
def e : K Γ Q := ( 0 , 0 )
/-- The inverse operation of the Metabelian group. -/
@[reducible, aesop norm unfold ( rule_sets [Metabelian])]
def inv : K Γ Q β K Γ Q
| ( k , q ) => (- ((- q ) +α΅₯ ( k + c q (- q ))), - q )
/-!
Some of the standard lemmas to show that `K Γ Q` has the structure of a group with the above operations.
-/
@[ aesop norm ( rule_sets [Metabelian])]
lemma left_id : β (g : K Γ Q ), mul c e g = g left_id : β ( g : K Γ Q ), mul c e g = g
| ( k , q ) => by aesop ( rule_sets [Cocycle, Metabelian])
@[ aesop norm ( rule_sets [Metabelian])]
lemma right_id : β ( g : K Γ Q ), mul c g e = g
| ( k , q ) => by aesop ( rule_sets [Cocycle, Metabelian, AutAction])
@[ aesop norm ( rule_sets [Metabelian])]
lemma left_inv : β ( g : K Γ Q ), mul c ( inv c g ) g = e
| ( k , q ) => by
have := Cocycle.inv_rel' c q
aesop ( rule_sets [Metabelian, Cocycle, AutAction])
@[ aesop norm ( rule_sets [Metabelian])]
lemma right_inv : β ( g : K Γ Q ), mul c g ( inv c g ) = e
| ( k , q ) => by aesop ( rule_sets [Metabelian, Cocycle, AutAction])
@[ aesop unsafe ( rule_sets [Metabelian])]
theorem mul_assoc : β (g g' g'' : K Γ Q ), mul c (mul c g g' ) g'' = mul c g (mul c g' g'' ) mul_assoc : β ( g g' g'' : K Γ Q ), mul c ( mul c g g' ) g'' = mul c g ( mul c g' g'' )
| ( k , q ), ( k' , q' ), ( k'' , q'' ) => by
mul c (mul c (k , q ) (k' , q' ) ) (k'' , q'' ) = mul c (k , q ) (mul c (k' , q' ) (k'' , q'' ) )aesop ( rule_sets [Metabelian, Cocycle, AutAction])
( options := { terminal := false , warnOnNonterminal := false }) left right q + q' + q'' = q + (q' + q'' )
mul c (mul c (k , q ) (k' , q' ) ) (k'' , q'' ) = mul c (k , q ) (mul c (k' , q' ) (k'' , q'' ) )Β· left right q + q' + q'' = q + (q' + q'' )simp only [ add_assoc , add_left_cancel_iff ]
left right q + q' + q'' = q + (q' + q'' )rw [ add_left_comm , add_left_cancel_iff ]
-- The cocycle condition is precisely what is required for the associativity of multiplication
left right q + q' + q'' = q + (q' + q'' )exact ccl . cocycle_condition : β {Q : Type ?u.80143} {K : Type ?u.80142} [inst : AddGroup Q ] [inst_2 : AddGroup K ] {c : Q β Q β K } [self : Cocycle c ]
(q q' q'' : Q ), c q q' + c (q + q' ) q'' = q +α΅₯ c q' q'' + c q (q' + q'' ) cocycle_condition q q' q''
mul c (mul c (k , q ) (k' , q' ) ) (k'' , q'' ) = mul c (k , q ) (mul c (k' , q' ) (k'' , q'' ) )Β· right q + q' + q'' = q + (q' + q'' )apply add_assoc
/-- A group structure on `K Γ Q` using the above multiplication operation. -/
instance metabelianGroup : Group ( K Γ Q ) :=
{
mul := mul c ,
one := e ,
inv := inv c ,
mul_one := right_id c ,
one_mul := left_id c ,
mul_assoc := mul_assoc c ,
mul_left_inv := left_inv c ,
div_eq_mul_inv := by intros ; rfl
}
@[ aesop norm simp ( rule_sets [Metabelian])]
theorem mul_def : β {k k' : K } {q q' : Q }, (k , q ) * (k' , q' ) = (k + (q +α΅₯ k' ) + c q q' , q + q' ) mul_def { k k' : K } { q q' : Q } : ( k , q ) * ( k' , q' ) = ( k + ( q +α΅₯ k' ) + c q q' , q + q' ) := rfl : β {Ξ± : Sort ?u.82627} {a : Ξ± }, a = a rfl
lemma kernel_pow ( k : K ) ( n : β ) : ( k , ( 0 : Q )) ^ n = ( n β’ k , ( 0 : Q )) := by
(k , 0 ) ^ n = (n β’ k , 0 ) induction n (k , 0 ) ^ n = (n β’ k , 0 ) <;>
(k , 0 ) ^ n = (n β’ k , 0 ) aesop ( rule_sets [Metabelian, Cocycle])
( add norm simp [pow_zero, pow_succ, zero_nsmul, succ_nsmul])
section Exactness
/-!
### Exactness
A proof that the Metabelian group `G` constructed as above indeed lies in middle of
the short exact sequence `1 β K β G β Q β 1`.
-/
/-- The inclusion map from the kernel to the Metabelian group. -/
@[ aesop norm unfold ( rule_sets [Metabelian])]
def Kernel.inclusion : ( Multiplicative : Type ?u.93385 β Type ?u.93385 Multiplicative K ) β* ( K Γ Q ) :=
{ toFun := (Β·, (0 : Q )),
map_one' := rfl : β {Ξ± : Sort ?u.94839} {a : Ξ± }, a = a rfl,
map_mul' := by β (x y : Multiplicative K ),
β{ toFun := fun x => (x , 0 ) , map_one' := (_ : (fun x => (x , 0 ) ) 1 = (fun x => (x , 0 ) ) 1 ) } (x * y ) = β{ toFun := fun x => (x , 0 ) , map_one' := (_ : (fun x => (x , 0 ) ) 1 = (fun x => (x , 0 ) ) 1 ) } x * β{ toFun := fun x => (x , 0 ) , map_one' := (_ : (fun x => (x , 0 ) ) 1 = (fun x => (x , 0 ) ) 1 ) } y aesop ( rule_sets [Metabelian, Cocycle]) }
/-- A proof that the inclusion map is injective. -/
theorem Kernel.inclusion_inj : Function.Injective : {Ξ± : Sort ?u.146773} β {Ξ² : Sort ?u.146772} β (Ξ± β Ξ² ) β Prop Function.Injective ( Kernel.inclusion c ) := by
intros _ _ ; simp [ Kernel.inclusion ]
/--- The projection map from the Metabelian group to the quotient. -/
@[ aesop norm unfold ( rule_sets [Metabelian])]
def Quotient.projection : K Γ Q β* ( Multiplicative : Type ?u.149149 β Type ?u.149149 Multiplicative Q ) :=
{ toFun := Prod.snd : {Ξ± : Type ?u.150484} β {Ξ² : Type ?u.150483} β Ξ± Γ Ξ² β Ξ² Prod.snd,
map_one' := rfl : β {Ξ± : Sort ?u.150492} {a : Ξ± }, a = a rfl
map_mul' := by β (x y : K Γ Q ),
β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } (x * y ) = β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } x * β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } y intro β¨_, _β© β¨_, _β© β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } ((fstβΒΉ , sndβΒΉ ) * (fstβ , sndβ ) ) = β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } (fstβΒΉ , sndβΒΉ ) * β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } (fstβ , sndβ ) ; β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } ((fstβΒΉ , sndβΒΉ ) * (fstβ , sndβ ) ) = β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } (fstβΒΉ , sndβΒΉ ) * β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } (fstβ , sndβ ) β (x y : K Γ Q ),
β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } (x * y ) = β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } x * β{ toFun := Prod.snd , map_one' := (_ : 1 .snd = 1 .snd ) } y rfl }
/-- A proof that the projection map is surjective. -/
theorem Quotient.projection_surj : Function.Surjective : {Ξ± : Sort ?u.150912} β {Ξ² : Sort ?u.150911} β (Ξ± β Ξ² ) β Prop Function.Surjective ( Quotient.projection c ) := by
intro q ; use β¨( 0 : K ), q β©
/-- A proof that the image of the first map is the kernel of the second map. -/
theorem exact_seq : MonoidHom.mrange ( Kernel.inclusion c ) = MonoidHom.mker ( Quotient.projection c ) := by
ext β¨ _ , _ β© ; aesop ( rule_sets [Metabelian]) ( add norm [MonoidHom.mem_mker])
end Exactness
end MetabelianGroup