Stafford38/Characteristic/SquareZeroOreLocalization.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.Characteristic.SquareZeroTraceData
3 public import Mathlib.RingTheory.OreLocalization.OreSet
4 
5 @[expose] public section
6 
7 /-!
8 # Ore localization of a square-zero deformation
9 
10 For a ring with a central square-zero parameter, whose commutators are
11 divisible by that parameter, the inverse image of every multiplicative set in
12 the commutative special fibre is a left Ore set.  Squaring the denominator is
13 enough both for the Ore equation and for the weak cancellation axiom.
14 
15 This is the localization input needed by the minimal-prime trace argument.  No
16 trace, finite-length, or prime-ideal conclusion is asserted here.
17 -/
18 
19 namespace Stafford38.Characteristic.SquareZeroOreLocalization
20 
21 open Stafford38.Characteristic.SquareZeroTraceData
22 
23 noncomputable section
24 
25 universe u_k u_R u_B u_N u_G
26 
27 variable {k : Type u_k} {R : Type u_R} {B : Type u_B}
28 variable {N : Type u_N} {G : Type u_G}
29 variable [Field k] [CommRing R] [Algebra k R]
30 variable [Ring B] [Algebra k B]
31 variable [AddCommGroup N] [Module k N] [Module Bᵐᵒᵖ N]
32 variable [SMulCommClass k Bᵐᵒᵖ N]
33 variable [AddCommGroup G] [Module k G] [Module R G]
34 
35 variable (D : RightSquareZeroTraceData k R B N G)
36 
37 /-- Multiplication by `c` kills the failure of two elements of `B` to
38 commute. -/
39 theorem c_mul_commutator_eq_zero (a b : B) :
40     D.c * Stafford.commutator a b = 0 := by
41   obtain ⟨z, hz, -⟩ := D.commutator_factor a b
42   rw [hz, ← mul_assoc, ← pow_two, D.c_sq, zero_mul]
43 
44 /-- Moving a factor past another factor is legitimate after multiplying by
45 the square-zero parameter. -/
46 theorem c_mul_mul_comm (a b : B) : D.c * (a * b) = D.c * (b * a) := by
47   have h := c_mul_commutator_eq_zero D a b
48   simp only [Stafford.commutator_eq_shared, AlgebraicAnalysis.ringCommutator,
49     mul_sub] at h
50   exact sub_eq_zero.mp h
51 
52 private theorem nonempty_oreSet_comap_of
53     {A C : Type*} [Ring A] [CommMonoid C]
54     (c : A)
55     (cCenter : c ∈ Set.center A)
56     (commutatorFactor : ∀ a b : A, ∃ z : A,
57       Stafford.commutator a b = c * z)
58     (cMulComm : ∀ a b : A, c * (a * b) = c * (b * a))
59     (pi : A →* C) (S : Submonoid C) :
60     Nonempty (OreLocalization.OreSet (S.comap pi)) := by
61   rw [OreLocalization.nonempty_oreSet_iff]
62   constructor
63   · intro r₁ r₂ s hrs
64     let delta : A := r₁ - r₂
65     obtain ⟨z, hsz⟩ := commutatorFactor (s : A) delta
66     let s2 : S.comap pi :=
67       ⟨(s : A) ^ 2, by
68         change pi ((s : A) ^ 2) ∈ S
69         rw [map_pow]
70         exact S.pow_mem s.property 2⟩
71     refine ⟨s2, ?_⟩
72     apply sub_eq_zero.mp
73     rw [← mul_sub]
74     change (s : A) ^ 2 * delta = 0
75     have hdelta_s : delta * (s : A) = 0 := by
76       change (r₁ - r₂) * (s : A) = 0
77       rw [sub_mul, hrs, sub_self]
78     have hs_delta : (s : A) * delta = c * z := by
79       simp only [Stafford.commutator_eq_shared, AlgebraicAnalysis.ringCommutator,
80         hdelta_s, sub_zero] at hsz
81       exact hsz
82     calc
83       (s : A) ^ 2 * delta = (s : A) * ((s : A) * delta) := by
84         simp [pow_two, mul_assoc]
85       _ = (s : A) * (c * z) := by rw [hs_delta]
86       _ = c * ((s : A) * z) := by
87         have hcs : c * (s : A) = (s : A) * c := by
88           exact cCenter.comm (s : A)
89         rw [← mul_assoc, ← hcs, mul_assoc]
90       _ = c * (z * (s : A)) := cMulComm (s : A) z
91       _ = (c * z) * (s : A) := by rw [mul_assoc]
92       _ = ((s : A) * delta) * (s : A) := by rw [hs_delta]
93       _ = (s : A) * (delta * (s : A)) := by rw [mul_assoc]
94       _ = 0 := by rw [hdelta_s, mul_zero]
95   · intro r s
96     obtain ⟨z, hsr⟩ := commutatorFactor (s : A) r
97     let s2 : S.comap pi :=
98       ⟨(s : A) ^ 2, by
99         change pi ((s : A) ^ 2) ∈ S
100         rw [map_pow]
101         exact S.pow_mem s.property 2⟩
102     refine ⟨(s : A) * r + c * z, s2, ?_⟩
103     change (s : A) ^ 2 * r = ((s : A) * r + c * z) * (s : A)
104     have hmove : (s : A) * r = r * (s : A) + c * z := by
105       simp only [Stafford.commutator_eq_shared, AlgebraicAnalysis.ringCommutator] at hsr
106       simpa [add_comm] using sub_eq_iff_eq_add.mp hsr
107     calc
108       (s : A) ^ 2 * r = (s : A) * ((s : A) * r) := by
109         simp [pow_two, mul_assoc]
110       _ = (s : A) * (r * (s : A) + c * z) := by rw [hmove]
111       _ = ((s : A) * r) * (s : A) + (s : A) * (c * z) := by
112         rw [mul_add, mul_assoc]
113       _ = ((s : A) * r) * (s : A) + c * ((s : A) * z) := by
114         have hcs : c * (s : A) = (s : A) * c := by
115           exact cCenter.comm (s : A)
116         rw [← mul_assoc, ← hcs]
117         simp only [mul_assoc]
118       _ = ((s : A) * r) * (s : A) + c * (z * (s : A)) := by
119         rw [cMulComm (s : A) z]
120       _ = ((s : A) * r + c * z) * (s : A) := by
121         rw [add_mul]
122         simp only [mul_assoc]
123 
124 /-- The inverse image in `B` of a multiplicative set in the commutative fibre
125 is a left Ore set.  The construction uses the squared denominator.
126 
127 The result is returned as `Nonempty` so callers can install the chosen Ore-set
128 structure locally without introducing a global instance for every `S`. -/
129 theorem nonempty_oreSet_comap (S : Submonoid R) :
130     Nonempty (OreLocalization.OreSet (S.comap D.pi.toMonoidHom)) :=
131   nonempty_oreSet_comap_of D.c
132     D.c_center
133     (fun a b => by
134       obtain ⟨z, hz, -⟩ := D.commutator_factor a b
135       exact ⟨z, hz⟩)
136     (c_mul_mul_comm D) D.pi.toMonoidHom S
137 
138 /-- Specialization from the opposite deformation ring to the commutative
139 special fibre. -/
140 def oppositeSpecializationMonoidHom : Bᵐᵒᵖ →* R where
141   toFun b := D.pi b.unop
142   map_one' := by simp
143   map_mul' a b := by
144     change D.pi (b.unop * a.unop) = D.pi a.unop * D.pi b.unop
145     rw [map_mul, mul_comm]
146 
147 /-- The right-module localization uses the opposite ring.  Its pulled-back
148 denominators are left Ore as well, so the concrete right two-jet module can be
149 localized by Mathlib's left Ore-localization API. -/
150 theorem nonempty_oreSet_comap_op (S : Submonoid R) :
151     Nonempty (OreLocalization.OreSet
152       (S.comap (oppositeSpecializationMonoidHom D))) := by
153   apply nonempty_oreSet_comap_of (MulOpposite.op D.c)
154   · refine
155       { comm := ?_
156         left_assoc := by intros; simp [mul_assoc]
157         right_assoc := by intros; simp [mul_assoc] }
158     intro a
159     apply MulOpposite.unop_injective
160     change a.unop * D.c = D.c * a.unop
161     exact (D.c_center.comm a.unop).symm
162   · intro a b
163     obtain ⟨z, hz, -⟩ := D.commutator_factor b.unop a.unop
164     refine ⟨MulOpposite.op z, ?_⟩
165     apply MulOpposite.unop_injective
166     change Stafford.commutator b.unop a.unop = z * D.c
167     rw [hz, D.c_center.comm z]
168   · intro a b
169     apply MulOpposite.unop_injective
170     change b.unop * a.unop * D.c = a.unop * b.unop * D.c
171     rw [← D.c_center.comm (b.unop * a.unop),
172       ← D.c_center.comm (a.unop * b.unop)]
173     exact c_mul_mul_comm D b.unop a.unop
174 
175 #print axioms c_mul_commutator_eq_zero
176 #print axioms c_mul_mul_comm
177 #print axioms nonempty_oreSet_comap
178 #print axioms oppositeSpecializationMonoidHom
179 #print axioms nonempty_oreSet_comap_op
180 
181 end
182 
183 end Stafford38.Characteristic.SquareZeroOreLocalization
184