Datasets:

roseking
/

openAI-math-dataset

import OAI.AlgebraicGeometry.PlaneCurves.Forms

namespace OAI

/-!
# Equivalence of projective and affine ideal-power multiplicity
-/

section

/-!
# Concrete chart evaluation and local-ring bridges
-/

noncomputable section

namespace Nagata.ProjectiveGeometry

abbrev ChartLocalRing (b : Fin 3) (p : PlanePoint) :=
  AffineMultiplicity.PointLocalRing (chartCoordinates b p)

/-- The homogeneous coordinate functions in the genuine local ring of chart
`b`; the distinguished coordinate is one. -/
def localHomogeneousCoordinates (b : Fin 3) (p : PlanePoint) :
    Fin 3 → ChartLocalRing b p :=
  fun j => if h : j = b then 1 else
    algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)
      (MvPolynomial.X ⟨j, h⟩)

/-- A homogeneous coordinate which is nonzero at the point is a unit in the
local ring. This is the actual denominator used on projective chart overlaps. -/
theorem localHomogeneousCoordinates_isUnit (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
    IsUnit (localHomogeneousCoordinates b p c) := by
  by_cases hcb : c = b
  · simp [localHomogeneousCoordinates, hcb]
  · simp only [localHomogeneousCoordinates, dite_eq_right hcb]
    apply (AffineMultiplicity.residueEval_isUnit (chartCoordinates b p) _).mpr
    simpa [chartCoordinates] using div_ne_zero hc hb

/-- The invertible denominator for the substitution from chart `c` into the
local ring of chart `b`. Its invertibility has just been proved. -/
def localChartDenominatorUnit (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) : (ChartLocalRing b p)ˣ :=
  (localHomogeneousCoordinates_isUnit b c p hb hc).unit

theorem localChartDenominatorUnit_val (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
    (localChartDenominatorUnit b c p hb hc : ChartLocalRing b p) =
      localHomogeneousCoordinates b p c :=
  (localHomogeneousCoordinates_isUnit b c p hb hc).unit_spec

/-- The concrete rational substitution on an overlap of affine projective
charts, with values in the actual local ring at the target point. -/
def chartTransitionToLocalRing (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
    MvPolynomial (ChartVariables c) ℂ →+* ChartLocalRing b p :=
  MvPolynomial.eval₂Hom
    ((algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)).comp
      MvPolynomial.C)
    (fun j => (↑((localChartDenominatorUnit b c p hb hc)⁻¹) : ChartLocalRing b p) *
      localHomogeneousCoordinates b p j.val)

theorem eval₂_dehomogenize {R : Type*} [CommSemiring R]
    (k : ℂ →+* R) (x : Fin 3 → R) (c : Fin 3) (hc : x c = 1)
    (F : MvPolynomial (Fin 3) ℂ) :
    MvPolynomial.eval₂ k (fun j : ChartVariables c => x j.val) (dehomogenize c F) =
      MvPolynomial.eval₂ k x F := by
  rw [dehomogenize, ← MvPolynomial.eval₂_assoc]
  congr 1
  funext j
  by_cases hj : j = c
  · subst j
    simp [hc]
  · simp [hj]

theorem eval₂_localHomogeneousCoordinates (b : Fin 3) (p : PlanePoint)
    (F : MvPolynomial (Fin 3) ℂ) :
    MvPolynomial.eval₂
      ((algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)).comp
        MvPolynomial.C)
      (localHomogeneousCoordinates b p) F =
    algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)
      (dehomogenize b F) := by
  rw [dehomogenize, MvPolynomial.eval₂_comp_left]
  congr 1
  funext j
  by_cases hj : j = b
  · simp [localHomogeneousCoordinates, hj]
  · simp [localHomogeneousCoordinates, hj]

/-- The source chart equation becomes the target chart equation multiplied
by the actual invertible denominator to degree `d`. -/
theorem chartTransition_dehomogenize {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
    chartTransitionToLocalRing b c p hb hc (dehomogenize c F) =
      (↑((localChartDenominatorUnit b c p hb hc)⁻¹) : ChartLocalRing b p) ^ d *
        algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)
          (dehomogenize b F) := by
  let u := localChartDenominatorUnit b c p hb hc
  have hu : (↑(u⁻¹) : ChartLocalRing b p) * localHomogeneousCoordinates b p c = 1 := by
    rw [← localChartDenominatorUnit_val b c p hb hc]
    exact Units.inv_mul u
  change MvPolynomial.eval₂ _
    (fun j : ChartVariables c => (↑(u⁻¹) : ChartLocalRing b p) *
      localHomogeneousCoordinates b p j.val) (dehomogenize c F) = _
  rw [eval₂_dehomogenize _
    (fun j : Fin 3 => (↑(u⁻¹) : ChartLocalRing b p) * localHomogeneousCoordinates b p j) c hu]
  rw [W16.homogeneous_eval₂_scale hF]
  rw [eval₂_localHomogeneousCoordinates]

theorem residueEval_localHomogeneousCoordinates (b : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (j : Fin 3) :
    AffineMultiplicity.residueEval (chartCoordinates b p)
      (localHomogeneousCoordinates b p j) = p.rep j / p.rep b := by
  by_cases hj : j = b
  · subst j
    simp [localHomogeneousCoordinates, hb]
  · simp [localHomogeneousCoordinates, hj, chartCoordinates]

/-- The actual rational substitution sends the target residue point to the
source chart coordinates. This discharges evaluation compatibility. -/
theorem chartTransition_residueEval (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0)
    (f : MvPolynomial (ChartVariables c) ℂ) :
    AffineMultiplicity.residueEval (chartCoordinates b p)
      (chartTransitionToLocalRing b c p hb hc f) =
        MvPolynomial.eval (chartCoordinates c p) f := by
  let ρ := AffineMultiplicity.residueEval (chartCoordinates b p)
  let e := chartTransitionToLocalRing b c p hb hc
  let u := localChartDenominatorUnit b c p hb hc
  have hu : ρ (↑u : ChartLocalRing b p) = p.rep c / p.rep b := by
    rw [localChartDenominatorUnit_val]
    exact residueEval_localHomogeneousCoordinates b p hb c
  have he : ρ.comp e = MvPolynomial.eval (chartCoordinates c p) := by
    apply MvPolynomial.ringHom_ext
    · intro a
      simp [ρ, e, chartTransitionToLocalRing]
    · intro j
      simp only [RingHom.comp_apply, e, chartTransitionToLocalRing,
        MvPolynomial.eval₂Hom_X', MvPolynomial.eval_X]
      change ρ ((↑(u⁻¹) : ChartLocalRing b p) *
        localHomogeneousCoordinates b p j.val) = p.rep j.val / p.rep c
      rw [map_mul, map_units_inv, hu,
        residueEval_localHomogeneousCoordinates b p hb j.val]
      rw [mul_comm, ← div_eq_mul_inv, div_div_div_cancel_right₀ hb]
  exact RingHom.congr_fun he f

/-- A coordinate substitution respecting evaluation transports all ideal-power
orders into the kernel of the target evaluation homomorphism. This applies to
rational chart substitutions after mapping into an actual local ring. -/
theorem orderAtLeast_map_into_kernel {σ K R : Type*} [CommRing K] [CommRing R]
    (p : σ → K) (e : MvPolynomial σ K →+* R) (ρ : R →+* K)
    (he : ∀ f, ρ (e f) = MvPolynomial.eval p f)
    (m : ℕ) (f : MvPolynomial σ K)
    (hf : AffineMultiplicity.orderAtLeast p m f) :
    e f ∈ (RingHom.ker ρ) ^ m := by
  have hle : AffineMultiplicity.pointIdeal p ≤ Ideal.comap e (RingHom.ker ρ) := by
    intro g hg
    change ρ (e g) = 0
    rw [he]
    exact (AffineMultiplicity.pointIdeal_mem_iff p g).mp hg
  have hp : f ∈ (Ideal.comap e (RingHom.ker ρ)) ^ m :=
    Ideal.pow_right_mono hle m hf
  exact Ideal.le_comap_pow e m hp

theorem chart_order_transport_via_residue {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) (m : ℕ)
    (ρ : ChartLocalRing b p →+* ℂ)
    (hker : RingHom.ker ρ = IsLocalRing.maximalIdeal (ChartLocalRing b p))
    (heval : ∀ f, ρ (chartTransitionToLocalRing b c p hb hc f) =
      MvPolynomial.eval (chartCoordinates c p) f)
    (hf : AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F)) :
    AffineMultiplicity.orderAtLeast (chartCoordinates b p) m (dehomogenize b F) := by
  have hmap := orderAtLeast_map_into_kernel (chartCoordinates c p)
    (chartTransitionToLocalRing b c p hb hc) ρ heval m (dehomogenize c F) hf
  rw [hker, chartTransition_dehomogenize hF b c p hb hc] at hmap
  have hunit : IsUnit ((↑((localChartDenominatorUnit b c p hb hc)⁻¹) :
      ChartLocalRing b p) ^ d) :=
    ((localChartDenominatorUnit b c p hb hc)⁻¹).isUnit.pow d
  have hbare := (Ideal.unit_mul_mem_iff_mem
    (IsLocalRing.maximalIdeal (ChartLocalRing b p) ^ m) hunit).mp hmap
  exact (AffineMultiplicity.localOrderAtLeast_iff (chartCoordinates b p) m
    (dehomogenize b F)).mp hbare

/-- Ordinary affine ideal-power orders agree on every projective chart
overlap for a homogeneous form, at every nonnegative order. -/
theorem chart_order_transport {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (b c : Fin 3) (p : PlanePoint)
    (hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) (m : ℕ)
    (hf : AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F)) :
    AffineMultiplicity.orderAtLeast (chartCoordinates b p) m (dehomogenize b F) :=
  chart_order_transport_via_residue hF b c p hb hc m
    (AffineMultiplicity.residueEval (chartCoordinates b p))
    (AffineMultiplicity.ker_residueEval (chartCoordinates b p))
    (chartTransition_residueEval b c p hb hc) hf

/-- One containing chart suffices for every multiplicity order. All residue,
localization, and homogeneous-scaling requirements have concrete witnesses. -/
theorem multiplicityAtLeast_iff_some_chart {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (p : PlanePoint) (m : ℕ) :
    multiplicityAtLeast F p m ↔
      ∃ c : Fin 3, p.rep c ≠ 0 ∧
        AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F) := by
  constructor
  · intro h
    obtain ⟨c, hc⟩ := chart_exists p
    exact ⟨c, hc, h c hc⟩
  · rintro ⟨c, hc, hf⟩ b hb
    exact chart_order_transport hF b c p hb hc m hf

theorem multiplicityAtLeast_iff_chart {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) (m : ℕ) :
    multiplicityAtLeast F p m ↔
      AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F) := by
  constructor
  · intro h
    exact h c hc
  · intro h b hb
    exact chart_order_transport hF b c p hb hc m h

/-- Nonzero scalar multiples define the same local multiplicity conditions,
including every nonreduced order. This is the equation-class descent bridge. -/
theorem multiplicityAtLeast_C_mul_iff (a : ℂ) (ha : a ≠ 0)
    (F : MvPolynomial (Fin 3) ℂ) (p : PlanePoint) (m : ℕ) :
    multiplicityAtLeast (MvPolynomial.C a * F) p m ↔ multiplicityAtLeast F p m := by
  constructor
  · intro h c hc
    have hf := h c hc
    rw [dehomogenize_mul, dehomogenize_C] at hf
    exact (AffineMultiplicity.orderAtLeast_nonvanishing_mul_iff
      (chartCoordinates c p) m (dehomogenize c F) (MvPolynomial.C a)
      (by simpa using ha)).mp hf
  · intro h c hc
    rw [dehomogenize_mul, dehomogenize_C]
    exact (AffineMultiplicity.orderAtLeast_nonvanishing_mul_iff
      (chartCoordinates c p) m (dehomogenize c F) (MvPolynomial.C a)
      (by simpa using ha)).mpr (h c hc)

theorem eval_dehomogenize (F : MvPolynomial (Fin 3) ℂ)
    (p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) :
    MvPolynomial.eval (chartCoordinates c p) (dehomogenize c F) =
      MvPolynomial.eval (fun j => p.rep j / p.rep c) F := by
  exact eval₂_dehomogenize (RingHom.id ℂ) (fun j => p.rep j / p.rep c) c
    (div_self hc) F

theorem eval_dehomogenize_homogeneous {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) :
    MvPolynomial.eval (chartCoordinates c p) (dehomogenize c F) =
      (p.rep c)⁻¹ ^ d * MvPolynomial.eval p.rep F := by
  rw [eval_dehomogenize F p c hc]
  simpa [div_eq_mul_inv, mul_comm] using
    W16.homogeneous_eval_scale hF p.rep ((p.rep c)⁻¹)

/-- First-order vanishing in any containing chart agrees with vanishing of
the original homogeneous form at the point's representative. -/
theorem chart_order_one_iff {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) :
    AffineMultiplicity.orderAtLeast (chartCoordinates c p) 1 (dehomogenize c F) ↔
      MvPolynomial.eval p.rep F = 0 := by
  rw [AffineMultiplicity.orderAtLeast_one_iff,
    eval_dehomogenize_homogeneous hF p c hc]
  simp only [mul_eq_zero, pow_ne_zero d (inv_ne_zero hc), false_or]

theorem multiplicityAtLeast_one_iff {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (p : PlanePoint) :
    multiplicityAtLeast F p 1 ↔ MvPolynomial.eval p.rep F = 0 := by
  constructor
  · intro h
    obtain ⟨c, hc⟩ := chart_exists p
    exact (chart_order_one_iff hF p c hc).mp (h c hc)
  · intro h c hc
    exact (chart_order_one_iff hF p c hc).mpr h

/-- At order one, one containing chart suffices; this is proved from the
homogeneous scaling identity rather than assumed coordinate invariance. -/
theorem multiplicityAtLeast_one_iff_some_chart {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
    (hF : F.IsHomogeneous d) (p : PlanePoint) :
    multiplicityAtLeast F p 1 ↔
      ∃ c : Fin 3, p.rep c ≠ 0 ∧
        AffineMultiplicity.orderAtLeast (chartCoordinates c p) 1 (dehomogenize c F) := by
  constructor
  · intro h
    obtain ⟨c, hc⟩ := chart_exists p
    exact ⟨c, hc, h c hc⟩
  · rintro ⟨c, hc, h⟩
    exact (multiplicityAtLeast_one_iff hF p).mpr ((chart_order_one_iff hF p c hc).mp h)

theorem multiplicityAtLeast_iff_localOrder (F : MvPolynomial (Fin 3) ℂ)
    (p : PlanePoint) (m : ℕ) :
    multiplicityAtLeast F p m ↔ ∀ c : Fin 3, p.rep c ≠ 0 →
      AffineMultiplicity.localOrderAtLeast (chartCoordinates c p) m (dehomogenize c F) := by
  simp only [multiplicityAtLeast, AffineMultiplicity.localOrderAtLeast_iff]

end Nagata.ProjectiveGeometry

end
end

end OAI

	import OAI.AlgebraicGeometry.PlaneCurves.Forms

	namespace OAI

	/-!
	# Equivalence of projective and affine ideal-power multiplicity
	-/

	section

	/-!
	# Concrete chart evaluation and local-ring bridges
	-/

	noncomputable section

	namespace Nagata.ProjectiveGeometry

	abbrev ChartLocalRing (b : Fin 3) (p : PlanePoint) :=
	AffineMultiplicity.PointLocalRing (chartCoordinates b p)

	/-- The homogeneous coordinate functions in the genuine local ring of chart
	`b`; the distinguished coordinate is one. -/
	def localHomogeneousCoordinates (b : Fin 3) (p : PlanePoint) :
	Fin 3 → ChartLocalRing b p :=
	fun j => if h : j = b then 1 else
	algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)
	(MvPolynomial.X ⟨j, h⟩)

	/-- A homogeneous coordinate which is nonzero at the point is a unit in the
	local ring. This is the actual denominator used on projective chart overlaps. -/
	theorem localHomogeneousCoordinates_isUnit (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
	IsUnit (localHomogeneousCoordinates b p c) := by
	by_cases hcb : c = b
	· simp [localHomogeneousCoordinates, hcb]
	· simp only [localHomogeneousCoordinates, dite_eq_right hcb]
	apply (AffineMultiplicity.residueEval_isUnit (chartCoordinates b p) _).mpr
	simpa [chartCoordinates] using div_ne_zero hc hb

	/-- The invertible denominator for the substitution from chart `c` into the
	local ring of chart `b`. Its invertibility has just been proved. -/
	def localChartDenominatorUnit (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) : (ChartLocalRing b p)ˣ :=
	(localHomogeneousCoordinates_isUnit b c p hb hc).unit

	theorem localChartDenominatorUnit_val (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
	(localChartDenominatorUnit b c p hb hc : ChartLocalRing b p) =
	localHomogeneousCoordinates b p c :=
	(localHomogeneousCoordinates_isUnit b c p hb hc).unit_spec

	/-- The concrete rational substitution on an overlap of affine projective
	charts, with values in the actual local ring at the target point. -/
	def chartTransitionToLocalRing (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
	MvPolynomial (ChartVariables c) ℂ →+* ChartLocalRing b p :=
	MvPolynomial.eval₂Hom
	((algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)).comp
	MvPolynomial.C)
	(fun j => (↑((localChartDenominatorUnit b c p hb hc)⁻¹) : ChartLocalRing b p) *
	localHomogeneousCoordinates b p j.val)

	theorem eval₂_dehomogenize {R : Type*} [CommSemiring R]
	(k : ℂ →+* R) (x : Fin 3 → R) (c : Fin 3) (hc : x c = 1)
	(F : MvPolynomial (Fin 3) ℂ) :
	MvPolynomial.eval₂ k (fun j : ChartVariables c => x j.val) (dehomogenize c F) =
	MvPolynomial.eval₂ k x F := by
	rw [dehomogenize, ← MvPolynomial.eval₂_assoc]
	congr 1
	funext j
	by_cases hj : j = c
	· subst j
	simp [hc]
	· simp [hj]

	theorem eval₂_localHomogeneousCoordinates (b : Fin 3) (p : PlanePoint)
	(F : MvPolynomial (Fin 3) ℂ) :
	MvPolynomial.eval₂
	((algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)).comp
	MvPolynomial.C)
	(localHomogeneousCoordinates b p) F =
	algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)
	(dehomogenize b F) := by
	rw [dehomogenize, MvPolynomial.eval₂_comp_left]
	congr 1
	funext j
	by_cases hj : j = b
	· simp [localHomogeneousCoordinates, hj]
	· simp [localHomogeneousCoordinates, hj]

	/-- The source chart equation becomes the target chart equation multiplied
	by the actual invertible denominator to degree `d`. -/
	theorem chartTransition_dehomogenize {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) :
	chartTransitionToLocalRing b c p hb hc (dehomogenize c F) =
	(↑((localChartDenominatorUnit b c p hb hc)⁻¹) : ChartLocalRing b p) ^ d *
	algebraMap (MvPolynomial (ChartVariables b) ℂ) (ChartLocalRing b p)
	(dehomogenize b F) := by
	let u := localChartDenominatorUnit b c p hb hc
	have hu : (↑(u⁻¹) : ChartLocalRing b p) * localHomogeneousCoordinates b p c = 1 := by
	rw [← localChartDenominatorUnit_val b c p hb hc]
	exact Units.inv_mul u
	change MvPolynomial.eval₂ _
	(fun j : ChartVariables c => (↑(u⁻¹) : ChartLocalRing b p) *
	localHomogeneousCoordinates b p j.val) (dehomogenize c F) = _
	rw [eval₂_dehomogenize _
	(fun j : Fin 3 => (↑(u⁻¹) : ChartLocalRing b p) * localHomogeneousCoordinates b p j) c hu]
	rw [W16.homogeneous_eval₂_scale hF]
	rw [eval₂_localHomogeneousCoordinates]

	theorem residueEval_localHomogeneousCoordinates (b : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (j : Fin 3) :
	AffineMultiplicity.residueEval (chartCoordinates b p)
	(localHomogeneousCoordinates b p j) = p.rep j / p.rep b := by
	by_cases hj : j = b
	· subst j
	simp [localHomogeneousCoordinates, hb]
	· simp [localHomogeneousCoordinates, hj, chartCoordinates]

	/-- The actual rational substitution sends the target residue point to the
	source chart coordinates. This discharges evaluation compatibility. -/
	theorem chartTransition_residueEval (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0)
	(f : MvPolynomial (ChartVariables c) ℂ) :
	AffineMultiplicity.residueEval (chartCoordinates b p)
	(chartTransitionToLocalRing b c p hb hc f) =
	MvPolynomial.eval (chartCoordinates c p) f := by
	let ρ := AffineMultiplicity.residueEval (chartCoordinates b p)
	let e := chartTransitionToLocalRing b c p hb hc
	let u := localChartDenominatorUnit b c p hb hc
	have hu : ρ (↑u : ChartLocalRing b p) = p.rep c / p.rep b := by
	rw [localChartDenominatorUnit_val]
	exact residueEval_localHomogeneousCoordinates b p hb c
	have he : ρ.comp e = MvPolynomial.eval (chartCoordinates c p) := by
	apply MvPolynomial.ringHom_ext
	· intro a
	simp [ρ, e, chartTransitionToLocalRing]
	· intro j
	simp only [RingHom.comp_apply, e, chartTransitionToLocalRing,
	MvPolynomial.eval₂Hom_X', MvPolynomial.eval_X]
	change ρ ((↑(u⁻¹) : ChartLocalRing b p) *
	localHomogeneousCoordinates b p j.val) = p.rep j.val / p.rep c
	rw [map_mul, map_units_inv, hu,
	residueEval_localHomogeneousCoordinates b p hb j.val]
	rw [mul_comm, ← div_eq_mul_inv, div_div_div_cancel_right₀ hb]
	exact RingHom.congr_fun he f

	/-- A coordinate substitution respecting evaluation transports all ideal-power
	orders into the kernel of the target evaluation homomorphism. This applies to
	rational chart substitutions after mapping into an actual local ring. -/
	theorem orderAtLeast_map_into_kernel {σ K R : Type*} [CommRing K] [CommRing R]
	(p : σ → K) (e : MvPolynomial σ K →+* R) (ρ : R →+* K)
	(he : ∀ f, ρ (e f) = MvPolynomial.eval p f)
	(m : ℕ) (f : MvPolynomial σ K)
	(hf : AffineMultiplicity.orderAtLeast p m f) :
	e f ∈ (RingHom.ker ρ) ^ m := by
	have hle : AffineMultiplicity.pointIdeal p ≤ Ideal.comap e (RingHom.ker ρ) := by
	intro g hg
	change ρ (e g) = 0
	rw [he]
	exact (AffineMultiplicity.pointIdeal_mem_iff p g).mp hg
	have hp : f ∈ (Ideal.comap e (RingHom.ker ρ)) ^ m :=
	Ideal.pow_right_mono hle m hf
	exact Ideal.le_comap_pow e m hp

	theorem chart_order_transport_via_residue {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) (m : ℕ)
	(ρ : ChartLocalRing b p →+* ℂ)
	(hker : RingHom.ker ρ = IsLocalRing.maximalIdeal (ChartLocalRing b p))
	(heval : ∀ f, ρ (chartTransitionToLocalRing b c p hb hc f) =
	MvPolynomial.eval (chartCoordinates c p) f)
	(hf : AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F)) :
	AffineMultiplicity.orderAtLeast (chartCoordinates b p) m (dehomogenize b F) := by
	have hmap := orderAtLeast_map_into_kernel (chartCoordinates c p)
	(chartTransitionToLocalRing b c p hb hc) ρ heval m (dehomogenize c F) hf
	rw [hker, chartTransition_dehomogenize hF b c p hb hc] at hmap
	have hunit : IsUnit ((↑((localChartDenominatorUnit b c p hb hc)⁻¹) :
	ChartLocalRing b p) ^ d) :=
	((localChartDenominatorUnit b c p hb hc)⁻¹).isUnit.pow d
	have hbare := (Ideal.unit_mul_mem_iff_mem
	(IsLocalRing.maximalIdeal (ChartLocalRing b p) ^ m) hunit).mp hmap
	exact (AffineMultiplicity.localOrderAtLeast_iff (chartCoordinates b p) m
	(dehomogenize b F)).mp hbare

	/-- Ordinary affine ideal-power orders agree on every projective chart
	overlap for a homogeneous form, at every nonnegative order. -/
	theorem chart_order_transport {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (b c : Fin 3) (p : PlanePoint)
	(hb : p.rep b ≠ 0) (hc : p.rep c ≠ 0) (m : ℕ)
	(hf : AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F)) :
	AffineMultiplicity.orderAtLeast (chartCoordinates b p) m (dehomogenize b F) :=
	chart_order_transport_via_residue hF b c p hb hc m
	(AffineMultiplicity.residueEval (chartCoordinates b p))
	(AffineMultiplicity.ker_residueEval (chartCoordinates b p))
	(chartTransition_residueEval b c p hb hc) hf

	/-- One containing chart suffices for every multiplicity order. All residue,
	localization, and homogeneous-scaling requirements have concrete witnesses. -/
	theorem multiplicityAtLeast_iff_some_chart {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (p : PlanePoint) (m : ℕ) :
	multiplicityAtLeast F p m ↔
	∃ c : Fin 3, p.rep c ≠ 0 ∧
	AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F) := by
	constructor
	· intro h
	obtain ⟨c, hc⟩ := chart_exists p
	exact ⟨c, hc, h c hc⟩
	· rintro ⟨c, hc, hf⟩ b hb
	exact chart_order_transport hF b c p hb hc m hf

	theorem multiplicityAtLeast_iff_chart {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) (m : ℕ) :
	multiplicityAtLeast F p m ↔
	AffineMultiplicity.orderAtLeast (chartCoordinates c p) m (dehomogenize c F) := by
	constructor
	· intro h
	exact h c hc
	· intro h b hb
	exact chart_order_transport hF b c p hb hc m h

	/-- Nonzero scalar multiples define the same local multiplicity conditions,
	including every nonreduced order. This is the equation-class descent bridge. -/
	theorem multiplicityAtLeast_C_mul_iff (a : ℂ) (ha : a ≠ 0)
	(F : MvPolynomial (Fin 3) ℂ) (p : PlanePoint) (m : ℕ) :
	multiplicityAtLeast (MvPolynomial.C a * F) p m ↔ multiplicityAtLeast F p m := by
	constructor
	· intro h c hc
	have hf := h c hc
	rw [dehomogenize_mul, dehomogenize_C] at hf
	exact (AffineMultiplicity.orderAtLeast_nonvanishing_mul_iff
	(chartCoordinates c p) m (dehomogenize c F) (MvPolynomial.C a)
	(by simpa using ha)).mp hf
	· intro h c hc
	rw [dehomogenize_mul, dehomogenize_C]
	exact (AffineMultiplicity.orderAtLeast_nonvanishing_mul_iff
	(chartCoordinates c p) m (dehomogenize c F) (MvPolynomial.C a)
	(by simpa using ha)).mpr (h c hc)

	theorem eval_dehomogenize (F : MvPolynomial (Fin 3) ℂ)
	(p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) :
	MvPolynomial.eval (chartCoordinates c p) (dehomogenize c F) =
	MvPolynomial.eval (fun j => p.rep j / p.rep c) F := by
	exact eval₂_dehomogenize (RingHom.id ℂ) (fun j => p.rep j / p.rep c) c
	(div_self hc) F

	theorem eval_dehomogenize_homogeneous {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) :
	MvPolynomial.eval (chartCoordinates c p) (dehomogenize c F) =
	(p.rep c)⁻¹ ^ d * MvPolynomial.eval p.rep F := by
	rw [eval_dehomogenize F p c hc]
	simpa [div_eq_mul_inv, mul_comm] using
	W16.homogeneous_eval_scale hF p.rep ((p.rep c)⁻¹)

	/-- First-order vanishing in any containing chart agrees with vanishing of
	the original homogeneous form at the point's representative. -/
	theorem chart_order_one_iff {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (p : PlanePoint) (c : Fin 3) (hc : p.rep c ≠ 0) :
	AffineMultiplicity.orderAtLeast (chartCoordinates c p) 1 (dehomogenize c F) ↔
	MvPolynomial.eval p.rep F = 0 := by
	rw [AffineMultiplicity.orderAtLeast_one_iff,
	eval_dehomogenize_homogeneous hF p c hc]
	simp only [mul_eq_zero, pow_ne_zero d (inv_ne_zero hc), false_or]

	theorem multiplicityAtLeast_one_iff {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (p : PlanePoint) :
	multiplicityAtLeast F p 1 ↔ MvPolynomial.eval p.rep F = 0 := by
	constructor
	· intro h
	obtain ⟨c, hc⟩ := chart_exists p
	exact (chart_order_one_iff hF p c hc).mp (h c hc)
	· intro h c hc
	exact (chart_order_one_iff hF p c hc).mpr h

	/-- At order one, one containing chart suffices; this is proved from the
	homogeneous scaling identity rather than assumed coordinate invariance. -/
	theorem multiplicityAtLeast_one_iff_some_chart {F : MvPolynomial (Fin 3) ℂ} {d : ℕ}
	(hF : F.IsHomogeneous d) (p : PlanePoint) :
	multiplicityAtLeast F p 1 ↔
	∃ c : Fin 3, p.rep c ≠ 0 ∧
	AffineMultiplicity.orderAtLeast (chartCoordinates c p) 1 (dehomogenize c F) := by
	constructor
	· intro h
	obtain ⟨c, hc⟩ := chart_exists p
	exact ⟨c, hc, h c hc⟩
	· rintro ⟨c, hc, h⟩
	exact (multiplicityAtLeast_one_iff hF p).mpr ((chart_order_one_iff hF p c hc).mp h)

	theorem multiplicityAtLeast_iff_localOrder (F : MvPolynomial (Fin 3) ℂ)
	(p : PlanePoint) (m : ℕ) :
	multiplicityAtLeast F p m ↔ ∀ c : Fin 3, p.rep c ≠ 0 →
	AffineMultiplicity.localOrderAtLeast (chartCoordinates c p) m (dehomogenize c F) := by
	simp only [multiplicityAtLeast, AffineMultiplicity.localOrderAtLeast_iff]

	end Nagata.ProjectiveGeometry

	end
	end

	end OAI