math / data /lean /OAI /Combinatorics /Chromatic /Shuffle /FourTensorKernel.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
20.5 kB
import Mathlib
import OAI.Combinatorics.Chromatic.Shuffle.ShuffleProjection
import OAI.Combinatorics.Chromatic.Shuffle.FourColumns
import OAI.Combinatorics.Chromatic.Shuffle.FourKernelCancellation
namespace OAI
section
namespace ElementaryPositivity.RawShuffle
open MvPolynomial HahnSeries
open ElementaryPositivity.LaurentAtInfinity ElementaryPositivity.RectangularKernel
open scoped TensorProduct
variable {I : Type*} [Fintype I] [DecidableEq I]
noncomputable local instance kernelTensorRing (d e : I β†’ β„•) : CommRing (S dβŠ—[β„š]S e) := inferInstance
noncomputable local instance kernelTensorDistrib (d e : I β†’ β„•) :
DistribSMul (S dβŠ—[β„š]S e) (S dβŠ—[β„š]S e) where
smul_add := mul_add
noncomputable local instance kernelTensorAlg (d e : I β†’ β„•) : Algebra β„š (S dβŠ—[β„š]S e) := inferInstance
noncomputable local instance kernelFourRing (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
CommRing ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) := inferInstance
noncomputable local instance kernelFourAlg (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Algebra β„š ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) := inferInstance
noncomputable local instance kernelTensorSelf (d e : I β†’ β„•) :
Module (S dβŠ—[β„š]S e) (S dβŠ—[β„š]S e) := Semiring.toModule
noncomputable local instance kernelTensorNonUnital (d e : I β†’ β„•) :
NonUnitalNonAssocSemiring (S dβŠ—[β„š]S e) := (kernelTensorRing d e).toNonUnitalNonAssocSemiring
noncomputable local instance kernelFourNonUnital (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
NonUnitalNonAssocSemiring ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) :=
(kernelFourRing d₁ e₁ dβ‚‚ eβ‚‚).toNonUnitalNonAssocSemiring
lemma realize_inverseKernelUnit_unit (a : I β†’ I β†’ β„•) (d e : I β†’ β„•) :
Units.map (mapRing (tensorValueAlg d e).toRingHom).toMonoidHom
(SeparationInfinity.inverseKernelUnit a d e)=SeparationInfinity.rawInverseKernelUnit a d e := by
apply Units.ext
exact SeparationInfinity.realize_inverseKernelUnit a d e
lemma fourKernel_lift_naturality (a : I β†’ I β†’ β„•) (d e d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•)
(F : S dβŠ—[β„š]S e →ₐ[β„š] (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚))
(r : CellVars d e β†’ CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚)
(h : βˆ€ x,fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚ (F x)=rename r (tensorValue d e x)) :
Units.map (mapRing (R:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (S:=MvPolynomial (CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) β„š) (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(Units.map (mapRing (R:=S dβŠ—[β„š]S e) (S:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) F.toRingHom).toMonoidHom (SeparationInfinity.inverseKernelUnit a d e))=
Units.map (mapRing (rename r).toRingHom).toMonoidHom (SeparationInfinity.rawInverseKernelUnit a d e) := by
apply Units.ext
apply HahnSeries.ext
funext k
change fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚ (F ((SeparationInfinity.inverseKernelUnit a d e).val.coeff k))=
rename r ((SeparationInfinity.rawInverseKernelUnit a d e).val.coeff k)
rw [h]
have hr := congrArg (fun x : LaurentSeries (MvPolynomial (CellVars d e) β„š)=>x.coeff k)
(SeparationInfinity.realize_inverseKernelUnit a d e)
exact congrArg (rename r) hr
lemma fourKernel_restrictRows (a : I β†’ I β†’ β„•) {d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•}
(A : Cut d₁ e₁) (B : Cut dβ‚‚ eβ‚‚) :
Units.map (mapRing (R:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (S:=MvPolynomial (CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) β„š) (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(Units.map (mapRing (R:=S (d₁+e₁)βŠ—[β„š]S (dβ‚‚+eβ‚‚)) (S:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (restrictRows d₁ e₁ dβ‚‚ eβ‚‚ A B).toRingHom).toMonoidHom
(SeparationInfinity.inverseKernelUnit a (d₁+e₁) (dβ‚‚+eβ‚‚)))=
fourTotalInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ := by
rw [fourKernel_lift_naturality a _ _ _ _ _ _ _ _ (fourValue_restrictRows A B)]
exact rowSplit_inverseKernel a A B
lemma fourKernel_firstColumn (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Units.map (mapRing (R:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (S:=MvPolynomial (CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) β„š) (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(Units.map (mapRing (R:=S dβ‚βŠ—[β„š]S dβ‚‚) (S:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (firstColumnAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(SeparationInfinity.inverseKernelUnit a d₁ dβ‚‚))=
rectangular (SeparationInfinity.inverseExponent a)
(fun i j x y=>fourAffine d₁ e₁ dβ‚‚ eβ‚‚ i j (.inl x) (.inl y)) := by
refine Eq.trans (fourKernel_lift_naturality a d₁ dβ‚‚ d₁ e₁ dβ‚‚ eβ‚‚
( firstColumnAlg d₁ e₁ dβ‚‚ eβ‚‚ ) _ (fourValue_firstColumn d₁ e₁ dβ‚‚ eβ‚‚)) ?_
have he : firstColumnVars d₁ e₁ dβ‚‚ eβ‚‚ =
Sum.elim (Sum.inl ∘ Sum.inl) (Sum.inr ∘ Sum.inl) := by
funext x; cases x <;> rfl
rw [he]
have h := rawKernel_rename (Οƒ:=CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) a d₁ dβ‚‚
(Sum.inl ∘ Sum.inl) (Sum.inr ∘ Sum.inl)
simpa only [fourAffine,fourForwardDifference,Function.comp_apply,
Equiv.sigmaSumDistrib_apply,Sum.map_inl,Sum.map_inr,firstColumnVars,secondColumnVars,crossingColumnVars] using h
lemma fourKernel_secondColumn (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Units.map (mapRing (R:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (S:=MvPolynomial (CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) β„š) (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(Units.map (mapRing (R:=S eβ‚βŠ—[β„š]S eβ‚‚) (S:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (secondColumnAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(SeparationInfinity.inverseKernelUnit a e₁ eβ‚‚))=
rectangular (SeparationInfinity.inverseExponent a)
(fun i j x y=>fourAffine d₁ e₁ dβ‚‚ eβ‚‚ i j (.inr x) (.inr y)) := by
refine Eq.trans (fourKernel_lift_naturality a e₁ eβ‚‚ d₁ e₁ dβ‚‚ eβ‚‚
( secondColumnAlg d₁ e₁ dβ‚‚ eβ‚‚ ) _ (fourValue_secondColumn d₁ e₁ dβ‚‚ eβ‚‚)) ?_
have he : secondColumnVars d₁ e₁ dβ‚‚ eβ‚‚ =
Sum.elim (Sum.inl ∘ Sum.inr) (Sum.inr ∘ Sum.inr) := by
funext x; cases x <;> rfl
rw [he]
have h := rawKernel_rename (Οƒ:=CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) a e₁ eβ‚‚
(Sum.inl ∘ Sum.inr) (Sum.inr ∘ Sum.inr)
simpa only [fourAffine,fourForwardDifference,Function.comp_apply,
Equiv.sigmaSumDistrib_apply,Sum.map_inl,Sum.map_inr,firstColumnVars,secondColumnVars,crossingColumnVars] using h
lemma fourKernel_crossingColumn (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Units.map (mapRing (R:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (S:=MvPolynomial (CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) β„š) (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(Units.map (mapRing (R:=S eβ‚βŠ—[β„š]S dβ‚‚) (S:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (crossingColumnAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom).toMonoidHom
(SeparationInfinity.inverseKernelUnit a e₁ dβ‚‚))=
rectangular (SeparationInfinity.inverseExponent a)
(fun i j x y=>fourAffine d₁ e₁ dβ‚‚ eβ‚‚ i j (.inr x) (.inl y)) := by
refine Eq.trans (fourKernel_lift_naturality a e₁ dβ‚‚ d₁ e₁ dβ‚‚ eβ‚‚
( crossingColumnAlg d₁ e₁ dβ‚‚ eβ‚‚ ) _ (fourValue_crossingColumn d₁ e₁ dβ‚‚ eβ‚‚)) ?_
have h := rawKernel_rename (Οƒ:=CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) a e₁ dβ‚‚
(Sum.inl ∘ Sum.inr) (Sum.inr ∘ Sum.inl)
simpa only [fourAffine,fourForwardDifference,Function.comp_apply,
Equiv.sigmaSumDistrib_apply,Sum.map_inl,Sum.map_inr,firstColumnVars,secondColumnVars,crossingColumnVars] using h
lemma fourTensor_cross_realize (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
mapRing (R:= (S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) (S:=MvPolynomial (CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) β„š) (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom
(polynomial (fourRelativeTaylor d₁ e₁ dβ‚‚ eβ‚‚ (fourCrossTensor a d₁ e₁ dβ‚‚ eβ‚‚)))=
(fourCrossAffineUnit a d₁ e₁ dβ‚‚ eβ‚‚).val := by
rw [polynomial_map,map_fourRelativeTaylor,fourValue_fourCrossTensor,polynomial_fourRelative_cross]
end ElementaryPositivity.RawShuffle
end
section
namespace ElementaryPositivity.RawShuffle
open MvPolynomial HahnSeries
open ElementaryPositivity.LaurentAtInfinity ElementaryPositivity.RectangularKernel
open scoped TensorProduct
variable {I : Type*} [Fintype I] [DecidableEq I]
noncomputable local instance cancelTensorRing (d e : I β†’ β„•) : CommRing (S dβŠ—[β„š]S e) := inferInstance
noncomputable local instance cancelTensorDistrib (d e : I β†’ β„•) :
DistribSMul (S dβŠ—[β„š]S e) (S dβŠ—[β„š]S e) where
smul_add := mul_add
noncomputable local instance cancelTensorAlg (d e : I β†’ β„•) : Algebra β„š (S dβŠ—[β„š]S e) := inferInstance
noncomputable local instance cancelFourRing (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
CommRing ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) := inferInstance
noncomputable local instance cancelFourAlg (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Algebra β„š ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) := inferInstance
noncomputable def mappedInverseKernel {R : Type*} [CommRing R] [Algebra β„š R]
(a : I β†’ I β†’ β„•) (d e : I β†’ β„•) (f : S dβŠ—[β„š]S e →ₐ[β„š] R) : (LaurentSeries R)Λ£ :=
Units.map (mapRing f.toRingHom).toMonoidHom (SeparationInfinity.inverseKernelUnit a d e)
noncomputable local instance cancelTensorSelf (d e : I β†’ β„•) :
Module (S dβŠ—[β„š]S e) (S dβŠ—[β„š]S e) := Semiring.toModule
noncomputable local instance cancelTensorNonUnital (d e : I β†’ β„•) :
NonUnitalNonAssocSemiring (S dβŠ—[β„š]S e) := (cancelTensorRing d e).toNonUnitalNonAssocSemiring
noncomputable local instance cancelFourNonUnital (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
NonUnitalNonAssocSemiring ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) :=
(cancelFourRing d₁ e₁ dβ‚‚ eβ‚‚).toNonUnitalNonAssocSemiring
noncomputable local instance cancelSeriesRing (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
CommRing (LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚))) := inferInstance
noncomputable def fourRowsInverseUnit (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•)
(A : Cut d₁ e₁) (B : Cut dβ‚‚ eβ‚‚) : (LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)))Λ£ :=
mappedInverseKernel a (d₁+e₁) (dβ‚‚+eβ‚‚) (restrictRows d₁ e₁ dβ‚‚ eβ‚‚ A B)
noncomputable def fourFirstInverseUnit (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
(LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)))Λ£ :=
mappedInverseKernel a d₁ dβ‚‚ (firstColumnAlg d₁ e₁ dβ‚‚ eβ‚‚)
noncomputable def fourSecondInverseUnit (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
(LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)))Λ£ :=
mappedInverseKernel a e₁ eβ‚‚ (secondColumnAlg d₁ e₁ dβ‚‚ eβ‚‚)
noncomputable def fourCrossingInverseUnit (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
(LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)))Λ£ :=
mappedInverseKernel a e₁ dβ‚‚ (crossingColumnAlg d₁ e₁ dβ‚‚ eβ‚‚)
lemma fourTotalInverseUnit_zero (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
fourTotalInverseUnit (fun _ _ : I=>0) d₁ e₁ dβ‚‚ eβ‚‚=fourClearingUnit d₁ e₁ dβ‚‚ eβ‚‚ := by
unfold fourTotalInverseUnit fourClearingUnit
congr 1
funext i j
simp only [SeparationInfinity.inverseExponent,Nat.cast_zero,sub_zero]
noncomputable def fourSeriesValue (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)) β†’+*
LaurentSeries (MvPolynomial (CellVars d₁ eβ‚βŠ•CellVars dβ‚‚ eβ‚‚) β„š) :=
mapRing (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom
lemma fourSeriesValue_injective (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Function.Injective (fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚) :=
mapRing_injective (fourValueAlg d₁ e₁ dβ‚‚ eβ‚‚).toRingHom (fourValue_injective d₁ e₁ dβ‚‚ eβ‚‚)
lemma fourSeriesValue_rows (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•)
(A : Cut d₁ e₁) (B : Cut dβ‚‚ eβ‚‚) :
Units.map (fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚).toMonoidHom (fourRowsInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ A B)=
fourTotalInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ := fourKernel_restrictRows a A B
lemma fourSeriesValue_first (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Units.map (fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚).toMonoidHom (fourFirstInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚)=
rectangular (SeparationInfinity.inverseExponent a)
(fun i j x y=>fourAffine d₁ e₁ dβ‚‚ eβ‚‚ i j (.inl x) (.inl y)) :=
fourKernel_firstColumn a d₁ e₁ dβ‚‚ eβ‚‚
lemma fourSeriesValue_second (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Units.map (fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚).toMonoidHom (fourSecondInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚)=
rectangular (SeparationInfinity.inverseExponent a)
(fun i j x y=>fourAffine d₁ e₁ dβ‚‚ eβ‚‚ i j (.inr x) (.inr y)) :=
fourKernel_secondColumn a d₁ e₁ dβ‚‚ eβ‚‚
lemma fourSeriesValue_crossing (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Units.map (fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚).toMonoidHom (fourCrossingInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚)=
rectangular (SeparationInfinity.inverseExponent a)
(fun i j x y=>fourAffine d₁ e₁ dβ‚‚ eβ‚‚ i j (.inr x) (.inl y)) :=
fourKernel_crossingColumn a d₁ e₁ dβ‚‚ eβ‚‚
lemma fourSeriesValue_cross (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚
(polynomial (fourRelativeTaylor d₁ e₁ dβ‚‚ eβ‚‚ (fourCrossTensor a d₁ e₁ dβ‚‚ eβ‚‚)))=
(fourCrossAffineUnit a d₁ e₁ dβ‚‚ eβ‚‚).val := fourTensor_cross_realize a d₁ e₁ dβ‚‚ eβ‚‚
lemma units_map_neg_one {R S : Type*} [Ring R] [Ring S] (f : R β†’+* S) :
Units.map f.toMonoidHom (-1 : RΛ£)=(-1 : SΛ£) := by
apply Units.ext
change f (-1) = -1
rw [map_neg,map_one]
lemma ring_map_unit_val {R S : Type*} [Ring R] [Ring S] (f : R β†’+* S) (u : RΛ£) :
f u.val = (Units.map f.toMonoidHom u).val := rfl
lemma ring_map_inv_unit_val {R S : Type*} [Ring R] [Ring S] (f : R β†’+* S) (u : RΛ£) :
f (u⁻¹).val = ((Units.map f.toMonoidHom u)⁻¹).val := rfl
lemma ring_map_signedUnits {R S : Type*} [CommRing R] [CommRing S]
(f : R β†’+* S) (A B C D : RΛ£) (w : β„€) :
f (((-1)^w*(A*B*(C*D⁻¹))).val)=
((-1)^w*(Units.map f.toMonoidHom A*Units.map f.toMonoidHom B*
(Units.map f.toMonoidHom C*(Units.map f.toMonoidHom D)⁻¹))).val := by
rw [ring_map_unit_val]
simp only [map_mul,map_inv,map_zpow,units_map_neg_one]
lemma unitKernelCancellation_lift {R S : Type*} [CommRing R] [CommRing S]
(f : R β†’+* S) (hf : Function.Injective f)
(K L A B C D : RΛ£) (P : R) (k l a b c d p : SΛ£)
(hK : Units.map f.toMonoidHom K=k) (hL : Units.map f.toMonoidHom L=l)
(hA : Units.map f.toMonoidHom A=a) (hB : Units.map f.toMonoidHom B=b)
(hC : Units.map f.toMonoidHom C=c) (hD : Units.map f.toMonoidHom D=d)
(hP : f P=p.val) (w : β„€)
(h : k*l⁻¹*p=(-1)^w*(a*b*(c*d⁻¹))) :
K.val*(L⁻¹).val*P=((-1)^w*(A*B*(C*D⁻¹))).val := by
apply hf
rw [map_mul,map_mul,hP]
simp only [ring_map_unit_val,map_mul,map_inv,map_zpow,units_map_neg_one,hK,hL,hA,hB,hC,hD]
exact congrArg Units.val h
lemma unitKernelCancellation_lift2 {R S : Type*} [CommRing R] [CommRing S]
(f : R β†’+* S) (hf : Function.Injective f)
(K L A B C D : RΛ£) (P : R) (p : SΛ£) (hP : f P=p.val) (w : β„€)
(h : Units.map f.toMonoidHom K*(Units.map f.toMonoidHom L)⁻¹*p=
(-1)^w*(Units.map f.toMonoidHom A*Units.map f.toMonoidHom B*
(Units.map f.toMonoidHom C*(Units.map f.toMonoidHom D)⁻¹))) :
K.val*(L⁻¹).val*P=((-1)^w*(A*B*(C*D⁻¹))).val :=
unitKernelCancellation_lift f hf K L A B C D P _ _ _ _ _ _ p rfl rfl rfl rfl rfl rfl hP w h
lemma fourSeriesValue_rows_val (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•)
(A : Cut d₁ e₁) (B : Cut dβ‚‚ eβ‚‚) :
fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚ (fourRowsInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ A B).val=
(fourTotalInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚).val :=
congrArg Units.val (fourSeriesValue_rows a d₁ e₁ dβ‚‚ eβ‚‚ A B)
lemma fourSeriesValue_rows_inv_val (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•)
(A : Cut d₁ e₁) (B : Cut dβ‚‚ eβ‚‚) :
fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚ ((fourRowsInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ A B)⁻¹).val=
((fourTotalInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚)⁻¹).val :=
congrArg (fun u=> (u⁻¹).val) (fourSeriesValue_rows a d₁ e₁ dβ‚‚ eβ‚‚ A B)
noncomputable def fourTensorKernelRHS (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
(LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)))Λ£ :=
(-1)^eulerForm a dβ‚‚ e₁ *
(fourFirstInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ * fourSecondInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ *
(fourCrossingInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ *
(fourCrossingInverseUnit (fun i j=>a j i) d₁ e₁ dβ‚‚ eβ‚‚)⁻¹))
lemma fourSeriesValue_kernelRHS (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
Units.map (fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚).toMonoidHom
(fourTensorKernelRHS a d₁ e₁ dβ‚‚ eβ‚‚)=
fourTotalInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ * (fourClearingUnit d₁ e₁ dβ‚‚ eβ‚‚)⁻¹ *
fourCrossAffineUnit a d₁ e₁ dβ‚‚ eβ‚‚ := by
apply Units.ext
change fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚ (fourTensorKernelRHS a d₁ e₁ dβ‚‚ eβ‚‚).val = _
unfold fourTensorKernelRHS
rw [ring_map_signedUnits]
apply congrArg Units.val
refine Eq.trans ?_ (fourKernel_cancellation a d₁ e₁ dβ‚‚ eβ‚‚).symm
apply congrArg ((-1)^eulerForm a dβ‚‚ e₁ * Β·)
exact congrArgβ‚‚ (Β· * Β·)
(congrArgβ‚‚ (Β· * Β·) (fourSeriesValue_first a d₁ e₁ dβ‚‚ eβ‚‚)
(fourSeriesValue_second a d₁ e₁ dβ‚‚ eβ‚‚))
(congrArgβ‚‚ (Β· * Β·) (fourSeriesValue_crossing a d₁ e₁ dβ‚‚ eβ‚‚)
(congrArg Inv.inv (fourSeriesValue_crossing (fun i j=>a j i) d₁ e₁ dβ‚‚ eβ‚‚)))
lemma fourSeriesValue_kernelRHS_val (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•) :
fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚ (fourTensorKernelRHS a d₁ e₁ dβ‚‚ eβ‚‚).val=
(fourTotalInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ * (fourClearingUnit d₁ e₁ dβ‚‚ eβ‚‚)⁻¹ *
fourCrossAffineUnit a d₁ e₁ dβ‚‚ eβ‚‚).val :=
congrArg Units.val (fourSeriesValue_kernelRHS a d₁ e₁ dβ‚‚ eβ‚‚)
lemma fourSeriesValue_kernelLHS (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•)
(A : Cut d₁ e₁) (B : Cut dβ‚‚ eβ‚‚) :
fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚
((fourRowsInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ A B).val *
((fourRowsInverseUnit (fun _ _ : I=>0) d₁ e₁ dβ‚‚ eβ‚‚ A B)⁻¹).val *
polynomial (fourRelativeTaylor d₁ e₁ dβ‚‚ eβ‚‚ (fourCrossTensor a d₁ e₁ dβ‚‚ eβ‚‚)))=
(fourTotalInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ * (fourClearingUnit d₁ e₁ dβ‚‚ eβ‚‚)⁻¹ *
fourCrossAffineUnit a d₁ e₁ dβ‚‚ eβ‚‚).val := by
rw [(fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚).map_mul,(fourSeriesValue d₁ e₁ dβ‚‚ eβ‚‚).map_mul,
fourSeriesValue_rows_val,fourSeriesValue_rows_inv_val,fourTotalInverseUnit_zero,fourSeriesValue_cross]
rfl
lemma fourTensorKernel_cancellation (a : I β†’ I β†’ β„•) (d₁ e₁ dβ‚‚ eβ‚‚ : I β†’ β„•)
(A : Cut d₁ e₁) (B : Cut dβ‚‚ eβ‚‚) :
(fourRowsInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ A B).val *
((fourRowsInverseUnit (fun _ _ : I=>0) d₁ e₁ dβ‚‚ eβ‚‚ A B)⁻¹).val *
polynomial (fourRelativeTaylor d₁ e₁ dβ‚‚ eβ‚‚ (fourCrossTensor a d₁ e₁ dβ‚‚ eβ‚‚))=
(((-1 : (LaurentSeries ((S dβ‚βŠ—[β„š]S e₁)βŠ—[β„š](S dβ‚‚βŠ—[β„š]S eβ‚‚)))Λ£)^eulerForm a dβ‚‚ e₁) *
(fourFirstInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ *
fourSecondInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ *
(fourCrossingInverseUnit a d₁ e₁ dβ‚‚ eβ‚‚ *
(fourCrossingInverseUnit (fun i j=>a j i) d₁ e₁ dβ‚‚ eβ‚‚)⁻¹))).val := by
apply fourSeriesValue_injective d₁ e₁ dβ‚‚ eβ‚‚
exact (fourSeriesValue_kernelLHS a d₁ e₁ dβ‚‚ eβ‚‚ A B).trans
(fourSeriesValue_kernelRHS_val a d₁ e₁ dβ‚‚ eβ‚‚).symm
end ElementaryPositivity.RawShuffle
end
end OAI