From 5a869021189bd2a993aa2c8e9aa28dc10f5f9937 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Wed, 14 Jun 2023 22:10:22 -0700
Subject: [PATCH 01/23] changed

---
 CommAlg/final_hil_pol.lean | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/CommAlg/final_hil_pol.lean b/CommAlg/final_hil_pol.lean
index 591c6cc..7176de2 100644
--- a/CommAlg/final_hil_pol.lean
+++ b/CommAlg/final_hil_pol.lean
@@ -6,7 +6,6 @@ import Mathlib.RingTheory.Artinian
 import Mathlib.Order.Height
 
 
-
 -- Setting for "library_search"
 set_option maxHeartbeats 0
 macro "ls" : tactic => `(tactic|library_search)
@@ -44,7 +43,7 @@ noncomputable def length ( A : Type _) (M : Type _)
  [CommRing A] [AddCommGroup M] [Module A M] :=  Set.chainHeight {M' : Submodule A M | M' < ⊤}
 
 -- Make instance of M_i being an R_0-module
-instance tada1 (𝒜 : ℤ   → Type _) (𝓜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)]  [DirectSum.GCommRing 𝒜]
+instance tada1 (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)]  [DirectSum.GCommRing 𝒜]
   [DirectSum.Gmodule 𝒜 𝓜] (i : ℤ ) : SMul (𝒜 0) (𝓜 i)
     where smul x y := @Eq.rec ℤ (0+i) (fun a _ => 𝓜 a) (GradedMonoid.GSmul.smul x y) i (zero_add i)
 
@@ -110,7 +109,7 @@ instance {𝒜 : ℤ → Type _} [∀ i, AddCommGroup (𝒜 i)] [DirectSum.GComm
 
 
 
-class StandardGraded {𝒜 : ℤ → Type _} [∀ i, AddCommGroup (𝒜 i)] [DirectSum.GCommRing 𝒜] : Prop where
+class StandardGraded (𝒜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [DirectSum.GCommRing 𝒜] : Prop where
   gen_in_first_piece :
     Algebra.adjoin (𝒜 0) (DirectSum.of _ 1 : 𝒜 1 →+ ⨁ i, 𝒜 i).range = (⊤ : Subalgebra (𝒜 0) (⨁ i, 𝒜 i))
 
@@ -189,10 +188,11 @@ lemma Associated_prime_of_graded_is_graded
 -- If M is a finite graed R-Mod of dimension d ≥ 1, then the Hilbert function H(M, n) is of polynomial type (d - 1)
 theorem Hilbert_polynomial_d_ge_1 (d : ℕ) (d1 : 1 ≤ d) (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)]
 [DirectSum.GCommRing 𝒜]
-[DirectSum.Gmodule 𝒜 𝓜] (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0)) 
+[DirectSum.Gmodule 𝒜 𝓜] (st: StandardGraded 𝒜) (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0)) 
 (fingen : IsNoetherian (⨁ i, 𝒜 i) (⨁ i, 𝓜 i))
 (findim :  dimensionmodule (⨁ i, 𝒜 i) (⨁ i, 𝓜 i) = d)
 (hilb : ℤ → ℤ) (Hhilb: hilbert_function 𝒜 𝓜 hilb)
+
 : PolyType hilb (d - 1) := by
   sorry
 
@@ -203,7 +203,7 @@ theorem Hilbert_polynomial_d_ge_1_reduced
 (d : ℕ) (d1 : 1 ≤ d)
 (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)]
 [DirectSum.GCommRing 𝒜]
-[DirectSum.Gmodule 𝒜 𝓜] (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0))
+[DirectSum.Gmodule 𝒜 𝓜] (st: StandardGraded 𝒜) (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0))
 (fingen : IsNoetherian (⨁ i, 𝒜 i) (⨁ i, 𝓜 i))
 (findim :  dimensionmodule (⨁ i, 𝒜 i) (⨁ i, 𝓜 i) = d)
 (hilb : ℤ → ℤ) (Hhilb: hilbert_function 𝒜 𝓜 hilb)
@@ -217,7 +217,7 @@ theorem Hilbert_polynomial_d_ge_1_reduced
 -- If M is a finite graed R-Mod of dimension zero, then the Hilbert function H(M, n) = 0 for n >> 0 
 theorem Hilbert_polynomial_d_0 (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)]
 [DirectSum.GCommRing 𝒜]
-[DirectSum.Gmodule 𝒜 𝓜] (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0)) 
+[DirectSum.Gmodule 𝒜 𝓜] (st: StandardGraded 𝒜) (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0)) 
 (fingen : IsNoetherian (⨁ i, 𝒜 i) (⨁ i, 𝓜 i))
 (findim :  dimensionmodule (⨁ i, 𝒜 i) (⨁ i, 𝓜 i) = 0)
 (hilb : ℤ → ℤ) (Hhilb : hilbert_function 𝒜 𝓜 hilb)
@@ -230,7 +230,7 @@ theorem Hilbert_polynomial_d_0 (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) [
 theorem Hilbert_polynomial_d_0_reduced
 (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)]
 [DirectSum.GCommRing 𝒜]
-[DirectSum.Gmodule 𝒜 𝓜] (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0)) 
+[DirectSum.Gmodule 𝒜 𝓜] (st: StandardGraded 𝒜) (art: IsArtinianRing (𝒜 0)) (loc : LocalRing (𝒜 0)) 
 (fingen : IsNoetherian (⨁ i, 𝒜 i) (⨁ i, 𝓜 i))
 (findim :  dimensionmodule (⨁ i, 𝒜 i) (⨁ i, 𝓜 i) = 0)
 (hilb : ℤ → ℤ) (Hhilb : hilbert_function 𝒜 𝓜 hilb)
@@ -256,3 +256,4 @@ theorem Hilbert_polynomial_d_0_reduced
 
 
 
+

From 766c740c8d76d6a344713b92dcfa796a41183fbe Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Wed, 14 Jun 2023 23:35:46 -0700
Subject: [PATCH 02/23] Add graded_isom (with error)

---
 CommAlg/final_hil_pol.lean | 34 ++++++++++++++++++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/CommAlg/final_hil_pol.lean b/CommAlg/final_hil_pol.lean
index 7176de2..e3c141e 100644
--- a/CommAlg/final_hil_pol.lean
+++ b/CommAlg/final_hil_pol.lean
@@ -108,7 +108,6 @@ instance {𝒜 : ℤ → Type _} [∀ i, AddCommGroup (𝒜 i)] [DirectSum.GComm
     sorry)
 
 
-
 class StandardGraded (𝒜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [DirectSum.GCommRing 𝒜] : Prop where
   gen_in_first_piece :
     Algebra.adjoin (𝒜 0) (DirectSum.of _ 1 : 𝒜 1 →+ ⨁ i, 𝒜 i).range = (⊤ : Subalgebra (𝒜 0) (⨁ i, 𝒜 i))
@@ -123,7 +122,27 @@ def Component_of_graded_as_addsubgroup (𝒜 : ℤ → Type _)
 
 def graded_morphism (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) (𝓝 : ℤ → Type _)
 [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)] [∀ i, AddCommGroup (𝓝 i)]
-[DirectSum.GCommRing 𝒜] [DirectSum.Gmodule 𝒜 𝓜][DirectSum.Gmodule 𝒜 𝓝] (f : (⨁ i, 𝓜 i) → (⨁ i, 𝓝 i)) : ∀ i, ∀ (r : 𝓜 i), ∀ j, (j ≠ i → f (DirectSum.of _ i r) j = 0) ∧ (IsLinearMap (⨁ i, 𝒜 i) f) := by sorry
+[DirectSum.GCommRing 𝒜] [DirectSum.Gmodule 𝒜 𝓜][DirectSum.Gmodule 𝒜 𝓝]
+(f : (⨁ i, 𝓜 i) →ₗ[(⨁ i, 𝒜 i)] (⨁ i, 𝓝 i)) 
+: ∀ i, ∀ (r : 𝓜 i), ∀ j, (j ≠ i → f (DirectSum.of _ i r) j = 0) 
+∧ (IsLinearMap (⨁ i, 𝒜 i) f) := by
+  sorry
+
+#check graded_morphism
+
+def graded_isomorphism (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) (𝓝 : ℤ → Type _)
+[∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)] [∀ i, AddCommGroup (𝓝 i)]
+[DirectSum.GCommRing 𝒜] [DirectSum.Gmodule 𝒜 𝓜][DirectSum.Gmodule 𝒜 𝓝]
+(f : (⨁ i, 𝓜 i) →ₗ[(⨁ i, 𝒜 i)] (⨁ i, 𝓝 i))
+(hf : graded_morphism (fun i => (𝒜 i)) (fun i => (𝓜 i)) (fun i => (𝓝 i)) f)
+: (f : (⨁ i, 𝓜 i) ≃ₗ[(⨁ i, 𝒜 i)] (⨁ i, 𝓝 i)) := by
+  sorry
+
+
+-- (⊕ i, 𝒜 i) (⨁ i, 𝓜 i) (⊕ i, 𝓝 i)
+
+#check graded_isomorphism
+
 
 
 def graded_submodule
@@ -142,6 +161,7 @@ end
 
 
 
+
 -- @Quotient of a graded ring R by a graded ideal p is a graded R-Mod, preserving each component
 instance Quotient_of_graded_is_graded
 (𝒜 : ℤ → Type _) [∀ i, AddCommGroup (𝒜 i)] [DirectSum.GCommRing 𝒜]
@@ -149,6 +169,13 @@ instance Quotient_of_graded_is_graded
   : DirectSum.Gmodule 𝒜 (fun i => (𝒜 i)⧸(Component_of_graded_as_addsubgroup 𝒜 p hp i)) := by
   sorry
 
+-- 
+lemma sss
+  : true := by
+  sorry
+
+
+
 
 -- If A_0 is Artinian and local, then A is graded local
 lemma Graded_local_if_zero_component_Artinian_and_local (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) 
@@ -255,5 +282,8 @@ theorem Hilbert_polynomial_d_0_reduced
 
 
 
+
+
+
 
 

From 75cc002bef90567bf47193dde474eb7ebabadbd9 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 12:31:37 -0700
Subject: [PATCH 03/23] finished a case of polytype 0

---
 CommAlg/PolyTEST.lean      |  0
 CommAlg/final_hil_pol.lean | 12 ++++++------
 2 files changed, 6 insertions(+), 6 deletions(-)
 create mode 100644 CommAlg/PolyTEST.lean

diff --git a/CommAlg/PolyTEST.lean b/CommAlg/PolyTEST.lean
new file mode 100644
index 0000000..e69de29
diff --git a/CommAlg/final_hil_pol.lean b/CommAlg/final_hil_pol.lean
index e3c141e..eff9302 100644
--- a/CommAlg/final_hil_pol.lean
+++ b/CommAlg/final_hil_pol.lean
@@ -134,13 +134,11 @@ def graded_isomorphism (𝒜 : ℤ → Type _) (𝓜 : ℤ → Type _) (𝓝 : 
 [∀ i, AddCommGroup (𝒜 i)] [∀ i, AddCommGroup (𝓜 i)] [∀ i, AddCommGroup (𝓝 i)]
 [DirectSum.GCommRing 𝒜] [DirectSum.Gmodule 𝒜 𝓜][DirectSum.Gmodule 𝒜 𝓝]
 (f : (⨁ i, 𝓜 i) →ₗ[(⨁ i, 𝒜 i)] (⨁ i, 𝓝 i))
-(hf : graded_morphism (fun i => (𝒜 i)) (fun i => (𝓜 i)) (fun i => (𝓝 i)) f)
-: (f : (⨁ i, 𝓜 i) ≃ₗ[(⨁ i, 𝒜 i)] (⨁ i, 𝓝 i)) := by
+: IsLinearEquiv f := by
   sorry
-
-
--- (⊕ i, 𝒜 i) (⨁ i, 𝓜 i) (⊕ i, 𝓝 i)
-
+-- f ∈ (⨁ i, 𝓜 i) ≃ₗ[(⨁ i, 𝒜 i)] (⨁ i, 𝓝 i)
+-- LinearEquivClass f (⨁ i, 𝒜 i) (⨁ i, 𝓜 i) (⨁ i, 𝓝 i)
+-- #print IsLinearEquiv
 #check graded_isomorphism
 
 
@@ -284,6 +282,8 @@ theorem Hilbert_polynomial_d_0_reduced
 
 
 
+
+
 
 
 

From 41105f8623d584ea652f0b2c8d2ed0f59fd0d6b2 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 12:40:41 -0700
Subject: [PATCH 04/23] Rename the file

---
 CommAlg/PolyTEST.lean        |   0
 CommAlg/final_poly_type.lean | 325 +++++++++++++++++++++++++++++++++++
 2 files changed, 325 insertions(+)
 delete mode 100644 CommAlg/PolyTEST.lean
 create mode 100644 CommAlg/final_poly_type.lean

diff --git a/CommAlg/PolyTEST.lean b/CommAlg/PolyTEST.lean
deleted file mode 100644
index e69de29..0000000
diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
new file mode 100644
index 0000000..c62acf3
--- /dev/null
+++ b/CommAlg/final_poly_type.lean
@@ -0,0 +1,325 @@
+import Mathlib.Order.Height
+import Mathlib.AlgebraicGeometry.PrimeSpectrum.Basic
+
+-- Setting for "library_search"
+set_option maxHeartbeats 0
+macro "ls" : tactic => `(tactic|library_search)
+
+-- New tactic "obviously"
+macro "obviously" : tactic =>
+  `(tactic| (
+      first
+        | dsimp; simp; done; dbg_trace "it was dsimp simp"
+        | simp; done; dbg_trace "it was simp"
+        | tauto; done; dbg_trace "it was tauto"
+        | simp; tauto; done; dbg_trace "it was simp tauto"
+        | rfl; done; dbg_trace "it was rfl"
+        | norm_num; done; dbg_trace "it was norm_num"
+        | /-change (@Eq ℝ _ _);-/ linarith; done; dbg_trace "it was linarith"
+        -- | gcongr; done
+        | ring; done; dbg_trace "it was ring"
+        | trivial; done; dbg_trace "it was trivial"
+        -- | nlinarith; done
+        | fail "No, this is not obvious."))
+
+
+-- Testing of Polynomial
+section Polynomial
+noncomputable section
+#check Polynomial 
+#check Polynomial (ℚ)
+#check Polynomial.eval
+
+
+example (f : Polynomial ℚ) (hf : f = Polynomial.C (1 : ℚ)) : Polynomial.eval 2 f = 1 := by
+  have : ∀ (q : ℚ), Polynomial.eval q f = 1 := by
+    sorry
+  obviously
+
+-- example (f : ℤ → ℤ) (hf : ∀ x, f x = x ^ 2) : Polynomial.eval 2 f = 4 := by
+--   sorry
+
+-- degree of a constant function is ⊥ (is this same as -1 ???)
+#print Polynomial.degree_zero
+
+def F : Polynomial ℚ := Polynomial.C (2 : ℚ)
+#print F
+#check F
+#check Polynomial.degree F
+#check Polynomial.degree 0
+#check WithBot ℕ
+-- #eval Polynomial.degree F
+#check Polynomial.eval 1 F
+example : Polynomial.eval (100 : ℚ) F = (2 : ℚ) := by
+  refine Iff.mpr (Rat.ext_iff (Polynomial.eval 100 F) 2) ?_
+  simp only [Rat.ofNat_num, Rat.ofNat_den]
+  rw [F]
+  simp
+
+-- Treat polynomial f ∈ ℚ[X] as a function f : ℚ → ℚ
+#check CoeFun
+
+
+
+
+end section
+
+
+-- @[BH, 4.1.2]
+-- All the polynomials are in ℚ[X], all the functions are considered as ℤ → ℤ
+noncomputable section
+-- Polynomial type of degree d
+@[simp]
+def PolyType (f : ℤ → ℤ) (d : ℕ) := ∃ Poly : Polynomial ℚ, ∃ (N : ℤ), ∀ (n : ℤ), N ≤ n → f n = Polynomial.eval (n : ℚ) Poly ∧ d = Polynomial.degree Poly
+section
+-- structure PolyType (f : ℤ → ℤ) where
+--   Poly : Polynomial ℤ
+--   d : 
+--   N : ℤ
+--   Poly_equal : ∀ n ∈ ℤ → f n = Polynomial.eval n : ℤ Poly
+
+#check PolyType
+
+example (f : ℤ → ℤ) (hf : ∀ x, f x = x ^ 2) : PolyType f 2 := by
+  unfold PolyType
+  sorry
+  -- use Polynomial.monomial (2 : ℤ) (1 : ℤ)
+  -- have' := hf 0; ring_nf at this
+  -- exact this
+
+end section
+
+-- Δ operator (of d times)
+@[simp]
+def Δ : (ℤ → ℤ) → ℕ → (ℤ → ℤ)
+  | f, 0 => f
+  | f, d + 1 => fun (n : ℤ) ↦ (Δ f d) (n + 1) - (Δ f d) (n)  
+section
+-- def Δ (f : ℤ → ℤ) (d : ℕ) := fun (n : ℤ) ↦ f (n + 1) - f n
+-- def add' : ℕ → ℕ → ℕ
+--   | 0, m => m 
+--   | n+1, m => (add' n m) + 1
+-- #eval add' 5 10
+#check Δ
+def f (n : ℤ) := n
+#eval (Δ f 1) 100
+-- #check (by (show_term unfold Δ) : Δ f 0=0)
+end section
+
+
+-- (NO NEED TO PROVE) Constant polynomial function = constant function
+lemma Poly_constant (F : Polynomial ℚ) (c : ℚ) : 
+  (F = Polynomial.C c) ↔ (∀ r : ℚ, (Polynomial.eval r F) = c) := by
+  constructor
+  · intro h
+    rintro r
+    refine Iff.mpr (Rat.ext_iff (Polynomial.eval r F) c) ?_
+    simp only [Rat.ofNat_num, Rat.ofNat_den]
+    rw [h]
+    simp
+  · sorry
+
+
+
+
+-- Shifting doesn't change the polynomial type
+lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s : ℤ) (hfg : ∀ (n : ℤ), f (n + s) = g (n)) : PolyType g d := by
+  simp only [PolyType]
+  rcases hf with ⟨F, hh⟩
+  rcases hh with ⟨N,ss⟩
+  sorry
+
+
+
+
+-- set_option pp.all true in
+-- PolyType 0 = constant function
+lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = c) ∧ c ≠ 0) := by
+  constructor
+  · intro h
+    rcases h with ⟨Poly, hN⟩
+    rcases hN with ⟨N, hh⟩
+    have H1 := λ n hn => (hh n hn).left
+    have H2 := λ n hn => (hh n hn).right
+    clear hh
+    specialize H2 (N + 1)
+    have this1 : Polynomial.degree Poly = 0 := by
+      have : N ≤ N + 1 := by
+        norm_num
+      tauto
+    have this2 : ∃ (c : ℤ), Poly = Polynomial.C (c : ℚ) := by
+      have HH : ∃ (c : ℚ), Poly = Polynomial.C (c : ℚ) := by
+        use Poly.coeff 0
+        apply Polynomial.eq_C_of_degree_eq_zero
+        exact this1
+      cases' HH with c HHH
+      have HHHH : ∃ (d : ℤ), d = c := by
+        have H3 := (Poly_constant Poly c).mp HHH N
+        have H4 := H1 N (le_refl N)
+        rw[H3] at H4
+        exact ⟨f N, H4⟩
+      cases' HHHH with d H5
+      use d
+      rw [H5]
+      exact HHH
+    rcases this2 with ⟨c, hthis2⟩
+    use c 
+    use N
+    intro n
+    specialize H1 n
+    constructor
+    · intro HH1
+      -- have H6 := H1 HH1
+    --
+      have this3 : f n = Polynomial.eval (n : ℚ) Poly := by
+        tauto
+      have this4 : Polynomial.eval (n : ℚ) Poly = c := by
+        rw [hthis2]
+        simp
+      have this5 : f n = (c : ℚ) := by
+        rw [←this4, this3]
+      exact Iff.mp (Rat.coe_int_inj (f n) c) this5
+    --
+    
+    · intro c0
+      have H7 := H2 (by norm_num)
+      rw [hthis2] at this1
+      rw [c0] at this1
+      simp at this1
+    --   
+
+
+  · intro h
+    rcases h with ⟨c, N, aaa⟩
+    let (Poly : Polynomial ℚ) := Polynomial.C (c : ℚ)
+    use Poly
+    use N
+    intro n Nn
+    specialize aaa n
+    have this1 : c ≠ 0 →  f n = c := by
+      tauto
+    constructor
+    · sorry
+    · sorry
+      -- apply Polynomial.degree_C c
+
+
+
+
+
+
+-- Δ of 0 times preserve the function
+lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by
+  tauto
+
+-- Δ of d times maps polynomial of degree d to polynomial of degree 0
+lemma Δ_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := by
+  intro h
+  rcases h with ⟨Poly, hN⟩
+  rcases hN with ⟨N, hh⟩
+  have H1 := λ n hn => (hh n hn).left
+  have H2 := λ n hn => (hh n hn).right
+  clear hh
+  have HH2 : d = Polynomial.degree Poly := by
+    sorry
+  induction' d with d hd
+  · rw [PolyType_0]
+    sorry
+  · sorry
+
+
+
+
+-- [BH, 4.1.2] (a) => (b)
+-- Δ^d f (n) = c for some nonzero integer c for n >> 0 → f is of polynomial type d
+lemma a_to_b (f : ℤ → ℤ) (d : ℕ) : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0)) → PolyType f d := by
+  intro h
+  rcases h with ⟨c, N, hh⟩
+  have H1 := λ n => (hh n).left
+  have H2 := λ n => (hh n).right
+  clear hh
+  have H2 : c ≠ 0 := by
+    tauto
+  induction' d with d hd
+  · rw [PolyType_0]
+    use c
+    use N
+    tauto
+  · sorry
+
+-- [BH, 4.1.2] (a) <= (b)
+-- f is of polynomial type d → Δ^d f (n) = c for some nonzero integer c for n >> 0
+lemma b_to_a (f : ℤ → ℤ) (d : ℕ) : PolyType f d → (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0)) := by
+  intro h
+  have : PolyType (Δ f d) 0 := by
+    apply Δ_PolyType_d_to_PolyType_0
+    exact h
+  have this1 : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) n = c) ∧ c ≠ 0)) := by
+    rw [←PolyType_0]
+    exact this
+  exact this1
+end
+
+
+
+
+
+-- @Additive lemma of length for a SES
+-- Given a SES 0 → A → B → C → 0, then length (A) - length (B) + length (C) = 0 
+section
+-- variable {R M N : Type _} [CommRing R] [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N]
+--   (f : M →[R] N)
+open LinearMap
+-- variable {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M]
+-- noncomputable def length := Set.chainHeight {M' : Submodule R M | M' < ⊤}
+
+
+-- Definitiion of the length of a module
+noncomputable def length (R M : Type _) [CommRing R] [AddCommGroup M] [Module R M] := Set.chainHeight {M' : Submodule R M | M' < ⊤}
+#check length ℤ ℤ
+-- #eval length ℤ ℤ
+
+
+-- @[ext]
+-- structure SES (R : Type _) [CommRing R] where
+--   A : Type _
+--   B : Type _
+--   C : Type _
+--   f : A →ₗ[R] B
+--   g : B →ₗ[R] C
+-- left_exact : LinearMap.ker f = 0
+-- middle_exact : LinearMap.range f = LinearMap.ker g
+-- right_exact : LinearMap.range g = C
+
+
+
+-- Definition of a SES (Short Exact Sequence)
+-- @[ext]
+structure SES {R A B C : Type _} [CommRing R] [AddCommGroup A] [AddCommGroup B]
+  [AddCommGroup C] [Module R A] [Module R B] [Module R C] 
+  (f : A →ₗ[R] B) (g : B →ₗ[R] C)
+  where
+  left_exact : LinearMap.ker f = ⊥
+  middle_exact : LinearMap.range f = LinearMap.ker g
+  right_exact : LinearMap.range g = ⊤
+
+#check SES.right_exact
+#check SES
+
+
+-- Additive lemma
+lemma length_Additive (R A B C : Type _) [CommRing R] [AddCommGroup A] [AddCommGroup B] [AddCommGroup C] [Module R A] [Module R B] [Module R C] 
+  (f : A →ₗ[R] B) (g : B →ₗ[R] C)
+  : (SES f g) → ((length R A) + (length R C) = (length R B)) := by
+  intro h
+  rcases h with ⟨left_exact, middle_exact, right_exact⟩
+  sorry
+
+end section
+
+
+
+
+
+
+

From 61a7ae54bfee1c5176466078d59487bb8ef66c33 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 13:31:48 -0700
Subject: [PATCH 05/23] change PolyType

---
 CommAlg/final_poly_type.lean | 51 +++++++++++++++++++++++++++---------
 1 file changed, 39 insertions(+), 12 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index c62acf3..94dd153 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -70,7 +70,7 @@ end section
 noncomputable section
 -- Polynomial type of degree d
 @[simp]
-def PolyType (f : ℤ → ℤ) (d : ℕ) := ∃ Poly : Polynomial ℚ, ∃ (N : ℤ), ∀ (n : ℤ), N ≤ n → f n = Polynomial.eval (n : ℚ) Poly ∧ d = Polynomial.degree Poly
+def PolyType (f : ℤ → ℤ) (d : ℕ) := ∃ Poly : Polynomial ℚ, ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = Polynomial.eval (n : ℚ) Poly) ∧ d = Polynomial.degree Poly
 section
 -- structure PolyType (f : ℤ → ℤ) where
 --   Poly : Polynomial ℤ
@@ -109,7 +109,7 @@ end section
 
 -- (NO NEED TO PROVE) Constant polynomial function = constant function
 lemma Poly_constant (F : Polynomial ℚ) (c : ℚ) : 
-  (F = Polynomial.C c) ↔ (∀ r : ℚ, (Polynomial.eval r F) = c) := by
+  (F = Polynomial.C (c : ℚ)) ↔ (∀ r : ℚ, (Polynomial.eval r F) = (c : ℚ)) := by
   constructor
   · intro h
     rintro r
@@ -134,13 +134,13 @@ lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s :
 
 -- set_option pp.all true in
 -- PolyType 0 = constant function
-lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = c) ∧ c ≠ 0) := by
+lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = c) ∧ (c ≠ 0)) := by
   constructor
   · intro h
     rcases h with ⟨Poly, hN⟩
     rcases hN with ⟨N, hh⟩
-    have H1 := λ n hn => (hh n hn).left
-    have H2 := λ n hn => (hh n hn).right
+    have H1 := λ n=> (hh n).left
+    have H2 := λ n=> (hh n).right
     clear hh
     specialize H2 (N + 1)
     have this1 : Polynomial.degree Poly = 0 := by
@@ -182,11 +182,10 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
     --
     
     · intro c0
-      have H7 := H2 (by norm_num)
+      -- have H7 := H2 (by norm_num)
       rw [hthis2] at this1
       rw [c0] at this1
       simp at this1
-    --   
 
 
   · intro h
@@ -194,17 +193,45 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
     let (Poly : Polynomial ℚ) := Polynomial.C (c : ℚ)
     use Poly
     use N
-    intro n Nn
+    intro n
     specialize aaa n
     have this1 : c ≠ 0 →  f n = c := by
       tauto
+    rcases aaa with ⟨A, B⟩
+    have this1 : f n = c := by
+      tauto
     constructor
-    · sorry
-    · sorry
+    clear A
+    · have this2 : ∀ (t : ℚ), (Polynomial.eval t Poly) = (c : ℚ) := by
+        rw [← Poly_constant Poly (c : ℚ)]
+        sorry
+      specialize this2 n
+      rw [this2]
+      tauto
+    · sorry 
       -- apply Polynomial.degree_C c
 
 
 
+    -- constructor
+    -- · intro n Nn
+    --   specialize aaa n
+    --   have this1 : c ≠ 0 →  f n = c := by
+    --     tauto
+    --   rcases aaa with ⟨A, B⟩
+    --   have this1 : f n = c := by
+    --     tauto
+    --   clear A
+    --   have this2 : ∀ (t : ℚ), (Polynomial.eval t Poly) = (c : ℚ) := by
+    --     rw [← Poly_constant Poly (c : ℚ)]
+    --     sorry
+    --   specialize this2 n
+    --   rw [this2]
+    --   tauto
+    -- · sorry
+
+
+
 
 
 
@@ -217,8 +244,8 @@ lemma Δ_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d →
   intro h
   rcases h with ⟨Poly, hN⟩
   rcases hN with ⟨N, hh⟩
-  have H1 := λ n hn => (hh n hn).left
-  have H2 := λ n hn => (hh n hn).right
+  have H1 := λ n => (hh n).left
+  have H2 := λ n => (hh n).right
   clear hh
   have HH2 : d = Polynomial.degree Poly := by
     sorry

From 007e8cf7950442d3fa16cd151eba2e1def637c93 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 15:10:30 -0700
Subject: [PATCH 06/23] finish more on the PolyType_0 lemma

---
 CommAlg/final_poly_type.lean | 74 ++++++++++++++++++++++--------------
 1 file changed, 45 insertions(+), 29 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 94dd153..ebd6043 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -70,7 +70,7 @@ end section
 noncomputable section
 -- Polynomial type of degree d
 @[simp]
-def PolyType (f : ℤ → ℤ) (d : ℕ) := ∃ Poly : Polynomial ℚ, ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = Polynomial.eval (n : ℚ) Poly) ∧ d = Polynomial.degree Poly
+def PolyType (f : ℤ → ℤ) (d : ℕ) := ∃ Poly : Polynomial ℚ, ∃ (N : ℤ), (∀ (n : ℤ), N ≤ n → f n = Polynomial.eval (n : ℚ) Poly) ∧ d = Polynomial.degree Poly
 section
 -- structure PolyType (f : ℤ → ℤ) where
 --   Poly : Polynomial ℤ
@@ -107,7 +107,7 @@ def f (n : ℤ) := n
 end section
 
 
--- (NO NEED TO PROVE) Constant polynomial function = constant function
+-- (NO need to prove another direction) Constant polynomial function = constant function
 lemma Poly_constant (F : Polynomial ℚ) (c : ℚ) : 
   (F = Polynomial.C (c : ℚ)) ↔ (∀ r : ℚ, (Polynomial.eval r F) = (c : ℚ)) := by
   constructor
@@ -132,6 +132,8 @@ lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s :
 
 
 
+
+
 -- set_option pp.all true in
 -- PolyType 0 = constant function
 lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = c) ∧ (c ≠ 0)) := by
@@ -139,10 +141,9 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
   · intro h
     rcases h with ⟨Poly, hN⟩
     rcases hN with ⟨N, hh⟩
-    have H1 := λ n=> (hh n).left
-    have H2 := λ n=> (hh n).right
-    clear hh
-    specialize H2 (N + 1)
+    rcases hh with ⟨H1, H2⟩
+    -- have H1 := λ n=> (hh n).left
+    -- have H2 := λ n=> (hh n).right
     have this1 : Polynomial.degree Poly = 0 := by
       have : N ≤ N + 1 := by
         norm_num
@@ -170,7 +171,6 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
     constructor
     · intro HH1
       -- have H6 := H1 HH1
-    --
       have this3 : f n = Polynomial.eval (n : ℚ) Poly := by
         tauto
       have this4 : Polynomial.eval (n : ℚ) Poly = c := by
@@ -179,7 +179,6 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
       have this5 : f n = (c : ℚ) := by
         rw [←this4, this3]
       exact Iff.mp (Rat.coe_int_inj (f n) c) this5
-    --
     
     · intro c0
       -- have H7 := H2 (by norm_num)
@@ -189,27 +188,46 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
 
 
   · intro h
-    rcases h with ⟨c, N, aaa⟩
-    let (Poly : Polynomial ℚ) := Polynomial.C (c : ℚ)
+    rcases h with ⟨c, N, hh⟩
+    let Poly := Polynomial.C (c : ℚ)
+    --unfold PolyType
     use Poly
+    --simp at Poly
     use N
-    intro n
-    specialize aaa n
-    have this1 : c ≠ 0 →  f n = c := by
-      tauto
-    rcases aaa with ⟨A, B⟩
-    have this1 : f n = c := by
-      tauto
+    have H1 := λ n=> (hh n).left
+    have H22 := λ n=> (hh n).right
+    have H2 : c ≠ 0 := by
+      exact H22 0
+    clear H22
     constructor
-    clear A
-    · have this2 : ∀ (t : ℚ), (Polynomial.eval t Poly) = (c : ℚ) := by
-        rw [← Poly_constant Poly (c : ℚ)]
-        sorry
-      specialize this2 n
-      rw [this2]
-      tauto
-    · sorry 
-      -- apply Polynomial.degree_C c
+    · intro n Nn
+      specialize H1 n
+      have this : f n = c := by
+        tauto
+      rw [this]
+      have this2 : Polynomial.eval (n : ℚ) Poly = (c : ℚ) := by
+        have this3 : ∀ r : ℚ, (Polynomial.eval r Poly) = (c : ℚ) :=  (Poly_constant Poly (c : ℚ)).mp rfl
+        exact this3 n
+      exact this2.symm
+    
+
+    · sorry
+    -- intro n
+    -- specialize aaa n
+    -- have this1 : c ≠ 0 →  f n = c := by
+    --   sorry
+    -- rcases aaa with ⟨A, B⟩
+    -- have this1 : f n = c := by
+    --   tauto
+    -- constructor
+    -- clear A
+    -- · have this2 : ∀ (t : ℚ), (Polynomial.eval t Poly) = (c : ℚ) := by
+    --     rw [← Poly_constant Poly (c : ℚ)]
+    --     sorry
+    --   specialize this2 n
+    --   rw [this2]
+    --   tauto
+    -- · sorry
 
 
 
@@ -244,9 +262,7 @@ lemma Δ_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d →
   intro h
   rcases h with ⟨Poly, hN⟩
   rcases hN with ⟨N, hh⟩
-  have H1 := λ n => (hh n).left
-  have H2 := λ n => (hh n).right
-  clear hh
+  rcases hh with ⟨H1, H2⟩
   have HH2 : d = Polynomial.degree Poly := by
     sorry
   induction' d with d hd

From 300007621a41a50bb0d75eef3034a2378a9af6d1 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 15:38:25 -0700
Subject: [PATCH 07/23] Finish the PolyType_0 lemma!

---
 CommAlg/final_poly_type.lean | 44 ++++++------------------------------
 1 file changed, 7 insertions(+), 37 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index ebd6043..60df0d4 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -198,6 +198,8 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
     have H22 := λ n=> (hh n).right
     have H2 : c ≠ 0 := by
       exact H22 0
+    have H2 : (c : ℚ) ≠ 0 := by
+      simp; tauto
     clear H22
     constructor
     · intro n Nn
@@ -206,47 +208,15 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
         tauto
       rw [this]
       have this2 : Polynomial.eval (n : ℚ) Poly = (c : ℚ) := by
-        have this3 : ∀ r : ℚ, (Polynomial.eval r Poly) = (c : ℚ) :=  (Poly_constant Poly (c : ℚ)).mp rfl
+        have this3 : ∀ r : ℚ, (Polynomial.eval r Poly) = (c : ℚ) := (Poly_constant Poly (c : ℚ)).mp rfl
         exact this3 n
       exact this2.symm
     
 
-    · sorry
-    -- intro n
-    -- specialize aaa n
-    -- have this1 : c ≠ 0 →  f n = c := by
-    --   sorry
-    -- rcases aaa with ⟨A, B⟩
-    -- have this1 : f n = c := by
-    --   tauto
-    -- constructor
-    -- clear A
-    -- · have this2 : ∀ (t : ℚ), (Polynomial.eval t Poly) = (c : ℚ) := by
-    --     rw [← Poly_constant Poly (c : ℚ)]
-    --     sorry
-    --   specialize this2 n
-    --   rw [this2]
-    --   tauto
-    -- · sorry
-
-
-
-    -- constructor
-    -- · intro n Nn
-    --   specialize aaa n
-    --   have this1 : c ≠ 0 →  f n = c := by
-    --     tauto
-    --   rcases aaa with ⟨A, B⟩
-    --   have this1 : f n = c := by
-    --     tauto
-    --   clear A
-    --   have this2 : ∀ (t : ℚ), (Polynomial.eval t Poly) = (c : ℚ) := by
-    --     rw [← Poly_constant Poly (c : ℚ)]
-    --     sorry
-    --   specialize this2 n
-    --   rw [this2]
-    --   tauto
-    -- · sorry
+    · have this : Polynomial.degree Poly = 0 := by
+        simp only [map_intCast]
+        exact Polynomial.degree_C H2
+      tauto
 
 
 

From d5b2e4d431c4edf47b7e01e3317281e5122b64e8 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 17:51:32 -0700
Subject: [PATCH 08/23] Part of the base case of \Delta lemma

---
 CommAlg/final_poly_type.lean | 60 +++++++++++++++++++++++++++++++-----
 1 file changed, 52 insertions(+), 8 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 60df0d4..403e14e 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -65,7 +65,13 @@ example : Polynomial.eval (100 : ℚ) F = (2 : ℚ) := by
 end section
 
 
+
+
+
 -- @[BH, 4.1.2]
+
+
+
 -- All the polynomials are in ℚ[X], all the functions are considered as ℤ → ℤ
 noncomputable section
 -- Polynomial type of degree d
@@ -107,6 +113,10 @@ def f (n : ℤ) := n
 end section
 
 
+
+
+
+
 -- (NO need to prove another direction) Constant polynomial function = constant function
 lemma Poly_constant (F : Polynomial ℚ) (c : ℚ) : 
   (F = Polynomial.C (c : ℚ)) ↔ (∀ r : ℚ, (Polynomial.eval r F) = (c : ℚ)) := by
@@ -133,7 +143,6 @@ lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s :
 
 
 
-
 -- set_option pp.all true in
 -- PolyType 0 = constant function
 lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = c) ∧ (c ≠ 0)) := by
@@ -211,7 +220,6 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
         have this3 : ∀ r : ℚ, (Polynomial.eval r Poly) = (c : ℚ) := (Poly_constant Poly (c : ℚ)).mp rfl
         exact this3 n
       exact this2.symm
-    
 
     · have this : Polynomial.degree Poly = 0 := by
         simp only [map_intCast]
@@ -221,23 +229,54 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
 
 
 
-
-
 -- Δ of 0 times preserve the function
 lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by
   tauto
 
+
+
+
+
 -- Δ of d times maps polynomial of degree d to polynomial of degree 0
-lemma Δ_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := by
+lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := by
   intro h
   rcases h with ⟨Poly, hN⟩
   rcases hN with ⟨N, hh⟩
   rcases hh with ⟨H1, H2⟩
   have HH2 : d = Polynomial.degree Poly := by
-    sorry
+    tauto
+  have HH3 : Polynomial.degree Poly = d := by
+    tauto
   induction' d with d hd
+  -- Base case
   · rw [PolyType_0]
-    sorry
+    have this : Poly = Polynomial.C (Polynomial.coeff Poly 0) := by
+      exact Polynomial.eq_C_of_degree_eq_zero HH3
+    let d := Polynomial.coeff Poly 0
+    have this11 : ∃ (c : ℤ), c = d := by
+      sorry
+    rcases this11 with ⟨c, this1⟩
+    have this1 : c = Polynomial.coeff Poly 0 := by
+      tauto
+    use c; use N; intro n
+    constructor
+    · specialize H1 n
+      rw [Δ_0]
+      intro h
+      have this2 : f n = Polynomial.eval (n : ℚ) Poly := by
+        tauto
+      have this3 : f n = (c : ℚ) := by
+        rw [this2, this1]
+        let HHH := (Poly_constant Poly c).mp
+        sorry
+      exact Iff.mp (Rat.coe_int_inj (f n) c) this3
+    · intro c0
+      have this2 : (c : ℚ) = 0 := by
+        exact congrArg Int.cast c0
+      have this3 : Polynomial.coeff Poly 0 = 0 := by
+        rw [←this1, this2]
+      sorry
+  -- Induction step
   · sorry
 
 
@@ -260,12 +299,14 @@ lemma a_to_b (f : ℤ → ℤ) (d : ℕ) : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n
     tauto
   · sorry
 
+
+
 -- [BH, 4.1.2] (a) <= (b)
 -- f is of polynomial type d → Δ^d f (n) = c for some nonzero integer c for n >> 0
 lemma b_to_a (f : ℤ → ℤ) (d : ℕ) : PolyType f d → (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0)) := by
   intro h
   have : PolyType (Δ f d) 0 := by
-    apply Δ_PolyType_d_to_PolyType_0
+    apply Δ_d_PolyType_d_to_PolyType_0
     exact h
   have this1 : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) n = c) ∧ c ≠ 0)) := by
     rw [←PolyType_0]
@@ -277,6 +318,9 @@ end
 
 
 
+
+
+
 -- @Additive lemma of length for a SES
 -- Given a SES 0 → A → B → C → 0, then length (A) - length (B) + length (C) = 0 
 section

From b8928c8d90964e6d996746a2df3bc7c0e4ab6dfc Mon Sep 17 00:00:00 2001
From: Andre <espietandre@gmail.com>
Date: Thu, 15 Jun 2023 22:09:13 -0400
Subject: [PATCH 09/23] refactored PolyType_0

---
 CommAlg/final_poly_type.lean | 97 ++++++------------------------------
 1 file changed, 16 insertions(+), 81 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 60df0d4..aca056a 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -136,92 +136,27 @@ lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s :
 
 -- set_option pp.all true in
 -- PolyType 0 = constant function
-lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), (N ≤ n → f n = c) ∧ (c ≠ 0)) := by
+lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), 
+    (N ≤ n → f n = c) ∧ c ≠ 0) := by
   constructor
-  · intro h
-    rcases h with ⟨Poly, hN⟩
-    rcases hN with ⟨N, hh⟩
-    rcases hh with ⟨H1, H2⟩
-    -- have H1 := λ n=> (hh n).left
-    -- have H2 := λ n=> (hh n).right
-    have this1 : Polynomial.degree Poly = 0 := by
-      have : N ≤ N + 1 := by
-        norm_num
-      tauto
+  · rintro ⟨Poly, ⟨N, ⟨H1, H2⟩⟩⟩ 
+    have this1 : Polynomial.degree Poly = 0 := by rw [← H2]; rfl
     have this2 : ∃ (c : ℤ), Poly = Polynomial.C (c : ℚ) := by
-      have HH : ∃ (c : ℚ), Poly = Polynomial.C (c : ℚ) := by
-        use Poly.coeff 0
-        apply Polynomial.eq_C_of_degree_eq_zero
-        exact this1
+      have HH : ∃ (c : ℚ), Poly = Polynomial.C (c : ℚ) := ⟨Poly.coeff 0, Polynomial.eq_C_of_degree_eq_zero (by rw[← H2]; rfl)⟩
       cases' HH with c HHH
-      have HHHH : ∃ (d : ℤ), d = c := by
-        have H3 := (Poly_constant Poly c).mp HHH N
-        have H4 := H1 N (le_refl N)
-        rw[H3] at H4
-        exact ⟨f N, H4⟩
-      cases' HHHH with d H5
-      use d
-      rw [H5]
-      exact HHH
-    rcases this2 with ⟨c, hthis2⟩
-    use c 
-    use N
-    intro n
-    specialize H1 n
+      have HHHH : ∃ (d : ℤ), d = c := ⟨f N, by simp [(Poly_constant Poly c).mp HHH N, H1 N (le_refl N)]⟩
+      cases' HHHH with d H5; exact ⟨d, by rw[← H5] at HHH; exact HHH⟩
+    rcases this2 with ⟨c, hthis2⟩ 
+    use c; use N; intro n
     constructor
-    · intro HH1
-      -- have H6 := H1 HH1
-      have this3 : f n = Polynomial.eval (n : ℚ) Poly := by
-        tauto
-      have this4 : Polynomial.eval (n : ℚ) Poly = c := by
-        rw [hthis2]
-        simp
-      have this5 : f n = (c : ℚ) := by
-        rw [←this4, this3]
-      exact Iff.mp (Rat.coe_int_inj (f n) c) this5
-    
+    · have this4 : Polynomial.eval (n : ℚ) Poly = c := by
+        rw [hthis2]; simp only [map_intCast, Polynomial.eval_int_cast]
+      exact fun HH1 => Iff.mp (Rat.coe_int_inj (f n) c) (by rw [←this4, H1 n HH1])
     · intro c0
-      -- have H7 := H2 (by norm_num)
-      rw [hthis2] at this1
-      rw [c0] at this1
-      simp at this1
-
-
-  · intro h
-    rcases h with ⟨c, N, hh⟩
-    let Poly := Polynomial.C (c : ℚ)
-    --unfold PolyType
-    use Poly
-    --simp at Poly
-    use N
-    have H1 := λ n=> (hh n).left
-    have H22 := λ n=> (hh n).right
-    have H2 : c ≠ 0 := by
-      exact H22 0
-    have H2 : (c : ℚ) ≠ 0 := by
-      simp; tauto
-    clear H22
-    constructor
-    · intro n Nn
-      specialize H1 n
-      have this : f n = c := by
-        tauto
-      rw [this]
-      have this2 : Polynomial.eval (n : ℚ) Poly = (c : ℚ) := by
-        have this3 : ∀ r : ℚ, (Polynomial.eval r Poly) = (c : ℚ) := (Poly_constant Poly (c : ℚ)).mp rfl
-        exact this3 n
-      exact this2.symm
-    
-
-    · have this : Polynomial.degree Poly = 0 := by
-        simp only [map_intCast]
-        exact Polynomial.degree_C H2
-      tauto
-
-
-
-
-
+      simp only [hthis2, c0, Int.cast_zero, map_zero, Polynomial.degree_zero] at this1
+  · rintro ⟨c, N, hh⟩
+    have H2 : (c : ℚ) ≠ 0 := by simp only [ne_eq, Int.cast_eq_zero]; exact (hh 0).2
+    exact ⟨Polynomial.C (c : ℚ), N, fun n Nn => by rw [(hh n).1 Nn]; exact (((Poly_constant (Polynomial.C (c : ℚ)) (c : ℚ)).mp rfl) n).symm, by rw [Polynomial.degree_C H2]; rfl⟩
 
 -- Δ of 0 times preserve the function
 lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by

From 31210a9bf5f2fece27ba9c7c829cd1688bdc3327 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 20:27:29 -0700
Subject: [PATCH 10/23] add foo and foofoo

---
 CommAlg/final_poly_type.lean | 79 +++++++++++++++++-------------------
 1 file changed, 38 insertions(+), 41 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 403e14e..3669cb6 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -229,55 +229,49 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
 
 
 
--- Δ of 0 times preserve the function
-lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by
-  tauto
+-- Δ of 0 times preserves the function
+lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by tauto
+
+-- Δ of 1 times decreaes the polynomial type by one
+lemma Δ_1 (f : ℤ → ℤ) (d : ℕ): d > 0 → PolyType f d → PolyType (Δ f 1) (d - 1) := by
+  sorry
+
+
+lemma foo (f : ℤ → ℤ) (s : ℕ) : Δ (Δ f 1) s = (Δ f (s + 1)) := by
+  sorry
 
 
 
 
 
 -- Δ of d times maps polynomial of degree d to polynomial of degree 0
+lemma foofoo (d : ℕ) : (f : ℤ → ℤ) → (PolyType f d) → (PolyType (Δ f d) 0):= by
+  induction' d with d hd
+  · intro f h
+    rw [Δ_0]
+    tauto
+  · intro f hf
+    have this1 : PolyType f (d + 1) := by tauto
+    have this2 : PolyType (Δ f (d + 1)) 0 := by
+      have this3 : PolyType (Δ f 1) d := by
+        sorry
+      clear hf
+      specialize hd (Δ f 1)
+      have this4 : PolyType (Δ (Δ f 1) d) 0 := by tauto
+      rw [foo] at this4
+      tauto
+    tauto
+
+
+
 lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := by
   intro h
-  rcases h with ⟨Poly, hN⟩
-  rcases hN with ⟨N, hh⟩
-  rcases hh with ⟨H1, H2⟩
-  have HH2 : d = Polynomial.degree Poly := by
-    tauto
-  have HH3 : Polynomial.degree Poly = d := by
-    tauto
-  induction' d with d hd
-  -- Base case
-  · rw [PolyType_0]
-    have this : Poly = Polynomial.C (Polynomial.coeff Poly 0) := by
-      exact Polynomial.eq_C_of_degree_eq_zero HH3
-    let d := Polynomial.coeff Poly 0
-    have this11 : ∃ (c : ℤ), c = d := by
-      sorry
-    rcases this11 with ⟨c, this1⟩
-    have this1 : c = Polynomial.coeff Poly 0 := by
-      tauto
-    use c; use N; intro n
-    constructor
-    · specialize H1 n
-      rw [Δ_0]
-      intro h
-      have this2 : f n = Polynomial.eval (n : ℚ) Poly := by
-        tauto
-      have this3 : f n = (c : ℚ) := by
-        rw [this2, this1]
-        let HHH := (Poly_constant Poly c).mp
-        sorry
-      exact Iff.mp (Rat.coe_int_inj (f n) c) this3
-    · intro c0
-      have this2 : (c : ℚ) = 0 := by
-        exact congrArg Int.cast c0
-      have this3 : Polynomial.coeff Poly 0 = 0 := by
-        rw [←this1, this2]
-      sorry
-  -- Induction step
-  · sorry
+  have this : ∀ (d : ℕ), ∀ (f :ℤ → ℤ), (PolyType f d) → (PolyType (Δ f d) 0) := by 
+    exact foofoo
+  specialize this d f
+  tauto
+
+
 
 
 
@@ -293,10 +287,13 @@ lemma a_to_b (f : ℤ → ℤ) (d : ℕ) : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n
   have H2 : c ≠ 0 := by
     tauto
   induction' d with d hd
+  -- Base case
   · rw [PolyType_0]
     use c
     use N
     tauto
+
+  -- Induction step
   · sorry
 
 

From a3c376de01fc08b5a1dc3eebc8ff579e42302ff7 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 20:28:30 -0700
Subject: [PATCH 11/23] merge two files

---
 CommAlg/final_poly_type.lean | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 3fc34d7..96a3aca 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -167,14 +167,21 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
     have H2 : (c : ℚ) ≠ 0 := by simp only [ne_eq, Int.cast_eq_zero]; exact (hh 0).2
     exact ⟨Polynomial.C (c : ℚ), N, fun n Nn => by rw [(hh n).1 Nn]; exact (((Poly_constant (Polynomial.C (c : ℚ)) (c : ℚ)).mp rfl) n).symm, by rw [Polynomial.degree_C H2]; rfl⟩
 
+
+
+
 -- Δ of 0 times preserves the function
 lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by tauto
 
+
+
 -- Δ of 1 times decreaes the polynomial type by one
 lemma Δ_1 (f : ℤ → ℤ) (d : ℕ): d > 0 → PolyType f d → PolyType (Δ f 1) (d - 1) := by
   sorry
 
 
+
+
 lemma foo (f : ℤ → ℤ) (s : ℕ) : Δ (Δ f 1) s = (Δ f (s + 1)) := by
   sorry
 

From 01f628cf986c8bdc6d9a13592c888408278f1246 Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 20:43:52 -0700
Subject: [PATCH 12/23] kind of finish \Delta of d times lemma

---
 CommAlg/final_poly_type.lean | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 96a3aca..4405e42 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -199,7 +199,9 @@ lemma foofoo (d : ℕ) : (f : ℤ → ℤ) → (PolyType f d) → (PolyType (Δ
     have this1 : PolyType f (d + 1) := by tauto
     have this2 : PolyType (Δ f (d + 1)) 0 := by
       have this3 : PolyType (Δ f 1) d := by
-        sorry
+        have this4 : d + 1 > 0 := by positivity
+        have this5 : (d + 1) > 0 → PolyType f (d + 1) → PolyType (Δ f 1) d := Δ_1 f (d + 1)
+        exact this5 this4 this1
       clear hf
       specialize hd (Δ f 1)
       have this4 : PolyType (Δ (Δ f 1) d) 0 := by tauto

From 37d8991879f5fdccad630a28fe4282d042d12261 Mon Sep 17 00:00:00 2001
From: poincare-duality <jidongw@uoregon.edu>
Date: Thu, 15 Jun 2023 20:45:29 -0700
Subject: [PATCH 13/23] proved one direction

---
 CommAlg/jayden(krull-dim-zero).lean | 140 ++++++++++++++++++++++------
 1 file changed, 109 insertions(+), 31 deletions(-)

diff --git a/CommAlg/jayden(krull-dim-zero).lean b/CommAlg/jayden(krull-dim-zero).lean
index f75912a..78bd648 100644
--- a/CommAlg/jayden(krull-dim-zero).lean
+++ b/CommAlg/jayden(krull-dim-zero).lean
@@ -16,6 +16,7 @@ import Mathlib.Order.ConditionallyCompleteLattice.Basic
 import Mathlib.Algebra.Ring.Pi
 import Mathlib.RingTheory.Finiteness
 import Mathlib.Util.PiNotation
+import CommAlg.krull
 
 open PiNotation
 
@@ -23,10 +24,10 @@ namespace Ideal
 
 variable (R : Type _) [CommRing R] (P : PrimeSpectrum R)
 
-noncomputable def height : ℕ∞ := Set.chainHeight {J : PrimeSpectrum R | J < P}
+-- noncomputable def height : ℕ∞ := Set.chainHeight {J : PrimeSpectrum R | J < P}
 
-noncomputable def krullDim (R : Type) [CommRing R] :
-     WithBot ℕ∞ := ⨆ (I : PrimeSpectrum R), height R I
+-- noncomputable def krullDim (R : Type) [CommRing R] :
+--      WithBot ℕ∞ := ⨆ (I : PrimeSpectrum R), height R I
 
 --variable {R}
 
@@ -66,6 +67,8 @@ lemma ring_Noetherian_iff_spec_Noetherian : IsNoetherianRing R
     ↔ TopologicalSpace.NoetherianSpace (PrimeSpectrum R) := by
     constructor
     intro RisNoetherian
+    sorry
+    sorry
     -- how do I apply an instance to prove one direction?
 
 
@@ -99,9 +102,9 @@ lemma containment_radical_power_containment :
 
 -- Stacks Lemma 10.52.6: I is a maximal ideal and IM = 0. Then length of M is
 -- the same as the dimension as a vector space over R/I,
-lemma length_eq_dim_if_maximal_annihilates {I : Ideal R} [Ideal.IsMaximal I] 
-    : I • (⊤ : Submodule R M) = 0
-     → Module.length R M = Module.rank R⧸I M⧸(I • (⊤ : Submodule R M)) := by sorry
+-- lemma length_eq_dim_if_maximal_annihilates {I : Ideal R} [Ideal.IsMaximal I] 
+--     : I • (⊤ : Submodule R M) = 0
+--      → Module.length R M = Module.rank R⧸I M⧸(I • (⊤ : Submodule R M)) := by sorry
 
 -- Does lean know that M/IM is a R/I module?
 -- Use 10.52.5
@@ -125,30 +128,34 @@ lemma Artinian_has_finite_max_ideal
     let m' : ℕ ↪ MaximalSpectrum R := Infinite.natEmbedding (MaximalSpectrum R)
     have m'inj := m'.injective
     let m'' : ℕ → Ideal R := fun n : ℕ ↦ ⨅ k ∈ range n, (m' k).asIdeal
-    let f : ℕ → Ideal R := fun n : ℕ ↦ (m' n).asIdeal
-    let F : Fin n → Ideal R := fun k ↦ (m' k).asIdeal
-    have comaximal : ∀ i j : ℕ, i ≠ j → (m' i).asIdeal ⊔ (m' j).asIdeal =
-      (⊤ : Ideal R) := by 
-      intro i j distinct
-      apply Ideal.IsMaximal.coprime_of_ne
-      exact (m' i).IsMaximal
-      exact (m' j).IsMaximal
-      have : (m' i) ≠ (m' j) := by 
-        exact Function.Injective.ne m'inj distinct
-      intro h
-      apply this
-      exact MaximalSpectrum.ext _ _ h
-    have ∀ n : ℕ, (R ⧸ ⨅ (i : Fin n), (F n) i) ≃+* ((i : Fin n) → R ⧸ (F n) i) := by
+    -- let f : ℕ → MaximalSpectrum R := fun n : ℕ ↦ m' n
+    -- let F : (n : ℕ) → Fin n → MaximalSpectrum R := fun n k ↦ m' k
+    have DCC : ∃ n : ℕ, ∀ k : ℕ, n ≤ k → m'' n = m'' k := by
+      apply IsArtinian.monotone_stabilizes {
+        toFun := m''
+        monotone' := sorry
+      }
+    cases' DCC with n DCCn
+    specialize DCCn (n+1)
+    specialize DCCn (Nat.le_succ n)
+    have containment1 : m'' n < (m' (n + 1)).asIdeal := by sorry
+    have : ∀ (j : ℕ), (j ≠ n + 1) → ∃ x, x ∈ (m' j).asIdeal ∧ x ∉ (m' (n+1)).asIdeal := by
+      intro j jnotn
+      have notcontain : ¬ (m' j).asIdeal ≤ (m' (n+1)).asIdeal := by
+        -- apply Ideal.IsMaximal (m' j).asIdeal
+        sorry
       sorry
-    -- (let F : Fin n → Ideal R := fun k : Fin n ↦ (m' k).asIdeal) 
-    -- let g := Ideal.quotientInfRingEquivPiQuotient f comaximal 
-
+    sorry
+      -- have distinct : (m' j).asIdeal ≠ (m' (n+1)).asIdeal := by         
+      --   intro h
+      --   apply Function.Injective.ne m'inj jnotn
+      --   exact MaximalSpectrum.ext _ _ h      
+      -- simp
+      -- unfold 
+     
 
 -- Stacks Lemma 10.53.4: R Artinian => Jacobson ideal of R is nilpotent
-lemma Jacobson_of_Artinian_is_nilpotent 
-    [IsArtinianRing R] : IsNilpotent (Ideal.jacobson (⊥ : Ideal R)) := by 
-    have J := Ideal.jacobson (⊥ : Ideal R)
-    
+-- This is in mathlib: IsArtinianRing.isNilpotent_jacobson_bot
 
 -- Stacks Lemma 10.53.5: If R has finitely many maximal ideals and 
 -- locally nilpotent Jacobson radical, then R is the product of its localizations at 
@@ -187,21 +194,92 @@ lemma primes_of_Artinian_are_maximal
 
 -- Lemma: Krull dimension of a ring is the supremum of height of maximal ideals
 
-
 -- Stacks Lemma 10.60.5: R is Artinian iff R is Noetherian of dimension 0
-lemma dim_zero_Noetherian_iff_Artinian (R : Type _) [CommRing R] : 
-    IsNoetherianRing R ∧ Ideal.krullDim R = 0 ↔ IsArtinianRing R := by 
+lemma dim_le_zero_Noetherian_iff_Artinian (R : Type _) [CommRing R] : 
+    IsNoetherianRing R ∧ Ideal.krullDim R ≤ 0 ↔ IsArtinianRing R := by 
     constructor
     sorry
     intro RisArtinian
     constructor
     apply finite_length_is_Noetherian
     rwa [IsArtinian_iff_finite_length] at RisArtinian
-    sorry -- can use Grant's lemma dim_eq_zero_iff
+    rw [Ideal.dim_le_zero_iff]
+    intro I
+    apply primes_of_Artinian_are_maximal
 
 
 
 
+-- Trash bin
+-- lemma Artinian_has_finite_max_ideal 
+--     [IsArtinianRing R] : Finite (MaximalSpectrum R) := by 
+--     by_contra infinite
+--     simp only [not_finite_iff_infinite] at infinite
+--     let m' : ℕ ↪ MaximalSpectrum R := Infinite.natEmbedding (MaximalSpectrum R)
+--     have m'inj := m'.injective
+--     let m'' : ℕ → Ideal R := fun n : ℕ ↦ ⨅ k ∈ range n, (m' k).asIdeal
+--     let f : ℕ → Ideal R := fun n : ℕ ↦ (m' n).asIdeal
+--     have DCC : ∃ n : ℕ, ∀ k : ℕ, n ≤ k → m'' n = m'' k := by
+--       apply IsArtinian.monotone_stabilizes {
+--         toFun := m''
+--         monotone' := sorry
+--       }
+--     cases' DCC with n DCCn
+--     specialize DCCn (n+1)
+--     specialize DCCn (Nat.le_succ n)
+--     let F : Fin (n + 1) → MaximalSpectrum R := fun k ↦ m' k
+--     have comaximal : ∀ (i j : Fin (n + 1)), (i ≠ j) → (F i).asIdeal ⊔ (F j).asIdeal =
+--       (⊤ : Ideal R) := by 
+--       intro i j distinct
+--       apply Ideal.IsMaximal.coprime_of_ne
+--       exact (F i).IsMaximal
+--       exact (F j).IsMaximal
+--       have : (F i) ≠ (F j) := by         
+--         apply Function.Injective.ne m'inj
+--         contrapose! distinct
+--         exact Fin.ext distinct
+--       intro h
+--       apply this
+--       exact MaximalSpectrum.ext _ _ h
+--     let CRT1 : (R ⧸ ⨅ (i : Fin (n + 1)), ((F i).asIdeal)) 
+--         ≃+* ((i : Fin (n + 1)) → R ⧸ (F i).asIdeal) := 
+--         Ideal.quotientInfRingEquivPiQuotient 
+--           (fun i ↦ (F i).asIdeal) comaximal
+--     let CRT2 : (R ⧸ ⨅ (i : Fin (n + 1)), ((F i).asIdeal)) 
+--         ≃+* ((i : Fin (n + 1)) → R ⧸ (F i).asIdeal) := 
+--         Ideal.quotientInfRingEquivPiQuotient 
+--           (fun i ↦ (F i).asIdeal) comaximal
+
+
+
+
+    -- have comaximal : ∀ (n : ℕ) (i j : Fin n), (i ≠ j) → ((F n) i).asIdeal ⊔ ((F n) j).asIdeal =
+    --   (⊤ : Ideal R) := by 
+    --   intro n i j distinct
+    --   apply Ideal.IsMaximal.coprime_of_ne
+    --   exact (F n i).IsMaximal
+    --   exact (F n j).IsMaximal
+    --   have : (F n i) ≠ (F n j) := by         
+    --     apply Function.Injective.ne m'inj
+    --     contrapose! distinct
+    --     exact Fin.ext distinct
+    --   intro h
+    --   apply this
+    --   exact MaximalSpectrum.ext _ _ h
+    -- let CRT : (n : ℕ) → (R ⧸ ⨅ (i : Fin n), ((F n) i).asIdeal) 
+    --     ≃+* ((i : Fin n) → R ⧸ ((F n) i).asIdeal) := 
+    --    fun n ↦ Ideal.quotientInfRingEquivPiQuotient 
+    --       (fun i ↦ (F n i).asIdeal) (comaximal n)
+    -- have DCC : ∃ n : ℕ, ∀ k : ℕ, n ≤ k → m'' n = m'' k := by
+    --   apply IsArtinian.monotone_stabilizes {
+    --     toFun := m''
+    --     monotone' := sorry
+    --   }
+    -- cases' DCC with n DCCn
+    -- specialize DCCn (n+1)
+    -- specialize DCCn (Nat.le_succ n)
+    -- let CRT1 := CRT n
+    -- let CRT2 := CRT (n + 1)
     
 
 

From 7cc1079f7d3f77b056049f89b5588e74bb28e0c9 Mon Sep 17 00:00:00 2001
From: GTBarkley <barkleygrant@gmail.com>
Date: Fri, 16 Jun 2023 03:53:29 +0000
Subject: [PATCH 14/23] swapped inequalities in lt_height_iff

---
 CommAlg/krull.lean | 45 +++++++++++++++++++++++----------------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/CommAlg/krull.lean b/CommAlg/krull.lean
index e068760..79e81c2 100644
--- a/CommAlg/krull.lean
+++ b/CommAlg/krull.lean
@@ -72,31 +72,32 @@ lemma krullDim_eq_height [LocalRing R] : krullDim R = height (closedPoint R) :=
 /-- The height of a prime `𝔭` is greater than `n` if and only if there is a chain of primes less than `𝔭`
   with length `n + 1`. -/
 lemma lt_height_iff' {𝔭 : PrimeSpectrum R} {n : ℕ∞} : 
-height 𝔭 > n ↔ ∃ c : List (PrimeSpectrum R), c.Chain' (· < ·) ∧ (∀ 𝔮 ∈ c, 𝔮 < 𝔭) ∧ c.length = n + 1 := by
-  rcases n with _ | n
-  . constructor <;> intro h <;> exfalso
+n < height 𝔭 ↔ ∃ c : List (PrimeSpectrum R), c.Chain' (· < ·) ∧ (∀ 𝔮 ∈ c, 𝔮 < 𝔭) ∧ c.length = n + 1 := by
+  match n with
+  | ⊤ =>  
+    constructor <;> intro h <;> exfalso
     . exact (not_le.mpr h) le_top
     . tauto
-  have (m : ℕ∞) : m > some n ↔ m ≥ some (n + 1) := by
-    symm
-    show (n + 1 ≤ m ↔ _ )
-    apply ENat.add_one_le_iff
-    exact ENat.coe_ne_top _
-  rw [this]
-  unfold Ideal.height
-  show ((↑(n + 1):ℕ∞) ≤ _) ↔ ∃c, _ ∧ _ ∧ ((_ : WithTop ℕ) = (_:ℕ∞))
-  rw [{J | J < 𝔭}.le_chainHeight_iff]
-  show (∃ c, (List.Chain' _ c ∧ ∀𝔮, 𝔮 ∈ c → 𝔮 < 𝔭) ∧ _) ↔ _
-  constructor <;> rintro ⟨c, hc⟩ <;> use c
-  . tauto
-  . change _ ∧ _ ∧ (List.length c : ℕ∞) = n + 1 at hc
-    norm_cast at hc
-    tauto
+  | (n : ℕ) => 
+    have (m : ℕ∞) : n < m ↔ (n + 1 : ℕ∞) ≤ m := by
+      symm
+      show (n + 1 ≤ m ↔ _ )
+      apply ENat.add_one_le_iff
+      exact ENat.coe_ne_top _
+    rw [this]
+    unfold Ideal.height
+    show ((↑(n + 1):ℕ∞) ≤ _) ↔ ∃c, _ ∧ _ ∧ ((_ : WithTop ℕ) = (_:ℕ∞))
+    rw [{J | J < 𝔭}.le_chainHeight_iff]
+    show (∃ c, (List.Chain' _ c ∧ ∀𝔮, 𝔮 ∈ c → 𝔮 < 𝔭) ∧ _) ↔ _
+    constructor <;> rintro ⟨c, hc⟩ <;> use c
+    . tauto
+    . change _ ∧ _ ∧ (List.length c : ℕ∞) = n + 1 at hc
+      norm_cast at hc
+      tauto
 
 /-- Form of `lt_height_iff''` for rewriting with the height coerced to `WithBot ℕ∞`. -/
 lemma lt_height_iff'' {𝔭 : PrimeSpectrum R} {n : ℕ∞} : 
-height 𝔭 > (n : WithBot ℕ∞) ↔ ∃ c : List (PrimeSpectrum R), c.Chain' (· < ·) ∧ (∀ 𝔮 ∈ c, 𝔮 < 𝔭) ∧ c.length = n + 1 := by
-  show (_ < _) ↔ _
+(n : WithBot ℕ∞) < height 𝔭 ↔ ∃ c : List (PrimeSpectrum R), c.Chain' (· < ·) ∧ (∀ 𝔮 ∈ c, 𝔮 < 𝔭) ∧ c.length = n + 1 := by
   rw [WithBot.coe_lt_coe]
   exact lt_height_iff'
 
@@ -158,7 +159,7 @@ lemma dim_le_zero_iff : krullDim R ≤ 0 ↔ ∀ I : PrimeSpectrum R, IsMaximal
       rw [hcontr] at h
       exact h h𝔪.1
     use 𝔪p
-    show (_ : WithBot ℕ∞) > (0 : ℕ∞)
+    show (0 : ℕ∞) < (_ : WithBot ℕ∞) 
     rw [lt_height_iff'']
     use [I]
     constructor
@@ -169,7 +170,7 @@ lemma dim_le_zero_iff : krullDim R ≤ 0 ↔ ∀ I : PrimeSpectrum R, IsMaximal
         rwa [hI']
       . simp
   . contrapose! h
-    change (_ : WithBot ℕ∞) > (0 : ℕ∞) at h
+    change (0 : ℕ∞) < (_ : WithBot ℕ∞) at h
     rw [lt_height_iff''] at h
     obtain ⟨c, _, hc2, hc3⟩ := h
     norm_cast at hc3

From 85263016c118b8b2f8363110a0ccc589e6c0222a Mon Sep 17 00:00:00 2001
From: Andre <espietandre@gmail.com>
Date: Fri, 16 Jun 2023 00:00:20 -0400
Subject: [PATCH 15/23] fixed indentation for PolyType_0

---
 CommAlg/final_poly_type.lean | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 4405e42..bfbef39 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -151,9 +151,11 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
   · rintro ⟨Poly, ⟨N, ⟨H1, H2⟩⟩⟩ 
     have this1 : Polynomial.degree Poly = 0 := by rw [← H2]; rfl
     have this2 : ∃ (c : ℤ), Poly = Polynomial.C (c : ℚ) := by
-      have HH : ∃ (c : ℚ), Poly = Polynomial.C (c : ℚ) := ⟨Poly.coeff 0, Polynomial.eq_C_of_degree_eq_zero (by rw[← H2]; rfl)⟩
+      have HH : ∃ (c : ℚ), Poly = Polynomial.C (c : ℚ) := 
+        ⟨Poly.coeff 0, Polynomial.eq_C_of_degree_eq_zero (by rw[← H2]; rfl)⟩
       cases' HH with c HHH
-      have HHHH : ∃ (d : ℤ), d = c := ⟨f N, by simp [(Poly_constant Poly c).mp HHH N, H1 N (le_refl N)]⟩
+      have HHHH : ∃ (d : ℤ), d = c := 
+        ⟨f N, by simp [(Poly_constant Poly c).mp HHH N, H1 N (le_refl N)]⟩
       cases' HHHH with d H5; exact ⟨d, by rw[← H5] at HHH; exact HHH⟩
     rcases this2 with ⟨c, hthis2⟩ 
     use c; use N; intro n
@@ -162,10 +164,13 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
         rw [hthis2]; simp only [map_intCast, Polynomial.eval_int_cast]
       exact fun HH1 => Iff.mp (Rat.coe_int_inj (f n) c) (by rw [←this4, H1 n HH1])
     · intro c0
-      simp only [hthis2, c0, Int.cast_zero, map_zero, Polynomial.degree_zero] at this1
+      simp only [hthis2, c0, Int.cast_zero, map_zero, Polynomial.degree_zero] 
+        at this1
   · rintro ⟨c, N, hh⟩
-    have H2 : (c : ℚ) ≠ 0 := by simp only [ne_eq, Int.cast_eq_zero]; exact (hh 0).2
-    exact ⟨Polynomial.C (c : ℚ), N, fun n Nn => by rw [(hh n).1 Nn]; exact (((Poly_constant (Polynomial.C (c : ℚ)) (c : ℚ)).mp rfl) n).symm, by rw [Polynomial.degree_C H2]; rfl⟩
+    have H2 : (c : ℚ) ≠ 0 := by simp only [ne_eq, Int.cast_eq_zero]; exact (hh 0).2 
+    exact ⟨Polynomial.C (c : ℚ), N, fun n Nn 
+      => by rw [(hh n).1 Nn]; exact (((Poly_constant (Polynomial.C (c : ℚ)) 
+      (c : ℚ)).mp rfl) n).symm, by rw [Polynomial.degree_C H2]; rfl⟩
 
 
 

From 04bda915d14865967076122446152a5dd830213c Mon Sep 17 00:00:00 2001
From: chelseaandmadrid <53058005+chelseaandmadrid@users.noreply.github.com>
Date: Thu, 15 Jun 2023 21:27:52 -0700
Subject: [PATCH 16/23] change statement of PolyType_0

---
 CommAlg/final_poly_type.lean | 69 ++++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 26 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index 4405e42..377619c 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -145,8 +145,8 @@ lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s :
 
 -- set_option pp.all true in
 -- PolyType 0 = constant function
-lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), 
-    (N ≤ n → f n = c) ∧ c ≠ 0) := by
+lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), (∀ (n : ℤ), 
+    (N ≤ n → f n = c)) ∧ c ≠ 0) := by
   constructor
   · rintro ⟨Poly, ⟨N, ⟨H1, H2⟩⟩⟩ 
     have this1 : Polynomial.degree Poly = 0 := by rw [← H2]; rfl
@@ -182,14 +182,11 @@ lemma Δ_1 (f : ℤ → ℤ) (d : ℕ): d > 0 → PolyType f d → PolyType (Δ
 
 
 
-lemma foo (f : ℤ → ℤ) (s : ℕ) : Δ (Δ f 1) s = (Δ f (s + 1)) := by
-  sorry
-
-
-
 
 
 -- Δ of d times maps polynomial of degree d to polynomial of degree 0
+lemma Δ_1_s_equiv_Δ_s_1 (f : ℤ → ℤ) (s : ℕ) : Δ (Δ f 1) s = (Δ f (s + 1)) := by
+  sorry
 lemma foofoo (d : ℕ) : (f : ℤ → ℤ) → (PolyType f d) → (PolyType (Δ f d) 0):= by
   induction' d with d hd
   · intro f h
@@ -205,12 +202,9 @@ lemma foofoo (d : ℕ) : (f : ℤ → ℤ) → (PolyType f d) → (PolyType (Δ
       clear hf
       specialize hd (Δ f 1)
       have this4 : PolyType (Δ (Δ f 1) d) 0 := by tauto
-      rw [foo] at this4
+      rw [Δ_1_s_equiv_Δ_s_1] at this4
       tauto
     tauto
-
-
-
 lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := by
   intro h
   have this : ∀ (d : ℕ), ∀ (f :ℤ → ℤ), (PolyType f d) → (PolyType (Δ f d) 0) := by 
@@ -222,37 +216,60 @@ lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d 
 
 
 
-
--- [BH, 4.1.2] (a) => (b)
--- Δ^d f (n) = c for some nonzero integer c for n >> 0 → f is of polynomial type d
-lemma a_to_b (f : ℤ → ℤ) (d : ℕ) : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0)) → PolyType f d := by
-  intro h
-  rcases h with ⟨c, N, hh⟩
-  have H1 := λ n => (hh n).left
-  have H2 := λ n => (hh n).right
-  clear hh
-  have H2 : c ≠ 0 := by
-    tauto
+lemma foofoofoo (d : ℕ) : (f : ℤ → ℤ) → (∃ (c : ℤ), ∃ (N : ℤ), (∀ (n : ℤ), N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0) → (PolyType f d)  := by
   induction' d with d hd
+
   -- Base case
-  · rw [PolyType_0]
+  · intro f
+    intro h
+    rcases h with ⟨c, N, hh⟩
+    rw [PolyType_0]
     use c
     use N
     tauto
 
   -- Induction step
-  · sorry
+  · intro f
+    intro h
+    rcases h with ⟨c, N, h⟩
+    have this : PolyType f (d + 1) := by
+      sorry
+    tauto
+
+
+
+-- [BH, 4.1.2] (a) => (b)
+-- Δ^d f (n) = c for some nonzero integer c for n >> 0 → f is of polynomial type d
+lemma a_to_b (f : ℤ → ℤ) (d : ℕ) : (∃ (c : ℤ), ∃ (N : ℤ), (∀ (n : ℤ), N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0) → PolyType f d := by
+  sorry
+  -- intro h
+  -- rcases h with ⟨c, N, hh⟩
+  -- have H1 := λ n => (hh n).left
+  -- have H2 := λ n => (hh n).right
+  -- clear hh
+  -- have H2 : c ≠ 0 := by
+  --   tauto
+  -- induction' d with d hd
+
+  -- -- Base case
+  -- · rw [PolyType_0]
+  --   use c
+  --   use N
+  --   tauto
+
+  -- -- Induction step
+  -- · sorry
 
 
 
 -- [BH, 4.1.2] (a) <= (b)
 -- f is of polynomial type d → Δ^d f (n) = c for some nonzero integer c for n >> 0
-lemma b_to_a (f : ℤ → ℤ) (d : ℕ) : PolyType f d → (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0)) := by
+lemma b_to_a (f : ℤ → ℤ) (d : ℕ) : PolyType f d → (∃ (c : ℤ), ∃ (N : ℤ), (∀ (n : ℤ), N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0) := by
   intro h
   have : PolyType (Δ f d) 0 := by
     apply Δ_d_PolyType_d_to_PolyType_0
     exact h
-  have this1 : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) n = c) ∧ c ≠ 0)) := by
+  have this1 : (∃ (c : ℤ), ∃ (N : ℤ), (∀ (n : ℤ), (N ≤ n → (Δ f d) n = c)) ∧ c ≠ 0) := by
     rw [←PolyType_0]
     exact this
   exact this1

From de995bf2f33858d41766845a1e793d6e91f34a25 Mon Sep 17 00:00:00 2001
From: Andre <espietandre@gmail.com>
Date: Fri, 16 Jun 2023 00:28:44 -0400
Subject: [PATCH 17/23] fixed some formatting

---
 CommAlg/final_poly_type.lean | 74 +-----------------------------------
 1 file changed, 2 insertions(+), 72 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index bfbef39..40f66e7 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -139,12 +139,6 @@ lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s :
   rcases hh with ⟨N,ss⟩
   sorry
 
-
-
-
-
--- set_option pp.all true in
--- PolyType 0 = constant function
 lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), 
     (N ≤ n → f n = c) ∧ c ≠ 0) := by
   constructor
@@ -172,28 +166,16 @@ lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N :
       => by rw [(hh n).1 Nn]; exact (((Poly_constant (Polynomial.C (c : ℚ)) 
       (c : ℚ)).mp rfl) n).symm, by rw [Polynomial.degree_C H2]; rfl⟩
 
-
-
-
 -- Δ of 0 times preserves the function
 lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by tauto
 
-
-
 -- Δ of 1 times decreaes the polynomial type by one
 lemma Δ_1 (f : ℤ → ℤ) (d : ℕ): d > 0 → PolyType f d → PolyType (Δ f 1) (d - 1) := by
   sorry
 
-
-
-
 lemma foo (f : ℤ → ℤ) (s : ℕ) : Δ (Δ f 1) s = (Δ f (s + 1)) := by
   sorry
 
-
-
-
-
 -- Δ of d times maps polynomial of degree d to polynomial of degree 0
 lemma foofoo (d : ℕ) : (f : ℤ → ℤ) → (PolyType f d) → (PolyType (Δ f d) 0):= by
   induction' d with d hd
@@ -214,19 +196,7 @@ lemma foofoo (d : ℕ) : (f : ℤ → ℤ) → (PolyType f d) → (PolyType (Δ
       tauto
     tauto
 
-
-
-lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := by
-  intro h
-  have this : ∀ (d : ℕ), ∀ (f :ℤ → ℤ), (PolyType f d) → (PolyType (Δ f d) 0) := by 
-    exact foofoo
-  specialize this d f
-  tauto
-
-
-
-
-
+lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := fun h => (foofoo d f) h
 
 -- [BH, 4.1.2] (a) => (b)
 -- Δ^d f (n) = c for some nonzero integer c for n >> 0 → f is of polynomial type d
@@ -248,8 +218,6 @@ lemma a_to_b (f : ℤ → ℤ) (d : ℕ) : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n
   -- Induction step
   · sorry
 
-
-
 -- [BH, 4.1.2] (a) <= (b)
 -- f is of polynomial type d → Δ^d f (n) = c for some nonzero integer c for n >> 0
 lemma b_to_a (f : ℤ → ℤ) (d : ℕ) : PolyType f d → (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0)) := by
@@ -263,41 +231,14 @@ lemma b_to_a (f : ℤ → ℤ) (d : ℕ) : PolyType f d → (∃ (c : ℤ), ∃
   exact this1
 end
 
-
-
-
-
-
-
-
 -- @Additive lemma of length for a SES
 -- Given a SES 0 → A → B → C → 0, then length (A) - length (B) + length (C) = 0 
 section
--- variable {R M N : Type _} [CommRing R] [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N]
---   (f : M →[R] N)
 open LinearMap
--- variable {R M : Type _} [CommRing R] [AddCommGroup M] [Module R M]
--- noncomputable def length := Set.chainHeight {M' : Submodule R M | M' < ⊤}
-
 
 -- Definitiion of the length of a module
 noncomputable def length (R M : Type _) [CommRing R] [AddCommGroup M] [Module R M] := Set.chainHeight {M' : Submodule R M | M' < ⊤}
 #check length ℤ ℤ
--- #eval length ℤ ℤ
-
-
--- @[ext]
--- structure SES (R : Type _) [CommRing R] where
---   A : Type _
---   B : Type _
---   C : Type _
---   f : A →ₗ[R] B
---   g : B →ₗ[R] C
--- left_exact : LinearMap.ker f = 0
--- middle_exact : LinearMap.range f = LinearMap.ker g
--- right_exact : LinearMap.range g = C
-
-
 
 -- Definition of a SES (Short Exact Sequence)
 -- @[ext]
@@ -309,10 +250,6 @@ structure SES {R A B C : Type _} [CommRing R] [AddCommGroup A] [AddCommGroup B]
   middle_exact : LinearMap.range f = LinearMap.ker g
   right_exact : LinearMap.range g = ⊤
 
-#check SES.right_exact
-#check SES
-
-
 -- Additive lemma
 lemma length_Additive (R A B C : Type _) [CommRing R] [AddCommGroup A] [AddCommGroup B] [AddCommGroup C] [Module R A] [Module R B] [Module R C] 
   (f : A →ₗ[R] B) (g : B →ₗ[R] C)
@@ -321,11 +258,4 @@ lemma length_Additive (R A B C : Type _) [CommRing R] [AddCommGroup A] [AddCommG
   rcases h with ⟨left_exact, middle_exact, right_exact⟩
   sorry
 
-end section
-
-
-
-
-
-
-
+end section
\ No newline at end of file

From 8eff058565edf99ccb03c3b0dc9b1c7be92f94be Mon Sep 17 00:00:00 2001
From: poincare-duality <jidongw@uoregon.edu>
Date: Thu, 15 Jun 2023 21:34:38 -0700
Subject: [PATCH 18/23] more stuff

---
 CommAlg/jayden(krull-dim-zero).lean | 88 ++++-------------------------
 1 file changed, 10 insertions(+), 78 deletions(-)

diff --git a/CommAlg/jayden(krull-dim-zero).lean b/CommAlg/jayden(krull-dim-zero).lean
index 78bd648..15dd150 100644
--- a/CommAlg/jayden(krull-dim-zero).lean
+++ b/CommAlg/jayden(krull-dim-zero).lean
@@ -43,7 +43,6 @@ class IsLocallyNilpotent {R : Type _} [CommRing R] (I : Ideal R) : Prop :=
 #check Ideal.IsLocallyNilpotent
 end Ideal
 
-
 -- Repeats the definition of the length of a module by Monalisa
 variable (R : Type _) [CommRing R] (I J : Ideal R)
 variable (M : Type _) [AddCommMonoid M] [Module R M]
@@ -71,7 +70,7 @@ lemma ring_Noetherian_iff_spec_Noetherian : IsNoetherianRing R
     sorry
     -- how do I apply an instance to prove one direction?
 
-
+-- Stacks Lemma 5.9.2: 
 -- Use TopologicalSpace.NoetherianSpace.exists_finset_irreducible :
 -- Every closed subset of a noetherian space is a finite union 
 -- of irreducible closed subsets.
@@ -169,7 +168,7 @@ abbrev Prod_of_localization :=
      
 def foo : Prod_of_localization R →+* R where
   toFun := sorry
-  invFun := sorry
+  -- invFun := sorry
   left_inv := sorry
   right_inv := sorry
   map_mul' := sorry
@@ -198,6 +197,13 @@ lemma primes_of_Artinian_are_maximal
 lemma dim_le_zero_Noetherian_iff_Artinian (R : Type _) [CommRing R] : 
     IsNoetherianRing R ∧ Ideal.krullDim R ≤ 0 ↔ IsArtinianRing R := by 
     constructor
+    rintro ⟨RisNoetherian, dimzero⟩  
+    rw [ring_Noetherian_iff_spec_Noetherian] at RisNoetherian
+    let Z := irreducibleComponents (PrimeSpectrum R)
+    have Zfinite : Set.Finite Z := by
+      -- apply TopologicalSpace.NoetherianSpace.finite_irreducibleComponents ?_
+      sorry
+    
     sorry
     intro RisArtinian
     constructor
@@ -207,81 +213,7 @@ lemma dim_le_zero_Noetherian_iff_Artinian (R : Type _) [CommRing R] :
     intro I
     apply primes_of_Artinian_are_maximal
 
-
-
-
--- Trash bin
--- lemma Artinian_has_finite_max_ideal 
---     [IsArtinianRing R] : Finite (MaximalSpectrum R) := by 
---     by_contra infinite
---     simp only [not_finite_iff_infinite] at infinite
---     let m' : ℕ ↪ MaximalSpectrum R := Infinite.natEmbedding (MaximalSpectrum R)
---     have m'inj := m'.injective
---     let m'' : ℕ → Ideal R := fun n : ℕ ↦ ⨅ k ∈ range n, (m' k).asIdeal
---     let f : ℕ → Ideal R := fun n : ℕ ↦ (m' n).asIdeal
---     have DCC : ∃ n : ℕ, ∀ k : ℕ, n ≤ k → m'' n = m'' k := by
---       apply IsArtinian.monotone_stabilizes {
---         toFun := m''
---         monotone' := sorry
---       }
---     cases' DCC with n DCCn
---     specialize DCCn (n+1)
---     specialize DCCn (Nat.le_succ n)
---     let F : Fin (n + 1) → MaximalSpectrum R := fun k ↦ m' k
---     have comaximal : ∀ (i j : Fin (n + 1)), (i ≠ j) → (F i).asIdeal ⊔ (F j).asIdeal =
---       (⊤ : Ideal R) := by 
---       intro i j distinct
---       apply Ideal.IsMaximal.coprime_of_ne
---       exact (F i).IsMaximal
---       exact (F j).IsMaximal
---       have : (F i) ≠ (F j) := by         
---         apply Function.Injective.ne m'inj
---         contrapose! distinct
---         exact Fin.ext distinct
---       intro h
---       apply this
---       exact MaximalSpectrum.ext _ _ h
---     let CRT1 : (R ⧸ ⨅ (i : Fin (n + 1)), ((F i).asIdeal)) 
---         ≃+* ((i : Fin (n + 1)) → R ⧸ (F i).asIdeal) := 
---         Ideal.quotientInfRingEquivPiQuotient 
---           (fun i ↦ (F i).asIdeal) comaximal
---     let CRT2 : (R ⧸ ⨅ (i : Fin (n + 1)), ((F i).asIdeal)) 
---         ≃+* ((i : Fin (n + 1)) → R ⧸ (F i).asIdeal) := 
---         Ideal.quotientInfRingEquivPiQuotient 
---           (fun i ↦ (F i).asIdeal) comaximal
-
-
-
-
-    -- have comaximal : ∀ (n : ℕ) (i j : Fin n), (i ≠ j) → ((F n) i).asIdeal ⊔ ((F n) j).asIdeal =
-    --   (⊤ : Ideal R) := by 
-    --   intro n i j distinct
-    --   apply Ideal.IsMaximal.coprime_of_ne
-    --   exact (F n i).IsMaximal
-    --   exact (F n j).IsMaximal
-    --   have : (F n i) ≠ (F n j) := by         
-    --     apply Function.Injective.ne m'inj
-    --     contrapose! distinct
-    --     exact Fin.ext distinct
-    --   intro h
-    --   apply this
-    --   exact MaximalSpectrum.ext _ _ h
-    -- let CRT : (n : ℕ) → (R ⧸ ⨅ (i : Fin n), ((F n) i).asIdeal) 
-    --     ≃+* ((i : Fin n) → R ⧸ ((F n) i).asIdeal) := 
-    --    fun n ↦ Ideal.quotientInfRingEquivPiQuotient 
-    --       (fun i ↦ (F n i).asIdeal) (comaximal n)
-    -- have DCC : ∃ n : ℕ, ∀ k : ℕ, n ≤ k → m'' n = m'' k := by
-    --   apply IsArtinian.monotone_stabilizes {
-    --     toFun := m''
-    --     monotone' := sorry
-    --   }
-    -- cases' DCC with n DCCn
-    -- specialize DCCn (n+1)
-    -- specialize DCCn (Nat.le_succ n)
-    -- let CRT1 := CRT n
-    -- let CRT2 := CRT (n + 1)
-    
-
+-- Use TopologicalSpace.NoetherianSpace.exists_finset_irreducible :
 
 
 

From 0089e927e1380662e1b8fcb4b1ba2b20404ed530 Mon Sep 17 00:00:00 2001
From: Andre <espietandre@gmail.com>
Date: Fri, 16 Jun 2023 00:44:03 -0400
Subject: [PATCH 19/23] fixed merge conflics

---
 CommAlg/final_poly_type.lean | 27 ---------------------------
 1 file changed, 27 deletions(-)

diff --git a/CommAlg/final_poly_type.lean b/CommAlg/final_poly_type.lean
index e192575..dcb0e70 100644
--- a/CommAlg/final_poly_type.lean
+++ b/CommAlg/final_poly_type.lean
@@ -139,11 +139,6 @@ lemma Poly_shifting (f : ℤ → ℤ) (g : ℤ → ℤ) (hf : PolyType f d) (s :
   rcases hh with ⟨N,ss⟩
   sorry
 
-
-
-
-
--- set_option pp.all true in
 -- PolyType 0 = constant function
 lemma PolyType_0 (f : ℤ → ℤ) : (PolyType f 0) ↔ (∃ (c : ℤ), ∃ (N : ℤ), (∀ (n : ℤ), 
     (N ≤ n → f n = c)) ∧ c ≠ 0) := by
@@ -179,11 +174,6 @@ lemma Δ_0 (f : ℤ → ℤ) : (Δ f 0) = f := by tauto
 lemma Δ_1 (f : ℤ → ℤ) (d : ℕ): d > 0 → PolyType f d → PolyType (Δ f 1) (d - 1) := by
   sorry
 
-
-
-
-
-
 -- Δ of d times maps polynomial of degree d to polynomial of degree 0
 lemma Δ_1_s_equiv_Δ_s_1 (f : ℤ → ℤ) (s : ℕ) : Δ (Δ f 1) s = (Δ f (s + 1)) := by
   sorry
@@ -208,23 +198,6 @@ lemma foofoo (d : ℕ) : (f : ℤ → ℤ) → (PolyType f d) → (PolyType (Δ
 
 lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := fun h => (foofoo d f) h
 
--- [BH, 4.1.2] (a) => (b)
--- Δ^d f (n) = c for some nonzero integer c for n >> 0 → f is of polynomial type d
-lemma a_to_b (f : ℤ → ℤ) (d : ℕ) : (∃ (c : ℤ), ∃ (N : ℤ), ∀ (n : ℤ), ((N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0)) → PolyType f d := by
-  intro h
-  rcases h with ⟨c, N, hh⟩
-  have H1 := λ n => (hh n).left
-  have H2 := λ n => (hh n).right
-  clear hh
-  have H2 : c ≠ 0 := by
-    tauto
-lemma Δ_d_PolyType_d_to_PolyType_0 (f : ℤ → ℤ) (d : ℕ): PolyType f d → PolyType (Δ f d) 0 := by
-  intro h
-  have this : ∀ (d : ℕ), ∀ (f :ℤ → ℤ), (PolyType f d) → (PolyType (Δ f d) 0) := by 
-    exact foofoo
-  specialize this d f
-  tauto
-
 lemma foofoofoo (d : ℕ) : (f : ℤ → ℤ) → (∃ (c : ℤ), ∃ (N : ℤ), (∀ (n : ℤ), N ≤ n → (Δ f d) (n) = c) ∧ c ≠ 0) → (PolyType f d)  := by
   induction' d with d hd
 

From 9c4f129a56e2fd7d935e988815ea793a95e25683 Mon Sep 17 00:00:00 2001
From: GTBarkley <barkleygrant@gmail.com>
Date: Fri, 16 Jun 2023 04:57:28 +0000
Subject: [PATCH 20/23] added WF_interval_le_prime

---
 CommAlg/grant2.lean | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/CommAlg/grant2.lean b/CommAlg/grant2.lean
index 0e3092e..24edcff 100644
--- a/CommAlg/grant2.lean
+++ b/CommAlg/grant2.lean
@@ -54,9 +54,20 @@ def symbolicIdeal(Q : Ideal R) {hin : Q.IsPrime} (I : Ideal R) : Ideal R where
     rw [←mul_assoc, mul_comm s, mul_assoc]
     exact Ideal.mul_mem_left _ _ hs2
 
+
+theorem WF_interval_le_prime (I : Ideal R) (P : Ideal R) [P.IsPrime] 
+  (h : ∀ J ∈ (Set.Icc I P), J.IsPrime → J = P ):
+  WellFounded ((· < ·) : (Set.Icc I P) → (Set.Icc I P) → Prop ) := sorry 
+
 protected lemma LocalRing.height_le_one_of_minimal_over_principle
-  [LocalRing R] (q : PrimeSpectrum R) {x : R} 
+  [LocalRing R] {x : R} 
   (h : (closedPoint R).asIdeal ∈ (Ideal.span {x}).minimalPrimes) :
-  q = closedPoint R ∨ Ideal.height q = 0 := by
-  
+  Ideal.height (closedPoint R) ≤ 1 := by
+  -- by_contra hcont
+  -- push_neg at hcont
+  -- rw [Ideal.lt_height_iff'] at hcont
+  -- rcases hcont with ⟨c, hc1, hc2, hc3⟩
+  apply height_le_of_gt_height_lt
+  intro p hp
+
   sorry
\ No newline at end of file

From 4b9f84f7c111d47b09364042622b358eeea824cb Mon Sep 17 00:00:00 2001
From: leopoldmayer <leomayer@uw.edu>
Date: Thu, 15 Jun 2023 22:10:39 -0700
Subject: [PATCH 21/23] new file for complete proof of adjoining a var

---
 CommAlg/polynomial.lean | 163 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 163 insertions(+)
 create mode 100644 CommAlg/polynomial.lean

diff --git a/CommAlg/polynomial.lean b/CommAlg/polynomial.lean
new file mode 100644
index 0000000..d03ce2c
--- /dev/null
+++ b/CommAlg/polynomial.lean
@@ -0,0 +1,163 @@
+import Mathlib.RingTheory.Ideal.Operations
+import Mathlib.RingTheory.FiniteType
+import Mathlib.Order.Height
+import Mathlib.RingTheory.Polynomial.Quotient
+import Mathlib.RingTheory.PrincipalIdealDomain
+import Mathlib.RingTheory.DedekindDomain.Basic
+import Mathlib.RingTheory.Ideal.Quotient
+import Mathlib.RingTheory.Localization.AtPrime
+import Mathlib.AlgebraicGeometry.PrimeSpectrum.Basic
+import Mathlib.Order.ConditionallyCompleteLattice.Basic
+import CommAlg.krull
+
+section ChainLemma
+variable {α β : Type _}
+variable [LT α] [LT β] (s t : Set α)
+
+namespace Set
+open List
+
+/-
+Sorry for using aesop, but it doesn't take that long
+-/
+theorem append_mem_subchain_iff :
+l ++ l' ∈ s.subchain ↔ l ∈ s.subchain ∧ l' ∈ s.subchain ∧ ∀ a ∈ l.getLast?, ∀ b ∈ l'.head?, a < b := by
+  simp [subchain, chain'_append]
+  aesop
+
+end Set
+end ChainLemma
+
+variable {R : Type _} [CommRing R]
+open Ideal Polynomial
+
+namespace Polynomial
+/-
+The composition R → R[X] → R is the identity
+-/
+theorem coeff_C_eq : RingHom.comp constantCoeff C = RingHom.id R := by ext; simp
+
+end Polynomial
+
+/-
+Given an ideal I in R, we define the ideal adjoin_x' I to be the kernel
+of R[X] → R → R/I
+-/
+def adj_x_map (I : Ideal R) : R[X] →+* R ⧸ I := (Ideal.Quotient.mk I).comp constantCoeff
+def adjoin_x' (I : Ideal R) : Ideal (Polynomial R) := RingHom.ker (adj_x_map I)
+def adjoin_x (I : PrimeSpectrum R) : PrimeSpectrum (Polynomial R) where
+  asIdeal := adjoin_x' I.asIdeal
+  IsPrime := RingHom.ker_isPrime _
+
+@[simp]
+lemma adj_x_comp_C (I : Ideal R) : RingHom.comp (adj_x_map I) C = Ideal.Quotient.mk I := by
+  ext x; simp [adj_x_map]
+
+lemma adjoin_x_eq (I : Ideal R) : adjoin_x' I = I.map C ⊔ Ideal.span {X} := by
+  apply le_antisymm
+  . rintro p hp
+    have h : ∃ q r, p = C r + X * q := ⟨p.divX, p.coeff 0, p.divX_mul_X_add.symm.trans $ by ring⟩
+    obtain ⟨q, r, rfl⟩ := h
+    suffices : r ∈ I
+    . simp only [Submodule.mem_sup, Ideal.mem_span_singleton]
+      refine' ⟨C r, Ideal.mem_map_of_mem C this, X * q, ⟨q, rfl⟩, rfl⟩
+    rw [adjoin_x', adj_x_map, RingHom.mem_ker, RingHom.comp_apply] at hp
+    rw [constantCoeff_apply, coeff_add, coeff_C_zero, coeff_X_mul_zero, add_zero] at hp
+    rwa  [←RingHom.mem_ker, Ideal.mk_ker] at hp
+  . rw [sup_le_iff]
+    constructor
+    . simp [adjoin_x', RingHom.ker, ←map_le_iff_le_comap, Ideal.map_map]
+    . simp [span_le, adjoin_x', RingHom.mem_ker, adj_x_map]
+
+/-
+If I is prime in R, the pushforward I*R[X] is prime in R[X]
+-/
+def map_prime (I : PrimeSpectrum R) : PrimeSpectrum R[X] :=
+  ⟨I.asIdeal.map C, isPrime_map_C_of_isPrime I.IsPrime⟩
+
+/-
+The pushforward map (Ideal R) → (Ideal R[X]) is injective
+-/
+lemma map_inj {I J : Ideal R} (h : I.map C = J.map C) : I = J := by
+  have H : map constantCoeff (I.map C) = map constantCoeff (J.map C) := by rw [h]
+  simp [Ideal.map_map, coeff_C_eq] at H
+  exact H
+
+/-
+The pushforward map (Ideal R) → (Ideal R[X]) is strictly monotone
+-/
+lemma map_strictmono {I J : Ideal R} (h : I < J) : I.map C < J.map C := by
+  rw [lt_iff_le_and_ne] at h ⊢
+  exact ⟨map_mono h.1, fun H => h.2 (map_inj H)⟩
+
+lemma map_lt_adjoin_x (I : PrimeSpectrum R) : map_prime I < adjoin_x I := by
+  simp [adjoin_x, adjoin_x_eq]
+  show I.asIdeal.map C  < I.asIdeal.map C ⊔ span {X}
+  simp [Ideal.span_le, mem_map_C_iff]
+  use 1
+  simp
+  rw [←Ideal.eq_top_iff_one]
+  exact I.IsPrime.ne_top'
+  
+/- Given an ideal p in R, define the ideal p[x] in R[x] -/
+lemma ht_adjoin_x_eq_ht_add_one [Nontrivial R] (I : PrimeSpectrum R) : height I + 1 ≤ height (adjoin_x I) := by
+  suffices H : height I + (1 : ℕ) ≤ height (adjoin_x I) + (0 : ℕ)
+  . norm_cast at H; rw [add_zero] at H; exact H
+  rw [height, height, Set.chainHeight_add_le_chainHeight_add {J | J < I} _ 1 0]
+  intro l hl
+  use ((l.map map_prime) ++ [map_prime I])
+  constructor
+  . simp [Set.append_mem_subchain_iff]
+    refine' ⟨_,_,_⟩
+    . show (List.map map_prime l).Chain' (· < ·) ∧ ∀ i ∈ _, i ∈ _
+      constructor
+      . apply List.chain'_map_of_chain' map_prime
+        intro a b hab
+        apply map_strictmono
+        exact hab
+        exact hl.1
+      . intro i hi
+        rw [List.mem_map] at hi
+        obtain ⟨a, ha, rfl⟩ := hi
+        show map_prime a < adjoin_x I
+        calc map_prime a < map_prime I := by apply map_strictmono; apply hl.2; apply ha
+          _ < adjoin_x I := by apply map_lt_adjoin_x
+    . apply map_lt_adjoin_x
+    . intro a ha
+      have H : ∃ b : PrimeSpectrum R, b ∈ l ∧ map_prime b = a
+      . have H2 : l ≠ []
+        . intro h
+          rw [h] at ha
+          tauto
+        use l.getLast H2
+        refine' ⟨List.getLast_mem H2, _⟩
+        have H3 : l.map map_prime ≠ []
+        . intro hl
+          apply H2
+          apply List.eq_nil_of_map_eq_nil hl
+        rw [List.getLast?_eq_getLast _ H3, Option.some_inj] at ha
+        simp [←ha, List.getLast_map _ H2]
+      obtain ⟨b, hb, rfl⟩ := H
+      apply map_strictmono
+      apply hl.2
+      exact hb
+  . simp
+
+/-
+dim R + 1 ≤ dim R[X]
+-/
+lemma dim_le_dim_polynomial_add_one [Nontrivial R] :
+  krullDim R + (1 : ℕ∞) ≤ krullDim R[X] := by
+  obtain ⟨n, hn⟩ := krullDim_nonneg_of_nontrivial R
+  rw [hn]
+  change ↑(n + 1) ≤ krullDim R[X]
+  have := le_of_eq hn.symm
+  rw [le_krullDim_iff'] at this ⊢
+  obtain ⟨I, hI⟩ := this
+  use adjoin_x I
+  apply WithBot.coe_mono
+  calc n + 1 ≤ height I + 1 := by
+        apply add_le_add_right
+        rw [WithBot.coe_le_coe] at hI
+        exact hI
+    _ ≤ height (adjoin_x I) := ht_adjoin_x_eq_ht_add_one I
\ No newline at end of file

From c702c535b5af813b33b0f0392835810537ac2a5f Mon Sep 17 00:00:00 2001
From: leopoldmayer <leomayer@uw.edu>
Date: Thu, 15 Jun 2023 22:13:11 -0700
Subject: [PATCH 22/23] golf attempt

---
 CommAlg/polynomial.lean | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/CommAlg/polynomial.lean b/CommAlg/polynomial.lean
index d03ce2c..f130868 100644
--- a/CommAlg/polynomial.lean
+++ b/CommAlg/polynomial.lean
@@ -98,33 +98,23 @@ lemma map_lt_adjoin_x (I : PrimeSpectrum R) : map_prime I < adjoin_x I := by
   simp
   rw [←Ideal.eq_top_iff_one]
   exact I.IsPrime.ne_top'
-  
-/- Given an ideal p in R, define the ideal p[x] in R[x] -/
+
 lemma ht_adjoin_x_eq_ht_add_one [Nontrivial R] (I : PrimeSpectrum R) : height I + 1 ≤ height (adjoin_x I) := by
   suffices H : height I + (1 : ℕ) ≤ height (adjoin_x I) + (0 : ℕ)
   . norm_cast at H; rw [add_zero] at H; exact H
   rw [height, height, Set.chainHeight_add_le_chainHeight_add {J | J < I} _ 1 0]
   intro l hl
   use ((l.map map_prime) ++ [map_prime I])
-  constructor
+  refine' ⟨_, by simp⟩
   . simp [Set.append_mem_subchain_iff]
-    refine' ⟨_,_,_⟩
-    . show (List.map map_prime l).Chain' (· < ·) ∧ ∀ i ∈ _, i ∈ _
-      constructor
-      . apply List.chain'_map_of_chain' map_prime
-        intro a b hab
-        apply map_strictmono
-        exact hab
-        exact hl.1
-      . intro i hi
-        rw [List.mem_map] at hi
+    refine' ⟨_, map_lt_adjoin_x I, fun a ha => _⟩
+    . refine' ⟨_, fun i hi => _⟩
+      . apply List.chain'_map_of_chain' map_prime (fun a b hab => map_strictmono hab) hl.1
+      . rw [List.mem_map] at hi
         obtain ⟨a, ha, rfl⟩ := hi
-        show map_prime a < adjoin_x I
         calc map_prime a < map_prime I := by apply map_strictmono; apply hl.2; apply ha
           _ < adjoin_x I := by apply map_lt_adjoin_x
-    . apply map_lt_adjoin_x
-    . intro a ha
-      have H : ∃ b : PrimeSpectrum R, b ∈ l ∧ map_prime b = a
+    . have H : ∃ b : PrimeSpectrum R, b ∈ l ∧ map_prime b = a
       . have H2 : l ≠ []
         . intro h
           rw [h] at ha
@@ -141,7 +131,7 @@ lemma ht_adjoin_x_eq_ht_add_one [Nontrivial R] (I : PrimeSpectrum R) : height I
       apply map_strictmono
       apply hl.2
       exact hb
-  . simp
+
 
 /-
 dim R + 1 ≤ dim R[X]

From 2402dd93b2ea145996de37ebc69d37591a3b96e9 Mon Sep 17 00:00:00 2001
From: leopoldmayer <leomayer@uw.edu>
Date: Fri, 16 Jun 2023 00:07:32 -0700
Subject: [PATCH 23/23] removed dependency on false sorried lemma

---
 CommAlg/krull.lean      | 28 ++++++++++++++++++++++++++--
 CommAlg/polynomial.lean | 18 ++++++++++++++++--
 2 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/CommAlg/krull.lean b/CommAlg/krull.lean
index e44fa91..e35a4c5 100644
--- a/CommAlg/krull.lean
+++ b/CommAlg/krull.lean
@@ -95,8 +95,32 @@ lemma le_krullDim_iff (R : Type _) [CommRing R] (n : ℕ) :
     have : height I ≤ krullDim R := by apply height_le_krullDim
     exact le_trans h this
 
-lemma le_krullDim_iff' (R : Type _) [CommRing R] (n : ℕ∞) :
-  n ≤ krullDim R ↔ ∃ I : PrimeSpectrum R, n ≤ (height I : WithBot ℕ∞) := by sorry
+#check ENat.recTopCoe
+
+/- terrible place for this lemma. Also this probably exists somewhere
+  Also this is a terrible proof
+-/
+lemma eq_top_iff (n : WithBot ℕ∞) : n = ⊤ ↔ ∀ m : ℕ, m ≤ n := by
+  aesop
+  induction' n using WithBot.recBotCoe with n
+  . exfalso
+    have := (a 0)
+    simp [not_lt_of_ge] at this
+  induction' n using ENat.recTopCoe with n
+  . rfl
+  . have := a (n + 1)
+    exfalso
+    change (((n + 1) : ℕ∞) : WithBot ℕ∞) ≤ _ at this
+    simp [WithBot.coe_le_coe] at this
+    change ((n + 1) : ℕ∞) ≤ (n : ℕ∞) at this
+    simp [ENat.add_one_le_iff] at this
+
+lemma krullDim_eq_top_iff (R : Type _) [CommRing R] :
+  krullDim R = ⊤ ↔ ∀ (n : ℕ), ∃ I : PrimeSpectrum R, n ≤ height I := by
+  simp [eq_top_iff, le_krullDim_iff]
+  change (∀ (m : ℕ), ∃ I, ((m : ℕ∞) : WithBot ℕ∞) ≤ height I) ↔ _
+  simp [WithBot.coe_le_coe]
+  
 
 /-- The Krull dimension of a local ring is the height of its maximal ideal. -/
 lemma krullDim_eq_height [LocalRing R] : krullDim R = height (closedPoint R) := by
diff --git a/CommAlg/polynomial.lean b/CommAlg/polynomial.lean
index f130868..8dd886a 100644
--- a/CommAlg/polynomial.lean
+++ b/CommAlg/polynomial.lean
@@ -132,7 +132,7 @@ lemma ht_adjoin_x_eq_ht_add_one [Nontrivial R] (I : PrimeSpectrum R) : height I
       apply hl.2
       exact hb
 
-
+#check (⊤ : ℕ∞)
 /-
 dim R + 1 ≤ dim R[X]
 -/
@@ -142,12 +142,26 @@ lemma dim_le_dim_polynomial_add_one [Nontrivial R] :
   rw [hn]
   change ↑(n + 1) ≤ krullDim R[X]
   have := le_of_eq hn.symm
-  rw [le_krullDim_iff'] at this ⊢
+  induction' n using ENat.recTopCoe with n
+  . change krullDim R = ⊤ at hn
+    change ⊤ ≤ krullDim R[X] 
+    rw [krullDim_eq_top_iff] at hn
+    rw [top_le_iff, krullDim_eq_top_iff]
+    intro n
+    obtain ⟨I, hI⟩ := hn n
+    use adjoin_x I
+    calc n ≤ height I := hI
+      _ ≤ height I + 1 := le_self_add
+      _ ≤ height (adjoin_x I) := ht_adjoin_x_eq_ht_add_one I
+  change n ≤ krullDim R at this
+  change (n + 1 : ℕ) ≤ krullDim R[X]
+  rw [le_krullDim_iff] at this ⊢
   obtain ⟨I, hI⟩ := this
   use adjoin_x I
   apply WithBot.coe_mono
   calc n + 1 ≤ height I + 1 := by
         apply add_le_add_right
+        change ((n : ℕ∞) : WithBot ℕ∞) ≤ (height I) at hI
         rw [WithBot.coe_le_coe] at hI
         exact hI
     _ ≤ height (adjoin_x I) := ht_adjoin_x_eq_ht_add_one I
\ No newline at end of file