File size: 6,649 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
import OAI.Algebra.AuslanderReiten.Tensor.BalancedTensorExact

namespace OAI

noncomputable section
namespace ArExplicit.BalancedTensor

variable {k R : Type*} [CommRing k] [Ring R] [Algebra k R]
variable {F G H M : Type*}
variable [AddCommGroup F] [Module k F] [Module Rᡐᡒᡖ F] [IsScalarTower k Rᡐᡒᡖ F]
variable [AddCommGroup G] [Module k G] [Module Rᡐᡒᡖ G] [IsScalarTower k Rᡐᡒᡖ G]
variable [AddCommGroup H] [Module k H] [Module Rᡐᡒᡖ H] [IsScalarTower k Rᡐᡒᡖ H]
variable [AddCommGroup M] [Module k M] [Module R M] [IsScalarTower k R M]

def mapLeft (a : F β†’β‚—[Rᡐᡒᡖ] G) : BalancedTensor k R F M β†’β‚—[k] BalancedTensor k R G M :=
  map (a.restrictScalars k) LinearMap.id (fun r f => a.map_smul r f) (fun _ _ => rfl)

omit [IsScalarTower k R M] in
@[simp] theorem mapLeft_tmul (a : F β†’β‚—[Rᡐᡒᡖ] G) (f : F) (m : M) :
    mapLeft (k := k) a (tmul f m) = tmul (a f) m := rfl

omit [IsScalarTower k R M] in
@[simp] theorem mapLeft_comp (a : F β†’β‚—[Rᡐᡒᡖ] G) (b : G β†’β‚—[Rᡐᡒᡖ] H) :
    mapLeft (k := k) (M := M) (b.comp a) = (mapLeft b).comp (mapLeft a) := by
  apply hom_ext
  intro f m
  rfl

omit [IsScalarTower k R M] in
@[simp] theorem mapLeft_zero : mapLeft (k := k) (M := M) (0 : F β†’β‚—[Rᡐᡒᡖ] G) = 0 := by
  apply hom_ext
  intro f m
  exact zero_tmul m

variable {n : β„•}

def leftCoefficients (s : M β†’β‚—[R] (Fin n β†’ R)) :
    BalancedTensor k R F M β†’β‚—[k] (Fin n β†’ F) :=
  lift
    { toFun f :=
        { toFun m i := MulOpposite.op (s m i) β€’ f
          map_add' m m' := by
            ext i
            simp only [map_add, Pi.add_apply, MulOpposite.op_add, add_smul]
          map_smul' c m := by
            ext i
            simp only [LinearMap.map_smul_of_tower, Pi.smul_apply, MulOpposite.op_smul,
              smul_assoc, RingHom.id_apply] }
      map_add' f f' := by ext m i; exact smul_add _ _ _
      map_smul' c f := by
        ext m i
        exact (smul_comm c (MulOpposite.op (s m i)) f).symm }
    (by
      intro f r m
      ext i
      change MulOpposite.op (s m i) β€’ (MulOpposite.op r β€’ f) = MulOpposite.op (s (r β€’ m) i) β€’ f
      simp only [map_smul, Pi.smul_apply, smul_eq_mul, MulOpposite.op_mul, mul_smul])

@[simp] theorem leftCoefficients_tmul (s : M β†’β‚—[R] (Fin n β†’ R)) (f : F) (m : M) (i : Fin n) :
    leftCoefficients (k := k) s (tmul f m) i = MulOpposite.op (s m i) β€’ f := rfl

def leftRecombine (p : (Fin n β†’ R) β†’β‚—[R] M) :
    (Fin n β†’ F) β†’β‚—[k] BalancedTensor k R F M :=
  βˆ‘ i, (((mk (k := k) (R := R)).flip (p (Pi.single i 1))).comp (LinearMap.proj i))

omit [Algebra k R] [IsScalarTower k Rᡐᡒᡖ F] [IsScalarTower k R M] in
@[simp] theorem leftRecombine_apply (p : (Fin n β†’ R) β†’β‚—[R] M) (f : Fin n β†’ F) :
    leftRecombine (k := k) p f = βˆ‘ i, tmul (f i) (p (Pi.single i 1)) := by
  simp [leftRecombine, mk]

theorem leftRecombine_leftCoefficients (s : M β†’β‚—[R] (Fin n β†’ R))
    (p : (Fin n β†’ R) β†’β‚—[R] M) (h : p.comp s = LinearMap.id) (z : BalancedTensor k R F M) :
    leftRecombine p (leftCoefficients s z) = z := by
  induction z using induction_on with
  | zero => simp
  | add x y hx hy => simp only [map_add, hx, hy]
  | tmul f m =>
    rw [leftRecombine_apply]
    calc
      (βˆ‘ i, tmul (leftCoefficients s (tmul f m) i) (p (Pi.single i 1))) =
          βˆ‘ i, tmul f (p (Pi.single i (s m i))) := by
        apply Finset.sum_congr rfl
        intro i hi
        rw [leftCoefficients_tmul, balance, ← p.map_smul]
        congr 2
        ext j
        by_cases hij : j = i
        Β· subst j; simp
        Β· simp [hij]
      _ = tmul f (p (βˆ‘ i, Pi.single i (s m i))) := by
        simp only [map_sum]
        exact (map_sum (mk (k := k) (R := R) f) _ _).symm
      _ = tmul f m := by
        rw [Finset.univ_sum_single]
        exact congrArg (fun m => tmul (k := k) (R := R) f m) (DFunLike.congr_fun h m)

theorem leftCoefficients_natural (s : M β†’β‚—[R] (Fin n β†’ R)) (a : F β†’β‚—[Rᡐᡒᡖ] G)
    (z : BalancedTensor k R F M) :
    leftCoefficients s (mapLeft a z) = fun i => a (leftCoefficients s z i) := by
  induction z using induction_on with
  | zero => ext i; simp
  | tmul f m => ext i; simp
  | add x y hx hy => ext i; simp only [map_add, Pi.add_apply, hx, hy]

omit [IsScalarTower k R M] in
theorem leftRecombine_natural (p : (Fin n β†’ R) β†’β‚—[R] M) (a : F β†’β‚—[Rᡐᡒᡖ] G) (z : Fin n β†’ F) :
    mapLeft a (leftRecombine p z) = leftRecombine (k := k) p (fun i => a (z i)) := by
  simp only [leftRecombine_apply, map_sum, mapLeft_tmul]

theorem mapLeft_exact [Module.Finite R M] [Module.Projective R M]
    (a : F β†’β‚—[Rᡐᡒᡖ] G) (b : G β†’β‚—[Rᡐᡒᡖ] H) (hex : Function.Exact a b) :
    Function.Exact (mapLeft (k := k) (M := M) a) (mapLeft b) := by
  obtain ⟨n, p, hp⟩ := Module.Finite.exists_fin' R M
  obtain ⟨s, hs⟩ := Module.projective_lifting_property p (LinearMap.id : M β†’β‚—[R] M) hp
  intro z
  constructor
  Β· intro hz
    have hcoords : βˆ€ i, b (leftCoefficients s z i) = 0 := by
      have hnat := leftCoefficients_natural s b z
      rw [hz, map_zero] at hnat
      intro i
      exact (congrFun hnat i).symm
    choose w hw using fun i => (hex (leftCoefficients s z i)).mp (hcoords i)
    refine ⟨leftRecombine p w, ?_⟩
    rw [leftRecombine_natural]
    convert leftRecombine_leftCoefficients s p hs z using 1
    exact congrArg (leftRecombine (k := k) p) (funext hw)
  · rintro ⟨w, rfl⟩
    have hba : b.comp a = 0 := by ext f; exact (hex (a f)).mpr ⟨f, rfl⟩
    change ((mapLeft b).comp (mapLeft a)) w = 0
    rw [← mapLeft_comp, hba, mapLeft_zero, LinearMap.zero_apply]

omit [IsScalarTower k R M] in
theorem mapLeft_surjective (a : F β†’β‚—[Rᡐᡒᡖ] G) (ha : Function.Surjective a) :
    Function.Surjective (mapLeft (k := k) (M := M) a) :=
  map_surjective (a.restrictScalars k) LinearMap.id
    (fun r f => a.map_smul r f) (fun _ _ => rfl) ha Function.surjective_id

theorem mapLeft_injective [Module.Finite R M] [Module.Projective R M]
    (a : F β†’β‚—[Rᡐᡒᡖ] G) (ha : Function.Injective a) :
    Function.Injective (mapLeft (k := k) (M := M) a) := by
  obtain ⟨n, p, hp⟩ := Module.Finite.exists_fin' R M
  obtain ⟨s, hs⟩ := Module.projective_lifting_property p (LinearMap.id : M β†’β‚—[R] M) hp
  intro x y hxy
  have hc : leftCoefficients s x = leftCoefficients s y := by
    ext i
    apply ha
    have hh := congrArg (fun z => leftCoefficients s z i) hxy
    simpa only [leftCoefficients_natural] using hh
  rw [← leftRecombine_leftCoefficients s p hs x, ← leftRecombine_leftCoefficients s p hs y, hc]

end ArExplicit.BalancedTensor

end

end OAI