openAI-math-dataset / lean /OAI /AlgebraicGeometry /CommutingDerivations /LocalizationEquivalence.lean
| import OAI.AlgebraicGeometry.CommutingDerivations.LocalizationSetup | |
| import OAI.AlgebraicGeometry.CommutingDerivations.ParameterBridge | |
| namespace OAI | |
| /-! | |
| Explicit maps between the ambient localization and the polynomial algebra | |
| over Laurent coefficients, using the unrestricted reconstruction formulas. | |
| -/ | |
| noncomputable section | |
| namespace AbhyankarSathaye.CommutingDerivations | |
| open MvPolynomial | |
| def ambientToFree : R →+* RelativePlane := | |
| eval₂Hom (C.comp (algebraMap ℂ LaurentCoefficients)) | |
| (ParameterBridge.values LaurentCoefficients coefficientC coefficientD) | |
| @[simp] theorem ambientToFree_constant (a : ℂ) : | |
| ambientToFree (C a) = C (algebraMap ℂ LaurentCoefficients a) := by | |
| simp [ambientToFree] | |
| @[simp] theorem ambientToFree_h : | |
| ambientToFree h = ParameterBridge.freeH LaurentCoefficients coefficientC coefficientD := by | |
| simp [ambientToFree, h, ParameterBridge.values] | |
| @[simp] theorem ambientToFree_u : | |
| ambientToFree u = ParameterBridge.freeU LaurentCoefficients coefficientC coefficientD := by | |
| simp [ambientToFree, u, ParameterBridge.values] | |
| @[simp] theorem ambientToFree_v : | |
| ambientToFree v = ParameterBridge.freeV LaurentCoefficients coefficientC coefficientD := by | |
| simp [ambientToFree, v, ParameterBridge.values] | |
| @[simp] theorem ambientToFree_w : | |
| ambientToFree w = ParameterBridge.freeW LaurentCoefficients coefficientC coefficientD := by | |
| simp [ambientToFree, w, ParameterBridge.values] | |
| @[simp] theorem ambientToFree_x : ambientToFree x = ParameterBridge.freeX LaurentCoefficients coefficientD := by | |
| simpa [x] using (ParameterBridge.free_relations _ _ _ coefficient_unit).1 | |
| @[simp] theorem ambientToFree_y : ambientToFree y = ParameterBridge.freeY LaurentCoefficients coefficientD := by | |
| simpa [y] using (ParameterBridge.free_relations _ _ _ coefficient_unit).2.1 | |
| @[simp] theorem ambientToFree_s : ambientToFree s = ParameterBridge.freeS LaurentCoefficients coefficientD := by | |
| simpa [s] using (ParameterBridge.free_relations _ _ _ coefficient_unit).2.2 | |
| @[simp] theorem ambientToFree_c : ambientToFree ambientC = C coefficientC := by | |
| simp [ambientC, F, p, ParameterBridge.freeH] | |
| @[simp] theorem ambientToFree_shiftX : ambientToFree shiftX = X 0 := by | |
| simp [shiftX, ParameterBridge.freeX] | |
| @[simp] theorem ambientToFree_shiftY : ambientToFree shiftY = X 1 := by | |
| simp [shiftY, ParameterBridge.freeY] | |
| @[simp] theorem coefficientMap_complex (a : ℂ) : | |
| coefficientMap (algebraMap ℂ LaurentCoefficients a) = loc (C a) := by | |
| rw [IsScalarTower.algebraMap_apply ℂ (Polynomial ℂ) LaurentCoefficients] | |
| change coefficientMap (algebraMap (Polynomial ℂ) LaurentCoefficients (Polynomial.C a)) = _ | |
| simp [coefficientMap, polynomialCoefficientMap, loc, | |
| IsScalarTower.algebraMap_apply ℂ R LocalizedAmbient] | |
| def relativeForward : LocalizedAmbient →+* RelativePlane := | |
| IsLocalization.Away.lift ambientC | |
| (show IsUnit (ambientToFree ambientC) by | |
| rw [ambientToFree_c] | |
| exact (IsUnit.of_mul_eq_one coefficientD coefficient_unit).map C) | |
| @[simp] theorem relativeForward_loc (f : R) : relativeForward (loc f) = ambientToFree f := by | |
| simp [relativeForward, loc] | |
| theorem relativeForward_coefficientMap : | |
| relativeForward.comp coefficientMap = (C : LaurentCoefficients →+* RelativePlane) := by | |
| apply IsLocalization.ringHom_ext (Submonoid.powers (Polynomial.X : Polynomial ℂ)) | |
| apply Polynomial.ringHom_ext | |
| · intro a | |
| simp [coefficientMap, polynomialCoefficientMap, relativeForward, ambientToFree, | |
| IsScalarTower.algebraMap_apply ℂ R LocalizedAmbient, | |
| IsScalarTower.algebraMap_apply ℂ (Polynomial ℂ) LaurentCoefficients] | |
| · simp [coefficientMap, polynomialCoefficientMap, coefficientC] | |
| @[simp] theorem relativeForward_coefficient (a : LaurentCoefficients) : | |
| relativeForward (coefficientMap a) = C a := | |
| RingHom.congr_fun relativeForward_coefficientMap a | |
| @[simp] theorem relativeForward_d : relativeForward localD = C coefficientD := by | |
| rw [← coefficientMap_D, relativeForward_coefficient] | |
| @[simp] theorem relativeForward_alpha : | |
| relativeForward localAlpha = ParameterBridge.freeAlpha LaurentCoefficients coefficientC coefficientD := by | |
| simp [localAlpha, ParameterBridge.freeAlpha] | |
| @[simp] theorem relativeForward_beta : | |
| relativeForward localBeta = ParameterBridge.freeBeta LaurentCoefficients coefficientC coefficientD := by | |
| simp [localBeta, ParameterBridge.freeBeta] | |
| @[simp] theorem relativeForward_shiftX : relativeForward (loc shiftX) = X 0 := by | |
| simp [shiftX, ParameterBridge.freeX] | |
| @[simp] theorem relativeForward_shiftY : relativeForward (loc shiftY) = X 1 := by | |
| simp [shiftY, ParameterBridge.freeY] | |
| @[simp] theorem relativeForward_T : relativeForward localT = X 2 := by | |
| simpa [localT, ParameterBridge.freeU, ParameterBridge.freeV, ParameterBridge.freeW, ParameterBridge.freeG] using | |
| (inverse_parameter | |
| (ParameterBridge.freeH LaurentCoefficients coefficientC coefficientD) | |
| (ParameterBridge.freeX LaurentCoefficients coefficientD) | |
| (ParameterBridge.freeY LaurentCoefficients coefficientD) | |
| (ParameterBridge.freeS LaurentCoefficients coefficientD) | |
| (ParameterBridge.freeAlpha LaurentCoefficients coefficientC coefficientD) | |
| (ParameterBridge.freeBeta LaurentCoefficients coefficientC coefficientD) (X 2 : RelativePlane) | |
| (ParameterBridge.free_bezout LaurentCoefficients coefficientC coefficientD coefficient_unit)) | |
| theorem relativeForward_backward : | |
| relativeForward.comp relativeBackward = RingHom.id RelativePlane := by | |
| apply MvPolynomial.ringHom_ext | |
| · intro a | |
| simp | |
| · intro i | |
| fin_cases i <;> simp [localCoordinates] | |
| @[simp] theorem relativeBackward_freeS : | |
| relativeBackward (ParameterBridge.freeS LaurentCoefficients coefficientD) = loc s := by | |
| simpa [ParameterBridge.freeS, localCoordinates] using local_recover_s | |
| @[simp] theorem relativeBackward_freeX : | |
| relativeBackward (ParameterBridge.freeX LaurentCoefficients coefficientD) = loc x := by | |
| simp [ParameterBridge.freeX, localCoordinates, shiftX] | |
| @[simp] theorem relativeBackward_freeY : | |
| relativeBackward (ParameterBridge.freeY LaurentCoefficients coefficientD) = loc y := by | |
| simp [ParameterBridge.freeY, localCoordinates, shiftY] | |
| @[simp] theorem relativeBackward_freeH : | |
| relativeBackward (ParameterBridge.freeH LaurentCoefficients coefficientC coefficientD) = loc h := by | |
| simpa [ParameterBridge.freeH] using local_section.symm | |
| @[simp] theorem relativeBackward_freeAlpha : | |
| relativeBackward (ParameterBridge.freeAlpha LaurentCoefficients coefficientC coefficientD) = localAlpha := by | |
| simp [ParameterBridge.freeAlpha, localAlpha] | |
| @[simp] theorem relativeBackward_freeBeta : | |
| relativeBackward (ParameterBridge.freeBeta LaurentCoefficients coefficientC coefficientD) = localBeta := by | |
| simp [ParameterBridge.freeBeta, localBeta] | |
| theorem relativeBackward_free_original : | |
| relativeBackward (ParameterBridge.freeU LaurentCoefficients coefficientC coefficientD) = loc u ∧ | |
| relativeBackward (ParameterBridge.freeV LaurentCoefficients coefficientC coefficientD) = loc v ∧ | |
| relativeBackward (ParameterBridge.freeW LaurentCoefficients coefficientC coefficientD) = loc w := by | |
| have hx : (loc u)^3 + loc h * loc v = loc x := by simp [x] | |
| have hy : -(loc u)^2 + loc h * loc w = loc y := by simp [y] | |
| have hs : S (loc h) (loc u) (loc v) (loc w) = loc s := by simp [s] | |
| simpa [ParameterBridge.freeU, ParameterBridge.freeV, ParameterBridge.freeW, ParameterBridge.freeG, localCoordinates, localT] using | |
| original_reconstruction (loc h) (loc x) (loc y) (loc s) localAlpha localBeta | |
| (loc u) (loc v) (loc w) local_bezout hx hy hs | |
| theorem relativeBackward_forward : | |
| relativeBackward.comp relativeForward = RingHom.id LocalizedAmbient := by | |
| apply IsLocalization.ringHom_ext (Submonoid.powers ambientC) | |
| apply MvPolynomial.ringHom_ext | |
| · intro a | |
| change relativeBackward (relativeForward (loc (C a))) = loc (C a) | |
| rw [relativeForward_loc, ambientToFree_constant, relativeBackward_C, coefficientMap_complex] | |
| · intro i | |
| obtain ⟨hu, hv, hw⟩ := relativeBackward_free_original | |
| change relativeBackward (relativeForward (loc (X i))) = loc (X i) | |
| fin_cases i | |
| · change relativeBackward (relativeForward (loc h)) = loc h | |
| rw [relativeForward_loc, ambientToFree_h] | |
| exact relativeBackward_freeH | |
| · change relativeBackward (relativeForward (loc u)) = loc u | |
| rw [relativeForward_loc, ambientToFree_u] | |
| exact hu | |
| · change relativeBackward (relativeForward (loc v)) = loc v | |
| rw [relativeForward_loc, ambientToFree_v] | |
| exact hv | |
| · change relativeBackward (relativeForward (loc w)) = loc w | |
| rw [relativeForward_loc, ambientToFree_w] | |
| exact hw | |
| /-- Actual localized ring equivalence, with explicit maps and both composites. -/ | |
| def localizationRingEquiv : LocalizedAmbient ≃+* RelativePlane := | |
| RingEquiv.ofRingHom relativeForward relativeBackward | |
| relativeForward_backward relativeBackward_forward | |
| /-- The algebra structure is exactly the specified map c ↦ F+1. -/ | |
| @[instance_reducible] | |
| def relativeAlgebra : Algebra LaurentCoefficients LocalizedAmbient := coefficientMap.toAlgebra | |
| /-- Actual equivalence over the Laurent coefficient ring. -/ | |
| def localizationEquiv : | |
| letI := relativeAlgebra | |
| LocalizedAmbient ≃ₐ[LaurentCoefficients] RelativePlane := | |
| letI := relativeAlgebra | |
| { localizationRingEquiv with | |
| commutes' := relativeForward_coefficient } | |
| /-- The same explicit equivalence also preserves the original complex scalars. -/ | |
| def localizationComplexEquiv : LocalizedAmbient ≃ₐ[ℂ] RelativePlane := | |
| { localizationRingEquiv with | |
| commutes' := by | |
| intro a | |
| change relativeForward (algebraMap ℂ LocalizedAmbient a) = | |
| algebraMap ℂ RelativePlane a | |
| rw [IsScalarTower.algebraMap_apply ℂ R LocalizedAmbient] | |
| change relativeForward (loc (C a)) = C (algebraMap ℂ LaurentCoefficients a) | |
| rw [relativeForward_loc, ambientToFree_constant] } | |
| theorem relativeLocalizationContract_proved : RelativeLocalizationContract := by | |
| refine ⟨localizationRingEquiv, relativeForward_coefficient, | |
| relativeForward_shiftX, relativeForward_shiftY, relativeForward_T, ?_⟩ | |
| rfl | |
| end AbhyankarSathaye.CommutingDerivations | |
| end | |
| end OAI | |