| import Mathlib |
| import OAI.NumberTheory.QuadraticForms.ScalarExtension |
|
|
| namespace OAI |
|
|
| /-! Local trace and cyclotomic length comparisons. -/ |
|
|
|
|
|
|
| namespace MultiplicityCounterexample.CompletionPlaceMaps |
| noncomputable section |
| open Filter |
| open scoped Topology |
|
|
| section RestrictedNorm |
| variable (K : Type*) [NormedField K] [CharZero K] |
|
|
| def rationalAbs : AbsoluteValue ℚ ℝ where |
| toFun q := ‖(q : K)‖ |
| map_mul' x y := by simp |
| nonneg' x := norm_nonneg _ |
| eq_zero' x := by simp |
| add_le' x y := by simpa using norm_add_le (x : K) (y : K) |
|
|
| @[simp] lemma rationalAbs_apply (q : ℚ) : rationalAbs K q = ‖(q : K)‖ := rfl |
|
|
| variable {K} |
| |
| def fromWithVal (p : ℕ) [Fact p.Prime] : WithVal (Rat.padicValuation p) →+* K := |
| (Rat.castHom K).comp (WithVal.equiv (Rat.padicValuation p)).toRingHom |
|
|
| lemma continuous_fromWithVal (p : ℕ) [Fact p.Prime] |
| (h : (rationalAbs K).IsEquiv (Rat.AbsoluteValue.padic p)) : |
| Continuous (fromWithVal (K := K) p) := by |
| obtain ⟨t, ht, heq⟩ := AbsoluteValue.isEquiv_iff_exists_rpow_eq.mp h.symm |
| have hn : Continuous fun q : WithVal (Rat.padicValuation p) => |
| ‖((WithVal.equiv (Rat.padicValuation p)) q : Padic p)‖ := |
| Padic.isUniformInducing_cast_withVal.uniformContinuous.continuous.norm |
| have hc : Continuous fun q : WithVal (Rat.padicValuation p) => |
| ‖fromWithVal (K := K) p q‖ := by |
| have hr := hn.rpow_const (p := t) (fun _ => Or.inr ht.le) |
| convert hr using 1 |
| ext q |
| have e := congrFun heq ((WithVal.equiv (Rat.padicValuation p)) q) |
| change ‖(((WithVal.equiv (Rat.padicValuation p)) q : ℚ) : K)‖ = _ |
| rw [Padic.eq_padicNorm] |
| exact e.symm |
| apply continuous_of_tendsto_nhds_zero (fromWithVal (K := K) p) |
| apply tendsto_zero_iff_norm_tendsto_zero.mpr |
| simpa using hc.continuousAt.tendsto (x := 0) |
|
|
| variable [CompleteSpace K] |
|
|
| def padicMap (p : ℕ) [Fact p.Prime] |
| (h : (rationalAbs K).IsEquiv (Rat.AbsoluteValue.padic p)) : Padic p →+* K := |
| (UniformSpace.Completion.extensionHom (fromWithVal (K := K) p) |
| (continuous_fromWithVal p h)).comp Padic.withValRingEquiv.symm.toRingHom |
|
|
| theorem exists_padicMap |
| (hne : (rationalAbs K).IsNontrivial) |
| (hbd : ∀ n : ℕ, ‖(n : K)‖ ≤ 1) : |
| ∃ p : ℕ, ∃ _ : Fact p.Prime, Nonempty (Padic p →+* K) := by |
| obtain ⟨p, ⟨hp, he⟩, _⟩ := |
| Rat.AbsoluteValue.equiv_padic_of_bounded hne (by simpa using hbd) |
| let := hp |
| exact ⟨p, hp, ⟨padicMap p he⟩⟩ |
|
|
| end RestrictedNorm |
|
|
| section FinitePlace |
| open scoped NumberField |
| open IsDedekindDomain |
| variable (F : Type*) [Field F] [NumberField F] |
| (v : HeightOneSpectrum (𝓞 F)) |
|
|
| instance finitePlaceCharZero : CharZero (v.adicCompletion F) := |
| charZero_of_injective_ringHom (NumberField.FinitePlace.embedding v).injective |
|
|
| lemma rationalAbs_finitePlace_nontrivial : |
| (rationalAbs (v.adicCompletion F)).IsNontrivial := by |
| obtain ⟨z, hz, hz0⟩ := (Submodule.ne_bot_iff _).mp |
| (Ideal.IsIntegral.under_ne_bot ℤ v.ne_bot) |
| refine ⟨(z : ℚ), by exact_mod_cast hz0, ?_⟩ |
| have hv := (NumberField.FinitePlace.norm_lt_one_iff_mem F v |
| ((algebraMap ℤ (𝓞 F)) z)).mpr hz |
| have hv' : ‖(z : v.adicCompletion F)‖ < 1 := by simpa using hv |
| simpa using ne_of_lt hv' |
|
|
| lemma rationalAbs_finitePlace_bounded (n : ℕ) : |
| ‖(n : v.adicCompletion F)‖ ≤ 1 := by |
| have hn := NumberField.FinitePlace.norm_embedding (K := F) v (n : F) |
| simp only [map_natCast] at hn |
| rw [hn] |
| exact NumberField.HeightOneSpectrum.adicAbv_natCast_le_one F v n |
|
|
| theorem exists_finitePlace_padicAlgHom : |
| ∃ p : ℕ, ∃ _ : Fact p.Prime, Nonempty (Padic p →ₐ[ℚ] v.adicCompletion F) := by |
| obtain ⟨p, hp, ⟨f⟩⟩ := exists_padicMap |
| (rationalAbs_finitePlace_nontrivial F v) (rationalAbs_finitePlace_bounded F v) |
| exact ⟨p, hp, ⟨f.toRatAlgHom⟩⟩ |
|
|
| end FinitePlace |
|
|
| open NumberField |
| variable (F : Type*) [Field F] [NumberField F] (v : InfinitePlace F) |
|
|
| instance infinitePlaceCharZero : CharZero v.Completion := |
| charZero_of_injective_ringHom (algebraMap F v.Completion).injective |
|
|
| def infinitePlaceRealAlgHom : ℝ →ₐ[ℚ] v.Completion := by |
| classical |
| by_cases hv : v.IsReal |
| · exact (InfinitePlace.Completion.ringEquivRealOfIsReal hv).symm.toRingHom.toRatAlgHom |
| · exact ((InfinitePlace.Completion.ringEquivComplexOfIsComplex |
| (InfinitePlace.not_isReal_iff_isComplex.mp hv)).symm.toRingHom.comp |
| (algebraMap ℝ ℂ)).toRatAlgHom |
|
|
|
|
| end |
| end MultiplicityCounterexample.CompletionPlaceMaps |
|
|
| namespace MultiplicityCounterexample.NumberFieldTraceLocalComparison |
| noncomputable section |
| open TensorProduct |
| open LinearMap (BilinForm) |
| open scoped NumberField MultiplicityCounterexample.TensorAlgebraModule |
| open CompletionTraceDescent CompletionPlaceMaps |
| variable {F V W : Type*} [Field F] [NumberField F] |
| [AddCommGroup V] [Module ℚ V] [Module F V] [IsScalarTower ℚ F V] |
| [AddCommGroup W] [Module ℚ W] [Module F W] [IsScalarTower ℚ F W] |
|
|
| def LocalTraceIsometry (A : Type*) [CommRing A] [Algebra ℚ A] |
| (B₁ : BilinForm F V) (B₂ : BilinForm F W) (z : F) : Prop := |
| ∃ e : (A ⊗[ℚ] V) ≃ₗ[A] (A ⊗[ℚ] W), |
| (∀ x, e (TensorAlgebraModule.rightAction z x) = |
| TensorAlgebraModule.rightAction z (e x)) ∧ |
| (∀ x y, (traceForm (R := ℚ) B₂).baseChange A (e x) (e y) = |
| (traceForm (R := ℚ) B₁).baseChange A x y) |
|
|
| theorem isometric_at_every_finitePlace |
| (B₁ : BilinForm F V) (B₂ : BilinForm F W) |
| (z : F) (hzgen : Algebra.adjoin ℚ ({z} : Set F) = ⊤) |
| (hloc : ∀ (p : ℕ) (_ : Fact p.Prime), LocalTraceIsometry (Padic p) B₁ B₂ z) |
| (v : IsDedekindDomain.HeightOneSpectrum (𝓞 F)) : |
| Nonempty ((B₁.baseChange (v.adicCompletion F)).IsometryEquiv |
| (B₂.baseChange (v.adicCompletion F))) := by |
| obtain ⟨p, hp, ⟨f⟩⟩ := exists_finitePlace_padicAlgHom F v |
| let : Algebra (Padic p) (v.adicCompletion F) := f.toRingHom.toAlgebra |
| let : IsScalarTower ℚ (Padic p) (v.adicCompletion F) := |
| IsScalarTower.of_algebraMap_eq (fun q => (f.commutes q).symm) |
| obtain ⟨e, hz, he⟩ := hloc p hp |
| exact ⟨descendTraceAtPlace (K := v.adicCompletion F) B₁ B₂ z hzgen e hz he⟩ |
|
|
| theorem isometric_at_every_infinitePlace |
| (B₁ : BilinForm F V) (B₂ : BilinForm F W) |
| (z : F) (hzgen : Algebra.adjoin ℚ ({z} : Set F) = ⊤) |
| (hreal : LocalTraceIsometry ℝ B₁ B₂ z) |
| (v : NumberField.InfinitePlace F) : |
| Nonempty ((B₁.baseChange v.Completion).IsometryEquiv (B₂.baseChange v.Completion)) := by |
| let f := infinitePlaceRealAlgHom F v |
| let : Algebra ℝ v.Completion := f.toRingHom.toAlgebra |
| let : IsScalarTower ℚ ℝ v.Completion := |
| IsScalarTower.of_algebraMap_eq (fun q => (f.commutes q).symm) |
| obtain ⟨e, hz, he⟩ := hreal |
| exact ⟨descendTraceAtPlace (K := v.Completion) B₁ B₂ z hzgen e hz he⟩ |
|
|
| end |
| end MultiplicityCounterexample.NumberFieldTraceLocalComparison |
|
|
| namespace MultiplicityCounterexample.TraceHermitian |
| open LinearMap (BilinForm) |
| noncomputable section |
| variable {F E V W : Type*} [Field F] [Field E] [Algebra F E] |
| [FiniteDimensional F E] [Algebra.IsSeparable F E] |
| [AddCommGroup V] [Module E V] [Module F V] [IsScalarTower F E V] |
| [AddCommGroup W] [Module E W] [Module F W] [IsScalarTower F E W] |
|
|
| lemma trace_pairing_ext {x y : E} |
| (h : ∀ a : E, Algebra.trace F E (a*x) = Algebra.trace F E (a*y)) : x = y := by |
| apply ((Algebra.traceForm F E).toDual (traceForm_nondegenerate F E)).injective |
| ext a |
| simpa only [BilinForm.toDual_def,Algebra.traceForm_apply,mul_comm] using h a |
|
|
| def traceFunctional (B : BilinForm F V) (x y : V) : Module.Dual F E where |
| toFun a := B (a • x) y |
| map_add' a b := by simp only [add_smul,map_add,LinearMap.add_apply] |
| map_smul' a b := by simp only [smul_assoc,map_smul,LinearMap.smul_apply,smul_eq_mul,RingHom.id_apply] |
|
|
| def lift (B : BilinForm F V) (x y : V) : E := |
| ((Algebra.traceForm F E).toDual (traceForm_nondegenerate F E)).symm |
| (traceFunctional B x y) |
|
|
| lemma trace_lift (B : BilinForm F V) (x y : V) (a : E) : |
| Algebra.trace F E (a * lift (E := E) B x y) = B (a • x) y := by |
| have h := BilinForm.apply_toDual_symm_apply (B := Algebra.traceForm F E) |
| (hB := traceForm_nondegenerate F E) (traceFunctional B x y) a |
| change Algebra.trace F E (lift (E := E) B x y * a) = B (a • x) y at h |
| simpa only [mul_comm] using h |
|
|
| lemma trace_lift_one (B : BilinForm F V) (x y : V) : |
| Algebra.trace F E (lift (E := E) B x y) = B x y := by |
| simpa using trace_lift (E := E) B x y (1 : E) |
|
|
| lemma lift_add_left (B : BilinForm F V) (x y z : V) : |
| lift (E := E) B (x+y) z = lift (E := E) B x z + lift (E := E) B y z := by |
| apply trace_pairing_ext (F := F) |
| intro a |
| simp only [mul_add,map_add,trace_lift,smul_add,LinearMap.add_apply] |
|
|
| lemma lift_add_right (B : BilinForm F V) (x y z : V) : |
| lift (E := E) B x (y+z) = lift (E := E) B x y + lift (E := E) B x z := by |
| apply trace_pairing_ext (F := F) |
| intro a |
| simp only [mul_add,map_add,trace_lift] |
|
|
| lemma lift_smul_left (B : BilinForm F V) (a : E) (x y : V) : |
| lift (E := E) B (a • x) y = a * lift (E := E) B x y := by |
| apply trace_pairing_ext (F := F) |
| intro b |
| rw [trace_lift,← mul_assoc,trace_lift,mul_smul] |
|
|
| variable (σ : E ≃ₐ[F] E) (hσ : Function.Involutive σ) |
|
|
| def AdjointRule (B : BilinForm F V) : Prop := |
| ∀ (a : E) (x y : V), B (a • x) y = B x (σ a • y) |
|
|
| include hσ in |
| lemma lift_smul_right (B : BilinForm F V) (hB : AdjointRule σ B) |
| (a : E) (x y : V) : lift (E := E) B x (a • y) = σ a * lift (E := E) B x y := by |
| apply trace_pairing_ext (F := F) |
| intro b |
| rw [trace_lift,← mul_assoc,mul_comm b (σ a),trace_lift,mul_smul,hB (σ a) (b • x) y,hσ] |
|
|
| omit [FiniteDimensional F E] [Algebra.IsSeparable F E] in |
| lemma trace_sigma (a : E) : Algebra.trace F E (σ a) = Algebra.trace F E a := by |
| exact Algebra.trace_eq_of_algEquiv σ a |
|
|
| include hσ in |
| lemma lift_symmetric (B : BilinForm F V) (hs : B.IsSymm) (hB : AdjointRule σ B) |
| (x y : V) : lift (E := E) B y x = σ (lift (E := E) B x y) := by |
| apply trace_pairing_ext (F := F) |
| intro a |
| rw [trace_lift,← trace_sigma σ (a * σ (lift (E := E) B x y)),map_mul,hσ,trace_lift] |
| rw [hB a y x,hs.eq] |
|
|
| lemma lift_nondegenerate_left (B : BilinForm F V) (hB : B.Nondegenerate) |
| (x : V) (hx : ∀ y, lift (E := E) B x y = 0) : x = 0 := by |
| apply hB.1 x |
| intro y |
| rw [← trace_lift_one (E := E), hx,map_zero] |
|
|
| lemma lift_nondegenerate_right (B : BilinForm F V) (hB : B.Nondegenerate) |
| (y : V) (hy : ∀ x, lift (E := E) B x y = 0) : y = 0 := by |
| apply hB.2 y |
| intro x |
| rw [← trace_lift_one (E := E),hy,map_zero] |
|
|
| theorem preserves_iff (B : BilinForm F V) (C : BilinForm F W) (e : V ≃ₗ[E] W) : |
| (∀ x y, C (e x) (e y) = B x y) ↔ |
| ∀ x y, lift (E := E) C (e x) (e y) = lift (E := E) B x y := by |
| constructor |
| · intro he x y |
| apply trace_pairing_ext (F := F) |
| intro a |
| rw [trace_lift,trace_lift,← e.map_smul,he] |
| · intro he x y |
| rw [← trace_lift_one (E := E),← trace_lift_one (E := E),he] |
|
|
| theorem lift_unique (B : BilinForm F V) (h : V → V → E) |
| (hh : ∀ a x y, Algebra.trace F E (a * h x y) = B (a • x) y) : |
| h = lift (E := E) B := by |
| funext x y |
| apply trace_pairing_ext (F := F) |
| intro a |
| rw [hh,trace_lift] |
|
|
| end |
| end MultiplicityCounterexample.TraceHermitian |
|
|
| namespace MultiplicityCounterexample.FixedFieldLocalComparison |
| noncomputable section |
| open TensorProduct |
| open LinearMap (BilinForm) |
| open scoped MultiplicityCounterexample.TensorAlgebraModule |
| variable {R F V W : Type*} [Field R] [Field F] [Algebra R F] |
| [FiniteDimensional R F] [Algebra.IsSeparable R F] |
| [AddCommGroup V] [Module R V] [Module F V] [IsScalarTower R F V] |
| [AddCommGroup W] [Module R W] [Module F W] [IsScalarTower R F W] |
|
|
| def SelfAdjointScalars (B : BilinForm R V) : Prop := |
| ∀ a : F, ∀ x y : V, B (a • x) y = B x (a • y) |
|
|
| def fixedForm (B : BilinForm R V) (hB : SelfAdjointScalars (F := F) B) : BilinForm F V where |
| toFun x := |
| { toFun := fun y => TraceHermitian.lift (E := F) B x y |
| map_add' := TraceHermitian.lift_add_right B x |
| map_smul' a y := by |
| change TraceHermitian.lift B x (a • y) = a * TraceHermitian.lift B x y |
| exact TraceHermitian.lift_smul_right (.refl : F ≃ₐ[R] F) |
| (fun _ => rfl) B hB a x y } |
| map_add' x y := by ext w; exact TraceHermitian.lift_add_left B x y w |
| map_smul' a x := by |
| ext y |
| exact TraceHermitian.lift_smul_left B a x y |
|
|
| @[simp] lemma fixedForm_apply (B : BilinForm R V) (hB : SelfAdjointScalars (F := F) B) |
| (x y : V) : fixedForm B hB x y = TraceHermitian.lift B x y := rfl |
|
|
| lemma trace_fixedForm (B : BilinForm R V) (hB : SelfAdjointScalars (F := F) B) : |
| CompletionTraceDescent.traceForm (fixedForm B hB) = B := by |
| ext x y |
| exact TraceHermitian.trace_lift_one B x y |
|
|
| lemma fixedForm_symmetric (B : BilinForm R V) (hB : SelfAdjointScalars (F := F) B) |
| (hs : B.IsSymm) : (fixedForm B hB).IsSymm := by |
| constructor |
| intro x y |
| exact (TraceHermitian.lift_symmetric (.refl : F ≃ₐ[R] F) |
| (fun _ => rfl) B hs hB y x) |
|
|
| lemma fixedForm_nondegenerate (B : BilinForm R V) (hB : SelfAdjointScalars (F := F) B) |
| (hn : B.Nondegenerate) : (fixedForm B hB).Nondegenerate := by |
| constructor |
| · intro x hx |
| exact TraceHermitian.lift_nondegenerate_left B hn x hx |
| · intro y hy |
| exact TraceHermitian.lift_nondegenerate_right B hn y hy |
|
|
| end |
|
|
| noncomputable section |
| open TensorProduct |
| open LinearMap (BilinForm) |
| open scoped NumberField |
| open NumberFieldTraceLocalComparison |
| variable {F V W A : Type*} [Field F] [NumberField F] |
| [CommRing A] [Algebra ℚ A] |
| [AddCommGroup V] [Module ℚ V] [Module F V] [IsScalarTower ℚ F V] |
| [AddCommGroup W] [Module ℚ W] [Module F W] [IsScalarTower ℚ F W] |
|
|
| theorem localTraceIsometry_of_equivariant |
| (B₁ : BilinForm ℚ V) (B₂ : BilinForm ℚ W) |
| (h₁ : SelfAdjointScalars (F := F) B₁) (h₂ : SelfAdjointScalars (F := F) B₂) |
| (z : F) (e : (A ⊗[ℚ] V) ≃ₗ[A] (A ⊗[ℚ] W)) |
| (hz : ∀ x, e (TensorAlgebraModule.rightAction z x) = |
| TensorAlgebraModule.rightAction z (e x)) |
| (he : ∀ x y, B₂.baseChange A (e x) (e y) = B₁.baseChange A x y) : |
| LocalTraceIsometry A (fixedForm B₁ h₁) (fixedForm B₂ h₂) z := by |
| refine ⟨e, hz, ?_⟩ |
| simpa only [trace_fixedForm] using he |
|
|
| end |
| end MultiplicityCounterexample.FixedFieldLocalComparison |
|
|
| namespace MultiplicityCounterexample.FixedFieldBridge |
| noncomputable section |
| open TensorProduct |
| open LinearMap (BilinForm) |
| open TensorAlgebraModule |
| variable {R F E A V W : Type*} [CommRing R] [CommRing F] [CommRing E] |
| [Algebra R F] [Algebra R E] [Algebra F E] [IsScalarTower R F E] |
| [CommRing A] [Algebra R A] |
| [AddCommGroup V] [Module R V] [Module F V] [Module E V] |
| [IsScalarTower R F V] [IsScalarTower R E V] [IsScalarTower F E V] |
| [AddCommGroup W] [Module R W] [Module F W] [Module E W] |
| [IsScalarTower R F W] [IsScalarTower R E W] [IsScalarTower F E W] |
|
|
| omit [IsScalarTower R F E] in |
| lemma rightAction_tower (a : F) (x : A ⊗[R] V) : |
| rightAction (algebraMap F E a) x = rightAction a x := by |
| induction x using TensorProduct.inductionOn with |
| | add x y hx hy => simp only [map_add, hx, hy] |
| | tmul b v => |
| change b ⊗ₜ[R] (algebraMap F E a • v) = b ⊗ₜ[R] (a • v) |
| rw [IsScalarTower.algebraMap_smul] |
|
|
| omit [IsScalarTower R F E] in |
| lemma intertwines_fixedScalars |
| (e : (A ⊗[R] V) ≃ₗ[A] (A ⊗[R] W)) |
| (z : E) (hgen : Algebra.adjoin R ({z} : Set E) = ⊤) |
| (hz : ∀ x, e (rightAction z x) = rightAction z (e x)) |
| (a : F) (x : A ⊗[R] V) : e (rightAction a x) = rightAction a (e x) := by |
| have h := TensorEquivariant.intertwines_all e.toLinearMap z hgen hz |
| (algebraMap F E a) x |
| simpa only [rightAction_tower, LinearEquiv.coe_coe] using h |
|
|
| end |
| end MultiplicityCounterexample.FixedFieldBridge |
|
|
| namespace MultiplicityCounterexample.FixedFieldPrimitive |
| noncomputable section |
| variable (F : Type*) [Field F] [NumberField F] |
| lemma exists_primitive : ∃ z : F, Algebra.adjoin ℚ ({z} : Set F) = ⊤ := by |
| obtain ⟨z, hz⟩ := Field.exists_primitive_element ℚ F |
| refine ⟨z, ?_⟩ |
| have h := congrArg IntermediateField.toSubalgebra hz |
| simpa only [IntermediateField.adjoin_toSubalgebra, IntermediateField.top_toSubalgebra] using h |
| end |
| end MultiplicityCounterexample.FixedFieldPrimitive |
|
|
| namespace MultiplicityCounterexample.CyclotomicPlaceComparison |
| noncomputable section |
| open TensorProduct |
| open LinearMap (BilinForm) |
| open scoped NumberField |
| open TensorAlgebraModule FixedFieldLocalComparison NumberFieldTraceLocalComparison |
| variable {F E V W : Type*} [Field F] [NumberField F] [Field E] [NumberField E] |
| [Algebra F E] |
| [AddCommGroup V] [Module ℚ V] [Module F V] [Module E V] |
| [IsScalarTower ℚ F V] [IsScalarTower ℚ E V] [IsScalarTower F E V] |
| [AddCommGroup W] [Module ℚ W] [Module F W] [Module E W] |
| [IsScalarTower ℚ F W] [IsScalarTower ℚ E W] [IsScalarTower F E W] |
|
|
| omit [NumberField F] [IsScalarTower ℚ F V] [IsScalarTower ℚ E V] in |
| lemma selfAdjointScalars_of_fixed_involution |
| (σ : E ≃ₐ[ℚ] E) (hfix : ∀ a : F, σ (algebraMap F E a) = algebraMap F E a) |
| (B : BilinForm ℚ V) (hB : TraceHermitian.AdjointRule σ B) : |
| SelfAdjointScalars (F := F) B := by |
| intro a x y |
| have h := hB (algebraMap F E a) x y |
| simpa only [hfix, IsScalarTower.algebraMap_smul] using h |
|
|
| def LocalEquivariantIsometry (A : Type*) [CommRing A] [Algebra ℚ A] |
| (B₁ : BilinForm ℚ V) (B₂ : BilinForm ℚ W) (z : E) : Prop := |
| ∃ e : (A ⊗[ℚ] V) ≃ₗ[A] (A ⊗[ℚ] W), |
| (∀ x, e (rightAction z x) = rightAction z (e x)) ∧ |
| (∀ x y, B₂.baseChange A (e x) (e y) = B₁.baseChange A x y) |
|
|
| lemma localTraceIsometry_of_cyclotomic |
| {A : Type*} [CommRing A] [Algebra ℚ A] |
| (B₁ : BilinForm ℚ V) (B₂ : BilinForm ℚ W) |
| (h₁ : SelfAdjointScalars (F := F) B₁) (h₂ : SelfAdjointScalars (F := F) B₂) |
| (z : E) (hzgen : Algebra.adjoin ℚ ({z} : Set E) = ⊤) |
| (he : LocalEquivariantIsometry A B₁ B₂ z) (a : F) : |
| LocalTraceIsometry A (fixedForm B₁ h₁) (fixedForm B₂ h₂) a := by |
| obtain ⟨e, hz, hB⟩ := he |
| exact localTraceIsometry_of_equivariant B₁ B₂ h₁ h₂ a e |
| (FixedFieldBridge.intertwines_fixedScalars e z hzgen hz a) hB |
|
|
| theorem fixedForm_isometric_at_every_finitePlace |
| (B₁ : BilinForm ℚ V) (B₂ : BilinForm ℚ W) |
| (h₁ : SelfAdjointScalars (F := F) B₁) (h₂ : SelfAdjointScalars (F := F) B₂) |
| (z : E) (hzgen : Algebra.adjoin ℚ ({z} : Set E) = ⊤) |
| (hloc : ∀ (p : ℕ) (_ : Fact p.Prime), LocalEquivariantIsometry (Padic p) B₁ B₂ z) |
| (v : IsDedekindDomain.HeightOneSpectrum (𝓞 F)) : |
| Nonempty (((fixedForm B₁ h₁).baseChange (v.adicCompletion F)).IsometryEquiv |
| ((fixedForm B₂ h₂).baseChange (v.adicCompletion F))) := by |
| obtain ⟨a, ha⟩ := FixedFieldPrimitive.exists_primitive F |
| exact isometric_at_every_finitePlace (fixedForm B₁ h₁) (fixedForm B₂ h₂) a ha |
| (fun p hp => localTraceIsometry_of_cyclotomic B₁ B₂ h₁ h₂ z hzgen (hloc p hp) a) v |
|
|
| theorem fixedForm_isometric_at_every_infinitePlace |
| (B₁ : BilinForm ℚ V) (B₂ : BilinForm ℚ W) |
| (h₁ : SelfAdjointScalars (F := F) B₁) (h₂ : SelfAdjointScalars (F := F) B₂) |
| (z : E) (hzgen : Algebra.adjoin ℚ ({z} : Set E) = ⊤) |
| (hreal : LocalEquivariantIsometry ℝ B₁ B₂ z) |
| (v : NumberField.InfinitePlace F) : |
| Nonempty (((fixedForm B₁ h₁).baseChange v.Completion).IsometryEquiv |
| ((fixedForm B₂ h₂).baseChange v.Completion)) := by |
| obtain ⟨a, ha⟩ := FixedFieldPrimitive.exists_primitive F |
| exact isometric_at_every_infinitePlace (fixedForm B₁ h₁) (fixedForm B₂ h₂) a ha |
| (localTraceIsometry_of_cyclotomic B₁ B₂ h₁ h₂ z hzgen hreal a) v |
|
|
| end |
| end MultiplicityCounterexample.CyclotomicPlaceComparison |
|
|
| namespace MultiplicityCounterexample.TraceTowerCompatibility |
| noncomputable section |
| open LinearMap (BilinForm) |
| variable {R F E V : Type*} [Field R] [Field F] [Field E] |
| [Algebra R F] [Algebra R E] [Algebra F E] [IsScalarTower R F E] |
| [FiniteDimensional R F] [FiniteDimensional F E] [FiniteDimensional R E] |
| [Algebra.IsSeparable R F] [Algebra.IsSeparable R E] |
| [AddCommGroup V] [Module R V] [Module F V] [Module E V] |
| [IsScalarTower R F V] [IsScalarTower R E V] [IsScalarTower F E V] |
|
|
| theorem lift_fixed_eq_trace_lift (B : BilinForm R V) (x y : V) : |
| TraceHermitian.lift (E := F) B x y = |
| Algebra.trace F E (TraceHermitian.lift (E := E) B x y) := by |
| apply TraceHermitian.trace_pairing_ext (F := R) |
| intro a |
| rw [TraceHermitian.trace_lift] |
| calc |
| B (a • x) y = B (algebraMap F E a • x) y := by rw [IsScalarTower.algebraMap_smul] |
| _ = Algebra.trace R E (algebraMap F E a * TraceHermitian.lift B x y) := |
| (TraceHermitian.trace_lift B x y (algebraMap F E a)).symm |
| _ = Algebra.trace R F (Algebra.trace F E |
| (a • TraceHermitian.lift (E := E) B x y)) := by |
| rw [Algebra.trace_trace, Algebra.smul_def] |
| _ = Algebra.trace R F (a * Algebra.trace F E (TraceHermitian.lift (E := E) B x y)) := by |
| rw [map_smul, smul_eq_mul] |
|
|
| theorem lift_fixed_diagonal (B : BilinForm R V) (x : V) (a : F) |
| (hx : TraceHermitian.lift (E := E) B x x = algebraMap F E a) |
| (hdim : Module.finrank F E = 2) : |
| TraceHermitian.lift (E := F) B x x = 2 * a := by |
| rw [lift_fixed_eq_trace_lift (E := E), hx, Algebra.trace_algebraMap, hdim] |
| simp |
|
|
| end |
| end MultiplicityCounterexample.TraceTowerCompatibility |
|
|
| namespace MultiplicityCounterexample.LengthBaseChange |
| noncomputable section |
| open TensorProduct |
| open LinearMap (BilinForm) |
| variable {F K V W : Type*} [Field F] [CharZero F] [Field K] [CharZero K] [Algebra F K] |
| [AddCommGroup V] [Module F V] [AddCommGroup W] [Module F W] |
|
|
| def halfForm (B : BilinForm F V) : BilinForm F V := (2 : F)⁻¹ • B |
|
|
| def lengthForm (B : BilinForm F V) : QuadraticForm F V := (halfForm B).toQuadraticMap |
|
|
| omit [CharZero F] in |
| @[simp] lemma halfForm_apply (B : BilinForm F V) (x y : V) : |
| halfForm B x y = (2 : F)⁻¹ * B x y := rfl |
|
|
| omit [CharZero F] in |
| @[simp] lemma lengthForm_apply (B : BilinForm F V) (x : V) : |
| lengthForm B x = (2 : F)⁻¹ * B x x := rfl |
|
|
| omit [CharZero F] in |
| lemma halfForm_symmetric (B : BilinForm F V) (hs : B.IsSymm) : (halfForm B).IsSymm := |
| hs.smul _ |
|
|
| lemma halfForm_nondegenerate (B : BilinForm F V) (hn : B.Nondegenerate) : |
| (halfForm B).Nondegenerate := by |
| constructor |
| · intro x hx |
| apply hn.1 x |
| intro y |
| have h := hx y |
| exact (mul_eq_zero.mp h).resolve_left (inv_ne_zero (by norm_num)) |
| · intro y hy |
| apply hn.2 y |
| intro x |
| have h := hy x |
| exact (mul_eq_zero.mp h).resolve_left (inv_ne_zero (by norm_num)) |
|
|
| lemma lengthForm_nondegenerate (B : BilinForm F V) (hs : B.IsSymm) (hn : B.Nondegenerate) : |
| (lengthForm B).Nondegenerate := by |
| let : Invertible (2 : F) := invertibleOfNonzero (by norm_num) |
| apply QuadraticMap.nondegenerate_associated_iff.mp |
| have ha : (lengthForm B).associated = halfForm B := |
| QuadraticMap.associated_left_inverse F (halfForm_symmetric B hs).eq |
| rw [ha] |
| exact halfForm_nondegenerate B hn |
|
|
| omit [CharZero F] [CharZero K] in |
| lemma lengthForm_baseChange (B : BilinForm F V) [Invertible (2 : F)] : |
| (lengthForm B).baseChange K = lengthForm (B.baseChange K) := by |
| apply _root_.baseChange_ext |
| intro x |
| simp only [QuadraticForm.baseChange_tmul, lengthForm_apply, |
| LinearMap.BilinForm.baseChange_tmul, mul_one, Algebra.smul_def, |
| map_mul, map_inv₀, map_ofNat] |
|
|
| def lengthIsometryAtPlace (B₁ : BilinForm F V) (B₂ : BilinForm F W) |
| [Invertible (2 : F)] |
| (e : (B₁.baseChange K).IsometryEquiv (B₂.baseChange K)) : |
| ((lengthForm B₁).baseChange K).IsometryEquiv ((lengthForm B₂).baseChange K) where |
| __ := e.toLinearEquiv |
| map_app' x := by |
| change (lengthForm B₂).baseChange K (e x) = (lengthForm B₁).baseChange K x |
| rw [lengthForm_baseChange, lengthForm_baseChange] |
| simp only [lengthForm_apply, e.map_app] |
|
|
| end |
| end MultiplicityCounterexample.LengthBaseChange |
|
|
| namespace MultiplicityCounterexample.CyclotomicLengthLocalComparison |
| noncomputable section |
| open TensorProduct |
| open LinearMap (BilinForm) |
| open scoped NumberField |
| open FixedFieldLocalComparison CyclotomicPlaceComparison LengthBaseChange |
| variable {F E V W : Type*} [Field F] [NumberField F] [Field E] [NumberField E] |
| [Algebra F E] [IsScalarTower ℚ F E] |
| [AddCommGroup V] [Module ℚ V] [Module F V] [Module E V] |
| [IsScalarTower ℚ F V] [IsScalarTower ℚ E V] [IsScalarTower F E V] |
| [AddCommGroup W] [Module ℚ W] [Module F W] [Module E W] |
| [IsScalarTower ℚ F W] [IsScalarTower ℚ E W] [IsScalarTower F E W] |
|
|
| def sourceLength (B : BilinForm ℚ V) (ha : SelfAdjointScalars (F := F) B) : |
| QuadraticForm F V := lengthForm (fixedForm B ha) |
|
|
| theorem sourceLength_value (σ : E ≃ₐ[ℚ] E) (hσ : Function.Involutive σ) |
| (hfixed : ∀ z : E, σ z = z → ∃ a : F, algebraMap F E a = z) |
| (hdim : Module.finrank F E = 2) |
| (B : BilinForm ℚ V) (ha : SelfAdjointScalars (F := F) B) |
| (hs : B.IsSymm) (hadj : TraceHermitian.AdjointRule σ B) (x : V) : |
| algebraMap F E (sourceLength B ha x) = TraceHermitian.lift (E := E) B x x := by |
| have hd : σ (TraceHermitian.lift (E := E) B x x) = TraceHermitian.lift B x x := |
| (TraceHermitian.lift_symmetric σ hσ B hs hadj x x).symm |
| obtain ⟨a, ha'⟩ := hfixed _ hd |
| have ht := TraceTowerCompatibility.lift_fixed_diagonal B x a ha'.symm hdim |
| simp only [sourceLength, lengthForm_apply, fixedForm_apply] |
| rw [ht, ← mul_assoc, inv_mul_cancel₀ (by norm_num : (2 : F) ≠ 0), one_mul, ha'] |
|
|
| theorem sourceLength_nondegenerate |
| (B : BilinForm ℚ V) (ha : SelfAdjointScalars (F := F) B) |
| (hs : B.IsSymm) (hn : B.Nondegenerate) : (sourceLength B ha).Nondegenerate := |
| lengthForm_nondegenerate _ (fixedForm_symmetric B ha hs) (fixedForm_nondegenerate B ha hn) |
|
|
| omit [IsScalarTower ℚ F E] in |
| theorem length_isometric_at_every_finitePlace |
| (B₁ : BilinForm ℚ V) (B₂ : BilinForm ℚ W) |
| (h₁ : SelfAdjointScalars (F := F) B₁) (h₂ : SelfAdjointScalars (F := F) B₂) |
| (z : E) (hzgen : Algebra.adjoin ℚ ({z} : Set E) = ⊤) |
| (hloc : ∀ (p : ℕ) (_ : Fact p.Prime), LocalEquivariantIsometry (Padic p) B₁ B₂ z) |
| (v : IsDedekindDomain.HeightOneSpectrum (𝓞 F)) : |
| Nonempty (((sourceLength B₁ h₁).baseChange (v.adicCompletion F)).IsometryEquiv |
| ((sourceLength B₂ h₂).baseChange (v.adicCompletion F))) := by |
| obtain ⟨e⟩ := fixedForm_isometric_at_every_finitePlace B₁ B₂ h₁ h₂ z hzgen hloc v |
| exact ⟨lengthIsometryAtPlace _ _ e⟩ |
|
|
| omit [IsScalarTower ℚ F E] in |
| theorem length_isometric_at_every_infinitePlace |
| (B₁ : BilinForm ℚ V) (B₂ : BilinForm ℚ W) |
| (h₁ : SelfAdjointScalars (F := F) B₁) (h₂ : SelfAdjointScalars (F := F) B₂) |
| (z : E) (hzgen : Algebra.adjoin ℚ ({z} : Set E) = ⊤) |
| (hreal : LocalEquivariantIsometry ℝ B₁ B₂ z) |
| (v : NumberField.InfinitePlace F) : |
| Nonempty (((sourceLength B₁ h₁).baseChange v.Completion).IsometryEquiv |
| ((sourceLength B₂ h₂).baseChange v.Completion)) := by |
| obtain ⟨e⟩ := fixedForm_isometric_at_every_infinitePlace B₁ B₂ h₁ h₂ z hzgen hreal v |
| exact ⟨lengthIsometryAtPlace _ _ e⟩ |
| end |
| end MultiplicityCounterexample.CyclotomicLengthLocalComparison |
|
|
| end OAI |
|
|
