| import Mathlib |
| import OAI.Combinatorics.Chromatic.Shuffle.FourTensorKernel |
| import OAI.Combinatorics.Chromatic.Shuffle.ColumnTaylor |
| import OAI.Combinatorics.Chromatic.Shuffle.SeparationHomogeneity |
| import OAI.Combinatorics.Chromatic.GradedAlgebra.LaurentScalarNaturality |
| import OAI.Combinatorics.Chromatic.GradedAlgebra.LaurentUnitSigns |
|
|
| namespace OAI |
|
|
| namespace ElementaryPositivity.RawShuffle |
| open MvPolynomial HahnSeries |
| open ElementaryPositivity.LaurentAtInfinity ElementaryPositivity.RectangularKernel |
| open SeparationInfinity |
| open scoped TensorProduct |
| variable {I : Type*} [Fintype I] [DecidableEq I] |
| attribute [local instance] cancelTensorRing cancelTensorAlg cancelFourRing cancelFourAlg |
| attribute [local instance] cancelTensorSelf cancelTensorNonUnital cancelFourNonUnital cancelSeriesRing |
|
|
| noncomputable local instance cellSepTensorSemiring (d e : I → ℕ) : Semiring (S d⊗[ℚ]S e) := |
| (cancelTensorRing d e).toSemiring |
| noncomputable local instance cellSepTensorNonAssoc (d e : I → ℕ) : NonAssocSemiring (S d⊗[ℚ]S e) := |
| (cancelTensorRing d e).toNonAssocSemiring |
| noncomputable local instance cellSepFourSemiring (d₁ e₁ d₂ e₂ : I → ℕ) : |
| Semiring ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) := |
| (cancelFourRing d₁ e₁ d₂ e₂).toSemiring |
| noncomputable local instance cellSepFourNonAssoc (d₁ e₁ d₂ e₂ : I → ℕ) : |
| NonAssocSemiring ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) := |
| (cancelFourRing d₁ e₁ d₂ e₂).toNonAssocSemiring |
| noncomputable local instance cellSepFourModule (d₁ e₁ d₂ e₂ : I → ℕ) : |
| Module ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) := Semiring.toModule |
|
|
| noncomputable def fourInputSeries (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (f : S (d₁+d₂)) (g : S (e₁+e₂)) : |
| LaurentSeries ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) := |
| mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom (tensorSeparationSeries a d₁ d₂ f) * |
| mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom (tensorSeparationSeries a e₁ e₂ g) * |
| (mappedInverseKernel a e₁ d₂ (crossingColumnAlg d₁ e₁ d₂ e₂) * |
| (mappedInverseKernel (fun i j=>a j i) e₁ d₂ (crossingColumnAlg d₁ e₁ d₂ e₂))⁻¹).val |
|
|
| lemma fourGrid_relativeTaylor_factor (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (f : S (d₁+d₂)) (g : S (e₁+e₂)) : |
| fourRelativeTaylor d₁ e₁ d₂ e₂ |
| (separateFour d₁ e₁ d₂ e₂ (fourGridPolynomial a f g d₁ e₁ d₂ e₂))= |
| Polynomial.map (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (relativeTaylor d₁ d₂ (restrictTensor (firstCut d₁ d₂) f)) * |
| Polynomial.map (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (relativeTaylor e₁ e₂ (restrictTensor (firstCut e₁ e₂) g)) * |
| fourRelativeTaylor d₁ e₁ d₂ e₂ (fourCrossTensor a d₁ e₁ d₂ e₂) := by |
| rw [separateFour_grid_factor a d₁ e₁ d₂ e₂ (firstCut d₁ d₂) (firstCut e₁ e₂)] |
| rw [←fourColumns_product d₁ e₁ d₂ e₂] |
| simp only [map_mul,←firstColumn_relativeTaylor,←secondColumn_relativeTaylor] |
|
|
| lemma polynomial_mapped_product {R S T : Type*} [CommRing R] [CommRing S] [CommRing T] |
| (f : R →+* T) (g : S →+* T) (p : Polynomial R) (q : Polynomial S) (r : Polynomial T) : |
| polynomial (Polynomial.map f p * Polynomial.map g q * r)= |
| mapRing f (polynomial p)*mapRing g (polynomial q)*polynomial r := by |
| rw [polynomial.map_mul,polynomial.map_mul,←polynomial_map,←polynomial_map] |
|
|
| omit [Fintype I] [DecidableEq I] in |
| private lemma fourPolynomial_mapped_product_pair (d₁ e₁ d₂ e₂ : I → ℕ) |
| (p : Polynomial (S d₁⊗[ℚ]S d₂)) (q : Polynomial (S e₁⊗[ℚ]S e₂)) : |
| polynomial (Polynomial.map (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom p * |
| Polynomial.map (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom q)= |
| mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom (polynomial p)* |
| mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom (polynomial q) := |
| (polynomial.map_mul _ _).trans |
| (congrArg₂ (fun x y => x * y) |
| (polynomial_map (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom p).symm |
| (polynomial_map (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom q).symm) |
|
|
| omit [Fintype I] [DecidableEq I] in |
| lemma fourPolynomial_mapped_product (d₁ e₁ d₂ e₂ : I → ℕ) |
| (p : Polynomial (S d₁⊗[ℚ]S d₂)) (q : Polynomial (S e₁⊗[ℚ]S e₂)) |
| (r : Polynomial ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂))) : |
| polynomial (Polynomial.map (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom p * |
| Polynomial.map (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom q * r)= |
| mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom (polynomial p)* |
| mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom (polynomial q)*polynomial r := by |
| calc |
| _ = polynomial (Polynomial.map (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom p * |
| Polynomial.map (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom q) * polynomial r := |
| polynomial.map_mul _ _ |
| _ = _ := congrArg (fun t => t * polynomial r) |
| (fourPolynomial_mapped_product_pair d₁ e₁ d₂ e₂ p q) |
|
|
| lemma fourGrid_taylor_factor (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (f : S (d₁+d₂)) (g : S (e₁+e₂)) : |
| polynomial (fourRelativeTaylor d₁ e₁ d₂ e₂ |
| (separateFour d₁ e₁ d₂ e₂ (fourGridPolynomial a f g d₁ e₁ d₂ e₂)))= |
| mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (polynomial (relativeTaylor d₁ d₂ (restrictTensor (firstCut d₁ d₂) f))) * |
| mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (polynomial (relativeTaylor e₁ e₂ (restrictTensor (firstCut e₁ e₂) g))) * |
| polynomial (fourRelativeTaylor d₁ e₁ d₂ e₂ (fourCrossTensor a d₁ e₁ d₂ e₂)) := by |
| rw [fourGrid_relativeTaylor_factor] |
| exact fourPolynomial_mapped_product d₁ e₁ d₂ e₂ _ _ _ |
|
|
| lemma negative_unit_word_rat {R : Type*} [CommRing R] [Algebra ℚ R] |
| (n : ℤ) (A B D : (LaurentSeries R)ˣ) : |
| ((-1)^n*(A*B*D)).val=HahnSeries.C (algebraMap ℚ R ((-1 : ℚ)^n))*(A.val*B.val*D.val) := by |
| rw [Units.val_mul,negative_unit_rat,Units.val_mul,Units.val_mul] |
|
|
| lemma fourTensorKernelRHS_scalar (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) : |
| (fourTensorKernelRHS a d₁ e₁ d₂ e₂).val= |
| HahnSeries.C (algebraMap ℚ ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) ((-1 : ℚ)^eulerForm a d₂ e₁)) * |
| ((fourFirstInverseUnit a d₁ e₁ d₂ e₂).val * |
| (fourSecondInverseUnit a d₁ e₁ d₂ e₂).val * |
| (fourCrossingInverseUnit a d₁ e₁ d₂ e₂ * |
| (fourCrossingInverseUnit (fun i j=>a j i) d₁ e₁ d₂ e₂)⁻¹).val) := by |
| unfold fourTensorKernelRHS |
| rw [Units.val_mul, negative_unit_rat] |
| rfl |
|
|
| lemma kernel_product_rearrange {R : Type*} [CommRing R] |
| (K L A B C D P Q r : R) (h : K*L*C=r*(A*B*D)) : |
| K*L*(P*Q*C)=r*((A*P)*(B*Q)*D) := by |
| calc |
| _ = (K*L*C)*(P*Q) := by ring |
| _ = _ := by rw [h]; ring |
|
|
| omit [Fintype I] [DecidableEq I] in |
| lemma four_rat_smul_series (d₁ e₁ d₂ e₂ : I → ℕ) (r : ℚ) |
| (x : LaurentSeries ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂))) : |
| r • x=HahnSeries.C (algebraMap ℚ ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) r)*x := |
| @rat_smul_series ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) |
| (cancelFourRing d₁ e₁ d₂ e₂) (cancelFourAlg d₁ e₁ d₂ e₂) r x |
|
|
| lemma firstColumn_tensorSeparationSeries (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (f : S (d₁+d₂)) : |
| mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom (tensorSeparationSeries a d₁ d₂ f)= |
| (fourFirstInverseUnit a d₁ e₁ d₂ e₂).val * |
| mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (polynomial (relativeTaylor d₁ d₂ (restrictTensor (firstCut d₁ d₂) f))) := |
| (mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom).map_mul _ _ |
|
|
| lemma secondColumn_tensorSeparationSeries (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (g : S (e₁+e₂)) : |
| mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom (tensorSeparationSeries a e₁ e₂ g)= |
| (fourSecondInverseUnit a d₁ e₁ d₂ e₂).val * |
| mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (polynomial (relativeTaylor e₁ e₂ (restrictTensor (firstCut e₁ e₂) g))) := |
| (mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom).map_mul _ _ |
|
|
| lemma fourInputSeries_factor (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (f : S (d₁+d₂)) (g : S (e₁+e₂)) : |
| fourInputSeries a d₁ e₁ d₂ e₂ f g= |
| ((fourFirstInverseUnit a d₁ e₁ d₂ e₂).val * |
| mapRing (firstColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (polynomial (relativeTaylor d₁ d₂ (restrictTensor (firstCut d₁ d₂) f)))) * |
| ((fourSecondInverseUnit a d₁ e₁ d₂ e₂).val * |
| mapRing (secondColumnAlg d₁ e₁ d₂ e₂).toRingHom |
| (polynomial (relativeTaylor e₁ e₂ (restrictTensor (firstCut e₁ e₂) g)))) * |
| (fourCrossingInverseUnit a d₁ e₁ d₂ e₂ * |
| (fourCrossingInverseUnit (fun i j=>a j i) d₁ e₁ d₂ e₂)⁻¹).val := by |
| exact congrArg₂ |
| (fun x y : LaurentSeries ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂)) => |
| x * y * (fourCrossingInverseUnit a d₁ e₁ d₂ e₂ * |
| (fourCrossingInverseUnit (fun i j=>a j i) d₁ e₁ d₂ e₂)⁻¹).val) |
| (firstColumn_tensorSeparationSeries a d₁ e₁ d₂ e₂ f) |
| (secondColumn_tensorSeparationSeries a d₁ e₁ d₂ e₂ g) |
|
|
| lemma kernel_product_rearrange_with_factors {R : Type*} [CommRing R] |
| (K L A B C D P Q r X Y : R) (h : K*L*C=r*(A*B*D)) |
| (hX : X=P*Q*C) (hY : Y=(A*P)*(B*Q)*D) : K*L*X=r*Y := by |
| rw [hX,hY] |
| exact kernel_product_rearrange K L A B C D P Q r h |
|
|
| lemma fourGrid_normalized_algebra (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (f : S (d₁+d₂)) (g : S (e₁+e₂)) |
| (K L r : LaurentSeries ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂))) |
| (h : K*L*polynomial (fourRelativeTaylor d₁ e₁ d₂ e₂ (fourCrossTensor a d₁ e₁ d₂ e₂))= |
| r*((fourFirstInverseUnit a d₁ e₁ d₂ e₂).val * |
| (fourSecondInverseUnit a d₁ e₁ d₂ e₂).val * |
| (fourCrossingInverseUnit a d₁ e₁ d₂ e₂ * |
| (fourCrossingInverseUnit (fun i j=>a j i) d₁ e₁ d₂ e₂)⁻¹).val)) : |
| K*L*polynomial (fourRelativeTaylor d₁ e₁ d₂ e₂ |
| (separateFour d₁ e₁ d₂ e₂ (fourGridPolynomial a f g d₁ e₁ d₂ e₂)))= |
| r*fourInputSeries a d₁ e₁ d₂ e₂ f g := |
| @kernel_product_rearrange_with_factors |
| (LaurentSeries ((S d₁⊗[ℚ]S e₁)⊗[ℚ](S d₂⊗[ℚ]S e₂))) (cancelSeriesRing d₁ e₁ d₂ e₂) |
| K L _ _ _ _ _ _ r _ _ h |
| (fourGrid_taylor_factor a d₁ e₁ d₂ e₂ f g) (fourInputSeries_factor a d₁ e₁ d₂ e₂ f g) |
|
|
| lemma fourGrid_normalized (a : I → I → ℕ) (d₁ e₁ d₂ e₂ : I → ℕ) |
| (A : Cut d₁ e₁) (B : Cut d₂ e₂) |
| (f : S (d₁+d₂)) (g : S (e₁+e₂)) : |
| (mappedInverseKernel a (d₁+e₁) (d₂+e₂) (restrictRows d₁ e₁ d₂ e₂ A B)).val * |
| ((mappedInverseKernel (fun _ _ : I=>0) (d₁+e₁) (d₂+e₂) (restrictRows d₁ e₁ d₂ e₂ A B))⁻¹).val * |
| polynomial (fourRelativeTaylor d₁ e₁ d₂ e₂ |
| (separateFour d₁ e₁ d₂ e₂ (fourGridPolynomial a f g d₁ e₁ d₂ e₂)))= |
| ((-1 : ℚ)^eulerForm a d₂ e₁) • fourInputSeries a d₁ e₁ d₂ e₂ f g := by |
| apply (fourGrid_normalized_algebra a d₁ e₁ d₂ e₂ f g _ _ _ |
| ((fourTensorKernel_cancellation a d₁ e₁ d₂ e₂ A B).trans |
| (fourTensorKernelRHS_scalar a d₁ e₁ d₂ e₂))).trans |
| exact (four_rat_smul_series d₁ e₁ d₂ e₂ _ _).symm |
|
|
| end ElementaryPositivity.RawShuffle |
|
|
| end OAI |
|
|
