| import Mathlib |
| import OAI.Algebra.FinitisticAsymmetry.Model |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped BigOperators |
| namespace LittleFinitistic.SplitBasic |
| universe v |
| variable {k : Type v} [Field k] |
| lemma pow_le_comap_pow {R S : Type*} [Ring R] [Ring S] (f : R →+* S) |
| (I : Ideal R) (J : Ideal S) (h : I ≤ J.comap f) (n : ℕ) : I ^ n ≤ (J ^ n).comap f := by |
| induction n with |
| | zero => simp [Submodule.pow_zero, Ideal.one_eq_top] |
| | succ n ih => |
| rw [Submodule.pow_succ, Submodule.pow_succ] |
| apply Ideal.mul_le.mpr |
| intro x hx y hy |
| change f (x * y) ∈ J ^ n * J |
| rw [map_mul] |
| exact Ideal.mul_mem_mul (ih hx) (h hy) |
|
|
| section SquareZero |
| variable {R M : Type v} [Ring R] [Algebra k R] [AddCommGroup M] |
| [Module R M] [Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] |
| [Module k M] [IsScalarTower k R M] [IsScalarTower k Rᵐᵒᵖ M] |
| variable {ι : Type v} (χ : R →ₐ[k] (ι → k)) |
| def squareZeroAugmentation : TrivSqZeroExt R M →ₐ[k] (ι → k) := |
| χ.comp (TrivSqZeroExt.fstHom k R M) |
| lemma squareZero_surjective (hχ : Function.Surjective χ) : |
| Function.Surjective (squareZeroAugmentation (M := M) χ) := by |
| intro s |
| obtain ⟨r, hr⟩ := hχ s |
| exact ⟨TrivSqZeroExt.inl r, hr⟩ |
| lemma squareZero_ker_nilpotent (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥) : |
| ∃ n : ℕ, (RingHom.ker (squareZeroAugmentation (M := M) χ).toRingHom) ^ n = ⊥ := by |
| obtain ⟨n, hn⟩ := hJ |
| let f := (TrivSqZeroExt.fstHom k R M).toRingHom |
| let K := RingHom.ker (squareZeroAugmentation (M := M) χ).toRingHom |
| let J := RingHom.ker χ.toRingHom |
| let L := RingHom.ker f |
| have h : K ^ n ≤ L := by |
| have hp := pow_le_comap_pow f K J (by intro x hx; exact hx) n |
| rw [hn] at hp |
| exact hp |
| have hL : L * L = ⊥ := by |
| apply le_bot_iff.mp |
| apply Ideal.mul_le.mpr |
| intro x hx y hy |
| change x.fst = 0 at hx |
| change y.fst = 0 at hy |
| change x * y = 0 |
| apply TrivSqZeroExt.ext <;> simp [TrivSqZeroExt.fst_mul, TrivSqZeroExt.snd_mul, hx, hy] |
| refine ⟨n + n, le_bot_iff.mp ?_⟩ |
| rw [Ideal.IsTwoSided.pow_add] |
| exact (Ideal.mul_mono h h).trans hL.le |
| end SquareZero |
|
|
| section Product |
| variable {R S ι κ : Type v} [Ring R] [Ring S] [Algebra k R] [Algebra k S] |
| variable (χ : R →ₐ[k] (ι → k)) (ψ : S →ₐ[k] (κ → k)) |
| def productAugmentation : R × S →ₐ[k] (Sum ι κ → k) where |
| toFun x := Sum.elim (χ x.1) (ψ x.2) |
| map_one' := by ext i; cases i <;> simp |
| map_zero' := by ext i; cases i <;> simp |
| map_add' x y := by ext i; cases i <;> simp |
| map_mul' x y := by ext i; cases i <;> simp |
| commutes' r := by ext i; cases i <;> simp |
| lemma product_surjective (hχ : Function.Surjective χ) (hψ : Function.Surjective ψ) : |
| Function.Surjective (productAugmentation χ ψ) := by |
| intro s |
| obtain ⟨r, hr⟩ := hχ (s ∘ Sum.inl) |
| obtain ⟨t, ht⟩ := hψ (s ∘ Sum.inr) |
| refine ⟨(r,t), ?_⟩ |
| ext i |
| cases i <;> simp [productAugmentation, hr, ht] |
| lemma product_ker_nilpotent |
| (hχ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥) |
| (hψ : ∃ n : ℕ, (RingHom.ker ψ.toRingHom) ^ n = ⊥) : |
| ∃ n : ℕ, (RingHom.ker (productAugmentation χ ψ).toRingHom) ^ n = ⊥ := by |
| obtain ⟨m, hm⟩ := hχ |
| obtain ⟨n, hn⟩ := hψ |
| let K := RingHom.ker (productAugmentation χ ψ).toRingHom |
| have h₁ := pow_le_comap_pow (RingHom.fst R S) K (RingHom.ker χ.toRingHom) |
| (by intro x hx; exact funext (fun i => congrFun hx (Sum.inl i))) m |
| have h₂ := pow_le_comap_pow (RingHom.snd R S) K (RingHom.ker ψ.toRingHom) |
| (by intro x hx; exact funext (fun i => congrFun hx (Sum.inr i))) n |
| rw [hm] at h₁ |
| rw [hn] at h₂ |
| refine ⟨m + n, le_bot_iff.mp ?_⟩ |
| intro x hx |
| exact Prod.ext (h₁ (Ideal.pow_le_pow_right (by omega) hx)) |
| (h₂ (Ideal.pow_le_pow_right (by omega) hx)) |
| end Product |
|
|
| section Opposite |
| variable {R ι : Type v} [Ring R] [Algebra k R] (χ : R →ₐ[k] (ι → k)) |
| def oppositeAugmentation : Rᵐᵒᵖ →ₐ[k] (ι → k) where |
| toFun x := χ x.unop |
| map_one' := χ.map_one |
| map_zero' := χ.map_zero |
| map_add' x y := χ.map_add _ _ |
| map_mul' x y := by simp [map_mul, mul_comm] |
| commutes' r := χ.commutes r |
| lemma opposite_surjective (hχ : Function.Surjective χ) : |
| Function.Surjective (oppositeAugmentation χ) := by |
| intro s |
| obtain ⟨r, hr⟩ := hχ s |
| exact ⟨MulOpposite.op r, hr⟩ |
| lemma unop_mem_pow_ker (n : ℕ) {x : Rᵐᵒᵖ} |
| (hx : x ∈ (RingHom.ker (oppositeAugmentation χ).toRingHom) ^ n) : |
| x.unop ∈ (RingHom.ker χ.toRingHom) ^ n := by |
| induction n generalizing x with |
| | zero => simp [Submodule.pow_zero, Ideal.one_eq_top] |
| | succ n ih => |
| rw [Submodule.pow_succ] at hx |
| rw [Ideal.IsTwoSided.pow_succ] |
| refine Submodule.mul_induction_on hx ?_ ?_ |
| · intro y hy z hz |
| exact Ideal.mul_mem_mul hz (ih hy) |
| · intro y z hy hz |
| exact add_mem hy hz |
| lemma opposite_ker_nilpotent (hχ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥) : |
| ∃ n : ℕ, (RingHom.ker (oppositeAugmentation χ).toRingHom) ^ n = ⊥ := by |
| obtain ⟨n, hn⟩ := hχ |
| refine ⟨n, le_bot_iff.mp ?_⟩ |
| intro x hx |
| have h := unop_mem_pow_ker χ n hx |
| rw [hn] at h |
| exact MulOpposite.unop_injective h |
| end Opposite |
| end LittleFinitistic.SplitBasic |
|
|
| end |
| end |
|
|
| end OAI |
|
|
