lean/OAI/Analysis/GroupDeterminants/IntegralTransfer.lean

import OAI.Analysis.GroupDeterminants.RegularTrace

namespace OAI

universe uG um ur

noncomputable section
open scoped BigOperators

namespace GroupRingDeterminant

section IntegralTransfer
variable {G : Type uG} {m : Type um} {r : Type ur} [Group G] [Fintype m] [DecidableEq m]
  [Fintype r] [DecidableEq r]

def divideGroup (q : ℕ) (a : MonoidAlgebra ℤ G) : MonoidAlgebra ℤ G :=
  MonoidAlgebra.ofCoeff (a.coeff.mapRange (fun z => z / (q : ℤ)) (by simp))

theorem kernel_integerReduction (q : ℕ) (a : MonoidAlgebra ℤ G)
    (ha : MonoidAlgebra.mapRingHom G (Int.castRingHom (ZMod q)) a = 0) :
    (q : ℤ) • divideGroup q a = a := by
  apply MonoidAlgebra.ext
  ext g
  have hg := congrArg (fun x : MonoidAlgebra (ZMod q) G => x.coeff g) ha
  change (a.coeff g : ZMod q) = 0 at hg
  have hd : (q : ℤ) ∣ a.coeff g := (ZMod.intCast_zmod_eq_zero_iff_dvd _ q).mp (by
    simpa only [MonoidAlgebra.coeff_mapRingHom,
      MonoidAlgebra.coeff_zero, Finsupp.zero_apply] using hg)
  rw [MonoidAlgebra.coeff_smul]
  change (q : ℤ) * (a.coeff g / (q : ℤ)) = a.coeff g
  exact Int.mul_ediv_cancel' hd

def toRat : MonoidAlgebra ℤ G →+* MonoidAlgebra ℚ G :=
  MonoidAlgebra.mapRingHom G (Int.castRingHom ℚ)

def toMod (q : ℕ) : MonoidAlgebra ℤ G →+* MonoidAlgebra (ZMod q) G :=
  MonoidAlgebra.mapRingHom G (Int.castRingHom (ZMod q))

omit [Fintype m] [DecidableEq m] [Fintype r] [DecidableEq r] in
theorem map_toRat_zsmul (t : ℤ) (A : Matrix m r (MonoidAlgebra ℤ G)) :
    (t • A).map toRat = (t : ℚ) • A.map toRat := by
  rw [Int.cast_smul_eq_zsmul]
  exact Matrix.map_smul _ _ (fun a => map_zsmul toRat _ a) _

theorem integral_transfer_of_lifts (q : ℕ) (hq : q ≠ 0)
    (P : Matrix m m (MonoidAlgebra ℚ G)) (hP : P * P = P)
    (C : Matrix m m (MonoidAlgebra ℤ G))
    (hC : C.map toRat = P + (q : ℚ) • (1 - P))
    (U : Matrix m r (MonoidAlgebra ℤ G)) (V : Matrix r m (MonoidAlgebra ℤ G))
    (huv : (U * V).map (toMod q) = C.map (toMod q)) :
    ∃ A : Matrix (r ⊕ m) (r ⊕ m) (MonoidAlgebra ℤ G),
      A.map toRat = transferMatrix (q : ℚ) P (U.map toRat) (V.map toRat) ∧
      IsUnit (A.map toRat) := by
  let W : Matrix m m (MonoidAlgebra ℤ G) := fun i j => divideGroup q ((U * V - C) i j)
  have hw : (q : ℤ) • W = U * V - C := by
    apply Matrix.ext
    intro i j
    apply kernel_integerReduction
    have h := congrFun (congrFun huv i) j
    change toMod q ((U * V) i j - C i j) = 0
    rw [map_sub, sub_eq_zero]
    exact h
  have hwq := congrArg (fun A : Matrix m m (MonoidAlgebra ℤ G) => A.map toRat) hw
  rw [map_toRat_zsmul, Int.cast_natCast, Matrix.map_sub _ (map_sub _) _ _, Matrix.map_mul, hC] at hwq
  have hq' : (q : ℚ) ≠ 0 := Nat.cast_ne_zero.mpr hq
  have hw' : W.map toRat = (q : ℚ)⁻¹ •
      (U.map toRat * V.map toRat - P - (q : ℚ) • (1 - P)) := by
    rw [sub_sub, ← hwq, smul_smul, inv_mul_cancel₀ hq', one_smul]
  refine ⟨Matrix.fromBlocks ((q : ℤ) • 1) V U W, ?_, ?_⟩
  · rw [Matrix.fromBlocks_map, map_toRat_zsmul,
      Int.cast_natCast, Matrix.map_one _ (map_zero _) (map_one _), hw']
    rfl
  · rw [Matrix.fromBlocks_map, map_toRat_zsmul,
      Int.cast_natCast, Matrix.map_one _ (map_zero _) (map_one _), hw']
    exact transferMatrix_isUnit (q : ℚ) hq' P hP (U.map toRat) (V.map toRat)

omit [Fintype m] [DecidableEq m] [Fintype r] [DecidableEq r] in
theorem map_toMod_zsmul (q : ℕ) (t : ℤ) (A : Matrix m r (MonoidAlgebra ℤ G)) :
    (t • A).map (toMod q) = (t : ZMod q) • A.map (toMod q) := by
  rw [Int.cast_smul_eq_zsmul]
  exact Matrix.map_smul _ _ (fun a => map_zsmul (toMod q) _ a) _

omit [Fintype m] [DecidableEq m] [Fintype r] [DecidableEq r] in
theorem reduceGroupTwo_toMod (k : ℕ) (hk : 0 < k) (a : MonoidAlgebra ℤ G) :
    reduceGroupTwo k hk (toMod (2 ^ k) a) = toMod 2 a := by
  apply MonoidAlgebra.ext
  ext g
  simp only [reduceGroupTwo, toMod, MonoidAlgebra.coeff_mapRingHom]
  exact map_intCast (reduceTwo k hk) _

omit [DecidableEq m] [Fintype r] [DecidableEq r] in
theorem integer_projection_square (P : Matrix m m (MonoidAlgebra ℚ G))
    (hP : P * P = P) (D : ℤ) (Z : Matrix m m (MonoidAlgebra ℤ G))
    (hZ : Z.map toRat = (D : ℚ) • P) : Z * Z = D • Z := by
  have hi : Function.Injective (toRat (G := G)) :=
    MonoidAlgebra.map_injective (Int.castRingHom ℚ).toAddMonoidHom Int.cast_injective
  apply Matrix.map_injective hi
  change (Z * Z).map toRat = (D • Z).map toRat
  rw [Matrix.map_mul, map_toRat_zsmul, hZ, Matrix.smul_mul, Matrix.mul_smul, hP]

omit [Fintype r] [DecidableEq r] in

theorem integral_reweight_mod_idempotent (q : ℕ) (D t : ℤ)
    (hDt : D * t = 1 - (q : ℤ)) (Z : Matrix m m (MonoidAlgebra ℤ G))
    (hZ : Z * Z = D • Z) :
    let C := (q : ℤ) • (1 : Matrix m m (MonoidAlgebra ℤ G)) + t • Z
    C.map (toMod q) * C.map (toMod q) = C.map (toMod q) := by
  dsimp only
  have hqt : ((q : ℤ) : ZMod q) = 0 := by simp
  have hdt : (D : ZMod q) * (t : ZMod q) = 1 := by
    have h := congrArg (fun z : ℤ => (z : ZMod q)) hDt
    simpa using h
  have hzz : Z.map (toMod q) * Z.map (toMod q) = (D : ZMod q) • Z.map (toMod q) := by
    rw [← Matrix.map_mul, hZ, map_toMod_zsmul]
  simp only [Matrix.map_add _ (map_add _) _ _, map_toMod_zsmul, hqt,
    zero_smul, zero_add]
  rw [Matrix.smul_mul, Matrix.mul_smul, hzz, smul_smul, smul_smul]
  congr 1
  calc
    (t : ZMod q) * (t : ZMod q) * (D : ZMod q) = (t : ZMod q) * ((D : ZMod q) * t) := by ring
    _ = (t : ZMod q) := by rw [hdt, mul_one]

omit [Fintype m] [Fintype r] [DecidableEq r] in
theorem integral_reweight_rational (q : ℕ) (D t : ℤ)
    (hDt : D * t = 1 - (q : ℤ)) (Z : Matrix m m (MonoidAlgebra ℤ G))
    (P : Matrix m m (MonoidAlgebra ℚ G)) (hZ : Z.map toRat = (D : ℚ) • P) :
    ((q : ℤ) • (1 : Matrix m m (MonoidAlgebra ℤ G)) + t • Z).map toRat =
      P + (q : ℚ) • (1 - P) := by
  have hdt : (t : ℚ) * (D : ℚ) = 1 - (q : ℚ) := by
    have h := congrArg (fun z : ℤ => (z : ℚ)) hDt
    simpa [mul_comm] using h
  rw [Matrix.map_add _ (map_add _) _ _, map_toRat_zsmul, map_toRat_zsmul,
    Matrix.map_one _ (map_zero _) (map_one _), hZ, smul_smul, hdt]
  simp only [Int.cast_natCast, sub_smul, one_smul, smul_sub]
  abel

theorem integral_transfer (D : ℕ) (hodd : Odd D)
    (P : Matrix m m (MonoidAlgebra ℚ G)) (hP : P * P = P)
    (Z : Matrix m m (MonoidAlgebra ℤ G)) (hZ : Z.map toRat = (D : ℚ) • P)
    (u : Matrix m r (MonoidAlgebra (ZMod 2) G))
    (v : Matrix r m (MonoidAlgebra (ZMod 2) G)) (huv : u * v = Z.map (toMod 2))
    (k : ℕ) (hk : 0 < k) (t : ℤ) (hDt : (D : ℤ) * t = 1 - (2 ^ k : ℕ)) :
    ∃ (U : Matrix m r (MonoidAlgebra ℤ G)) (V : Matrix r m (MonoidAlgebra ℤ G))
      (A : Matrix (r ⊕ m) (r ⊕ m) (MonoidAlgebra ℤ G)),
      A.map toRat = transferMatrix ((2 ^ k : ℕ) : ℚ) P (U.map toRat) (V.map toRat) ∧
      IsUnit (A.map toRat) := by
  classical
  let q : ℕ := 2 ^ k
  let C : Matrix m m (MonoidAlgebra ℤ G) := (q : ℤ) • 1 + t • Z
  let e : Matrix m m (MonoidAlgebra (ZMod q) G) := C.map (toMod q)
  have hZZ : Z * Z = (D : ℤ) • Z :=
    integer_projection_square P hP D Z (by simpa using hZ)
  have he : e * e = e := integral_reweight_mod_idempotent q D t hDt Z hZZ
  have htwo : (2 : ZMod 2) = 0 := by decide
  have hD2 : (D : ZMod 2) = 1 := by
    obtain ⟨a, rfl⟩ := hodd
    simp only [Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat, htwo, zero_mul,
      zero_add, Nat.cast_one]
  have hq2 : (q : ZMod 2) = 0 := by
    simp only [q, Nat.cast_pow, Nat.cast_ofNat, htwo, zero_pow hk.ne']
  have ht2 : (t : ZMod 2) = 1 := by
    have h := congrArg (fun z : ℤ => (z : ZMod 2)) hDt
    push_cast at h
    simpa only [hD2, htwo, zero_pow hk.ne', one_mul, sub_zero] using h
  have hC2 : C.map (toMod 2) = Z.map (toMod 2) := by
    simp only [C, Matrix.map_add _ (map_add _) _ _, map_toMod_zsmul,
      Int.cast_natCast, hq2, ht2, zero_smul, one_smul, zero_add]
  have he2 : e.map (reduceGroupTwo k hk) = C.map (toMod 2) := by
    apply Matrix.ext
    intro i j
    exact reduceGroupTwo_toMod k hk (C i j)
  obtain ⟨u', v', hu'v'⟩ := lift_binary_factorization k hk e he u v (by
    rw [he2, hC2]
    exact huv)
  have hs := integerReduction_surjective (G := G) q
  choose U₀ hU₀ using fun i j => hs (u' i j)
  choose V₀ hV₀ using fun i j => hs (v' i j)
  let U : Matrix m r (MonoidAlgebra ℤ G) := U₀
  let V : Matrix r m (MonoidAlgebra ℤ G) := V₀
  have hU : U.map (toMod q) = u' := Matrix.ext hU₀
  have hV : V.map (toMod q) = v' := Matrix.ext hV₀
  have hUV : (U * V).map (toMod q) = C.map (toMod q) := by
    rw [Matrix.map_mul, hU, hV, hu'v']
  have hC : C.map toRat = P + (q : ℚ) • (1 - P) :=
    integral_reweight_rational q D t hDt Z P (by simpa using hZ)
  obtain ⟨A, ha, haunit⟩ := integral_transfer_of_lifts q
    (pow_ne_zero _ (by decide)) P hP C hC U V hUV
  exact ⟨U, V, A, ha, haunit⟩

theorem integral_transfer_of_congruence (D : ℕ) (hodd : Odd D)
    (P : Matrix m m (MonoidAlgebra ℚ G)) (hP : P * P = P)
    (Z : Matrix m m (MonoidAlgebra ℤ G)) (hZ : Z.map toRat = (D : ℚ) • P)
    (u : Matrix m r (MonoidAlgebra (ZMod 2) G))
    (v : Matrix r m (MonoidAlgebra (ZMod 2) G)) (huv : u * v = Z.map (toMod 2))
    (k : ℕ) (hk : 0 < k) (hkD : Nat.ModEq D (2 ^ k) 1) :
    ∃ (U : Matrix m r (MonoidAlgebra ℤ G)) (V : Matrix r m (MonoidAlgebra ℤ G))
      (A : Matrix (r ⊕ m) (r ⊕ m) (MonoidAlgebra ℤ G)),
      A.map toRat = transferMatrix ((2 ^ k : ℕ) : ℚ) P (U.map toRat) (V.map toRat) ∧
      IsUnit (A.map toRat) := by
  obtain ⟨t, ht⟩ := Nat.modEq_iff_dvd.mp hkD
  exact integral_transfer D hodd P hP Z hZ u v huv k hk t (by simpa using ht.symm)

end IntegralTransfer

end GroupRingDeterminant

end

end OAI