| import OAI.Analysis.GroupDeterminants.IntegralTransfer |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace GroupRingDeterminant |
|
|
| section ComplexRegular |
| variable {G : Type} [Group G] {n : ℕ} |
|
|
| def shiftFunctions : G →* Module.End ℂ (G → ℂ) where |
| toFun g := { |
| toFun f h := f (g⁻¹ * h) |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl } |
| map_one' := by ext f h; simp |
| map_mul' g h := by ext f a; simp [mul_assoc] |
| |
| def convolutionHom : MonoidAlgebra ℂ G →ₐ[ℂ] Module.End ℂ (G → ℂ) := |
| MonoidAlgebra.lift ℂ (Module.End ℂ (G → ℂ)) G shiftFunctions |
|
|
| theorem convolutionHom_apply (a : MonoidAlgebra ℂ G) (f : G → ℂ) (h : G) : |
| convolutionHom a f h = a.coeff.sum fun g z => z * f (g⁻¹ * h) := by |
| simp only [convolutionHom, MonoidAlgebra.lift_apply, Finsupp.sum, |
| LinearMap.sum_apply, LinearMap.smul_apply, Finset.sum_apply, |
| Pi.smul_apply, smul_eq_mul] |
| rfl |
|
|
| local instance functionModule : Module (MonoidAlgebra ℂ G) (G → ℂ) := |
| Module.compHom (G → ℂ) convolutionHom.toRingHom |
|
|
| open scoped Matrix.Module |
|
|
| def complexOperator (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) : |
| Hilbert G n →L[ℂ] Hilbert G n := |
| ∑ i : Fin n, ∑ j : Fin n, (A i j).coeff.sum |
| (fun g z => z • elementaryOperator i j g) |
|
|
| theorem complexOperator_apply (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) |
| (ξ : Hilbert G n) (i : Fin n) (h : G) : |
| complexOperator A ξ (i, h) = ∑ j : Fin n, |
| (A i j).coeff.sum fun g z => z * ξ (j, g⁻¹ * h) := by |
| classical |
| simp only [complexOperator, Finsupp.sum, sum_apply, |
| smul_apply, lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, |
| Pi.smul_apply, smul_eq_mul, elementaryOperator_apply] |
| rw [Finset.sum_eq_single i] |
| · simp |
| · intro b _ hbi |
| simp [Ne.symm hbi] |
| · simp |
|
|
| theorem complexOperator_curry (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) |
| (ξ : Hilbert G n) : |
| Function.curry (complexOperator A ξ) = A • Function.curry (ξ : Fin n × G → ℂ) := by |
| funext i h |
| rw [Matrix.Module.smul_apply] |
| simp only [Finset.sum_apply] |
| rw [Function.curry_apply, complexOperator_apply] |
| apply Finset.sum_congr rfl |
| intro j _ |
| exact (convolutionHom_apply (A i j) (fun g => ξ (j, g)) h).symm |
|
|
| theorem complexOperator_mul (A B : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) : |
| complexOperator (A * B) = complexOperator A * complexOperator B := by |
| apply ContinuousLinearMap.ext |
| intro ξ |
| apply lp.ext |
| funext a |
| obtain ⟨i, h⟩ := a |
| have he : Function.curry (complexOperator (A * B) ξ) = |
| Function.curry (complexOperator A (complexOperator B ξ)) := by |
| rw [complexOperator_curry, mul_smul, complexOperator_curry, complexOperator_curry] |
| exact congrFun (congrFun he i) h |
|
|
| theorem complexOperator_one : complexOperator (1 : Matrix (Fin n) (Fin n) |
| (MonoidAlgebra ℂ G)) = 1 := by |
| apply ContinuousLinearMap.ext |
| intro ξ |
| apply lp.ext |
| funext a |
| obtain ⟨i, h⟩ := a |
| have he := complexOperator_curry (1 : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) ξ |
| rw [one_smul] at he |
| exact congrFun (congrFun he i) h |
|
|
| theorem complexOperator_add (A B : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) : |
| complexOperator (A + B) = complexOperator A + complexOperator B := by |
| apply ContinuousLinearMap.ext |
| intro ξ |
| apply lp.ext |
| funext a |
| obtain ⟨i, h⟩ := a |
| have he : Function.curry (complexOperator (A + B) ξ) = |
| Function.curry (complexOperator A ξ) + Function.curry (complexOperator B ξ) := by |
| rw [complexOperator_curry, add_smul, complexOperator_curry, complexOperator_curry] |
| exact congrFun (congrFun he i) h |
|
|
| theorem complexOperator_zero : complexOperator (0 : Matrix (Fin n) (Fin n) |
| (MonoidAlgebra ℂ G)) = 0 := by |
| simp [complexOperator, MonoidAlgebra.coeff_zero] |
|
|
| def complexRepresentation : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G) →+* |
| (Hilbert G n →L[ℂ] Hilbert G n) where |
| toFun := complexOperator |
| map_one' := complexOperator_one |
| map_mul' := complexOperator_mul |
| map_zero' := complexOperator_zero |
| map_add' := complexOperator_add |
|
|
| theorem complexOperator_isUnit {A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)} |
| (hA : IsUnit A) : IsUnit (complexOperator A) := hA.map complexRepresentation |
|
|
| theorem complexOperator_integer (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℤ G)) : |
| complexOperator (A.map (MonoidAlgebra.mapRingHom G (Int.castRingHom ℂ))) = |
| regularOperator A := by |
| classical |
| unfold complexOperator regularOperator |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| change (MonoidAlgebra.map (Int.castRingHom ℂ).toAddMonoidHom (A i j)).coeff.sum _ = _ |
| rw [MonoidAlgebra.coeff_map] |
| exact Finsupp.sum_mapRange_index |
| (h := fun groupElement coefficient => coefficient • elementaryOperator i j groupElement) |
| (fun groupElement => zero_smul ℂ (elementaryOperator i j groupElement)) |
|
|
| theorem regularOperator_isUnit {A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℤ G)} |
| (hA : IsUnit (rationalMatrix A)) : IsUnit (regularOperator A) := by |
| let f : MonoidAlgebra ℚ G →+* MonoidAlgebra ℂ G := |
| MonoidAlgebra.mapRingHom G (Rat.castHom ℂ) |
| have h := complexOperator_isUnit (hA.map f.mapMatrix) |
| have hf : f.comp (MonoidAlgebra.mapRingHom G (Int.castRingHom ℚ)) = |
| MonoidAlgebra.mapRingHom G (Int.castRingHom ℂ) := by |
| rw [← MonoidAlgebra.mapRingHom_comp] |
| congr 1 |
| change IsUnit (complexOperator (A.map |
| (f.comp (MonoidAlgebra.mapRingHom G (Int.castRingHom ℚ))))) at h |
| rw [hf, complexOperator_integer] at h |
| exact h |
|
|
| def groupTraceCLM : (Hilbert G n →L[ℂ] Hilbert G n) →L[ℂ] ℂ := |
| ∑ i : Fin n, (innerSL ℂ (identityVector i)).comp |
| (ContinuousLinearMap.apply ℂ (Hilbert G n) (identityVector i)) |
|
|
| theorem groupTraceCLM_apply (T : Hilbert G n →L[ℂ] Hilbert G n) : |
| groupTraceCLM T = groupTrace T := by |
| simp [groupTraceCLM, groupTrace] |
|
|
| theorem groupTrace_complex (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) : |
| groupTrace (complexOperator A) = ∑ i : Fin n, (A i i).coeff 1 := by |
| classical |
| unfold groupTrace |
| apply Finset.sum_congr rfl |
| intro i _ |
| have hi (ξ : Hilbert G n) : inner ℂ (identityVector i) ξ = ξ (i, 1) := by |
| simp [identityVector, lp.inner_single_left, RCLike.inner_apply] |
| rw [hi, complexOperator_apply] |
| rw [Finset.sum_eq_single i] |
| · rw [(A i i).coeff.sum_eq_single 1] |
| · simp [identityVector_apply] |
| · intro g _ hg |
| simp [identityVector_apply, hg] |
| · simp |
| · intro j _ hji |
| simp [identityVector_apply, hji] |
| · simp |
|
|
| theorem coefficient_mul_comm (a b : MonoidAlgebra ℂ G) : |
| (a * b).coeff 1 = (b * a).coeff 1 := by |
| rw [MonoidAlgebra.coeff_mul_apply_left a b, MonoidAlgebra.coeff_mul_apply_right b a] |
| simp only [mul_one, one_mul, mul_comm] |
|
|
| theorem groupTrace_complex_mul_comm |
| (A B : Matrix (Fin n) (Fin n) (MonoidAlgebra ℂ G)) : |
| groupTrace (complexOperator A * complexOperator B) = |
| groupTrace (complexOperator B * complexOperator A) := by |
| classical |
| rw [← complexOperator_mul, ← complexOperator_mul, groupTrace_complex, groupTrace_complex] |
| simp only [Matrix.mul_apply, MonoidAlgebra.coeff_sum, Finsupp.finsetSum_apply] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| exact coefficient_mul_comm _ _ |
|
|
| end ComplexRegular |
|
|
| end GroupRingDeterminant |
|
|
| end |
|
|
| end OAI |
|
|
