| import OAI.Combinatorics.CompleteCrossing.OrderPairing |
| import OAI.Combinatorics.CompleteCrossing.Polynomials |
|
|
| namespace OAI |
|
|
| /-! Vertex specialization, local interpolation tests, and kernel vanishing. -/ |
|
|
| section |
|
|
| /-! Evaluation symmetries and genuine degree bounds after fixing a vertex. -/ |
| noncomputable section |
| open scoped BigOperators |
| namespace Paper170 |
|
|
| theorem evalFour_swapFirst (P : Poly4) (x u y v : ℝ) : |
| evalFour x u y v (swapFirstPair P) = evalFour u x y v P := by |
| induction P using MvPolynomial.induction_on with |
| | C r => simp [swapFirstPair, evalFour] |
| | add P Q hP hQ => simpa using congrArg₂ (·+·) hP hQ |
| | mul_X P i hP => |
| simp only [swapFirstPair, AlgHom.toLinearMap_apply, map_mul, MvPolynomial.rename_X] at hP ⊢ |
| change MvPolynomial.aeval ![x,u,y,v] _ = MvPolynomial.aeval ![u,x,y,v] _ |
| change MvPolynomial.aeval ![x,u,y,v] _ = MvPolynomial.aeval ![u,x,y,v] _ at hP |
| simp only [map_mul] |
| rw [hP] |
| fin_cases i <;> simp [Equiv.swap_apply_def, Fin.ext_iff] |
|
|
| theorem evalFour_swapSecond (P : Poly4) (x u y v : ℝ) : |
| evalFour x u y v (swapSecondPair P) = evalFour x u v y P := by |
| induction P using MvPolynomial.induction_on with |
| | C r => simp [swapSecondPair, evalFour] |
| | add P Q hP hQ => simpa using congrArg₂ (·+·) hP hQ |
| | mul_X P i hP => |
| simp only [swapSecondPair, AlgHom.toLinearMap_apply, map_mul, MvPolynomial.rename_X] at hP ⊢ |
| change MvPolynomial.aeval ![x,u,y,v] _ = MvPolynomial.aeval ![x,u,v,y] _ |
| change MvPolynomial.aeval ![x,u,y,v] _ = MvPolynomial.aeval ![x,u,v,y] _ at hP |
| simp only [map_mul] |
| rw [hP] |
| fin_cases i <;> simp [Equiv.swap_apply_def, Fin.ext_iff] |
|
|
| theorem vertexSpecialization_monomial (x : ℝ) (m : Fin 4 →₀ ℕ) (c : ℝ) : |
| vertexSpecialization x (MvPolynomial.monomial m c) = |
| MvPolynomial.C (c*x^m 0*x^m 2) * MvPolynomial.X 0^m 1 * MvPolynomial.X 1^m 3 := by |
| simp only [vertexSpecialization, MvPolynomial.aeval_monomial, MvPolynomial.algebraMap_eq] |
| rw [Finsupp.prod_fintype] |
| · simp [Fin.prod_univ_four] |
| ring |
| · intro i |
| simp |
|
|
| theorem vertexSpecialization_rectangle (s : ℕ) (P : endpointSymmetricSpace s) (x : ℝ) : |
| vertexSpecialization x P.val ∈ rectangle (s-2) (s-2) := by |
| have hp := ((symmetric_space_membership s P.val).mp P.property).1 |
| have hb (k : Fin 2) : (vertexSpecialization x P.val).degreeOf k ≤ s-2 := by |
| rw [P.val.as_sum, map_sum] |
| apply (MvPolynomial.degreeOf_sum_le k _ _).trans |
| apply Finset.sup_le |
| intro m hm |
| rw [vertexSpecialization_monomial] |
| have h1 := MvPolynomial.degreeOf_le_iff.mp (hp 1) m hm |
| have h3 := MvPolynomial.degreeOf_le_iff.mp (hp 3) m hm |
| have hmul := MvPolynomial.degreeOf_mul_le k |
| (MvPolynomial.C (P.val.coeff m*x^m 0*x^m 2)*MvPolynomial.X 0^m 1) |
| (MvPolynomial.X 1^m 3) |
| have hC := MvPolynomial.degreeOf_C_mul_le (MvPolynomial.X 0^m 1 : Poly2) k |
| (P.val.coeff m*x^m 0*x^m 2) |
| have hpow0 := MvPolynomial.degreeOf_pow_le k (MvPolynomial.X 0 : Poly2) (m 1) |
| have hpow1 := MvPolynomial.degreeOf_pow_le k (MvPolynomial.X 1 : Poly2) (m 3) |
| fin_cases k <;> norm_num [MvPolynomial.degreeOf_X, Fin.ext_iff] at hpow0 hpow1 hmul hC ⊢ <;> omega |
| exact (rectangle_membership _ _ _).mpr ⟨hb 0,hb 1⟩ |
|
|
| theorem neighbor_nodePolynomial {n : ℕ} (node : Fin n → ℝ) (i : Fin n) : |
| Zarankiewicz.nodePolynomial (fun p : {j : Fin n // j ≠ i} => node p.val) = |
| omittedNodePolynomial node i := by |
| classical |
| unfold Zarankiewicz.nodePolynomial omittedNodePolynomial |
| exact (Finset.prod_subtype (Finset.univ.erase i) (by simp) |
| (fun j => Polynomial.X-Polynomial.C (node j))).symm |
|
|
| theorem neighbor_nodeWeight {n : ℕ} (node : Fin n → ℝ) (hn : Function.Injective node) |
| (i : Fin n) (p : {j : Fin n // j ≠ i}) : |
| nodeWeight (fun q : {j : Fin n // j ≠ i} => node q.val) p = |
| (node p.val-node i)*nodeWeight node p.val := by |
| classical |
| rw [omitted_node_weight node hn i p.val p.property.symm] |
| unfold nodeWeight Zarankiewicz.derivativeAtNode |
| rw [neighbor_nodePolynomial] |
|
|
| theorem sum_away {n : ℕ} (i : Fin n) (f : Fin n → ℝ) (hi : f i=0) : |
| (∑j, f j) = ∑j : {j : Fin n // j ≠ i}, f j.val := by |
| classical |
| rw [← Finset.sum_erase_add _ _ (Finset.mem_univ i), hi, add_zero] |
| exact Finset.sum_subtype (Finset.univ.erase i) (by simp) f |
|
|
| end Paper170 |
|
|
| end |
| end |
|
|
| section |
|
|
| /-! The kernel vanishes on every orientation of an independent supported edge pair. -/ |
| noncomputable section |
| namespace Paper170 |
|
|
| theorem kernel_ordered_eval_zero {n s : ℕ} (node : Fin n → ℝ) (J : CrossingTensor n) |
| (P : endpointSymmetricSpace s) (hP : supportEvaluation s node J P = 0) |
| {i p k q : Fin n} (hip : i<p) (hkq : k<q) (hik : i≠k) (hiq : i≠q) |
| (hpk : p≠k) (hpq : p≠q) (hJ : J i p k q ≠ 0) : |
| evalFour (node i) (node p) (node k) (node q) P.val = 0 := by |
| classical |
| let a : SupportCoord J := ⟨((i,p),(k,q)), by |
| simp only [supportedPairs, Finset.mem_filter, Finset.mem_univ, true_and] |
| exact ⟨hip,hkq,hik,hiq,hpk,hpq,hJ⟩⟩ |
| exact congrFun hP a |
|
|
| theorem kernel_independent_eval_zero {n s : ℕ} (node : Fin n → ℝ) (J : CrossingTensor n) |
| (hreverseLeft : ∀i p k q, J p i k q = -J i p k q) |
| (hreverseRight : ∀i p k q, J i p q k = -J i p k q) |
| (P : endpointSymmetricSpace s) (hP : supportEvaluation s node J P = 0) |
| {i p k q : Fin n} (hip : i≠p) (hkq : k≠q) (hik : i≠k) (hiq : i≠q) |
| (hpk : p≠k) (hpq : p≠q) (hJ : J i p k q ≠ 0) : |
| evalFour (node i) (node p) (node k) (node q) P.val = 0 := by |
| have hsym := (symmetric_space_membership s P.val).mp P.property |
| have he1 (x u y v : ℝ) : evalFour x u y v P.val = evalFour u x y v P.val := by |
| rw [← evalFour_swapFirst, hsym.2.1] |
| have he2 (x u y v : ℝ) : evalFour x u y v P.val = evalFour x u v y P.val := by |
| rw [← evalFour_swapSecond, hsym.2.2] |
| rcases lt_or_gt_of_ne hip with hip | hpi |
| · rcases lt_or_gt_of_ne hkq with hkq | hqk |
| · exact kernel_ordered_eval_zero node J P hP hip hkq hik hiq hpk hpq hJ |
| · rw [he2] |
| apply kernel_ordered_eval_zero node J P hP hip hqk hiq hik hpq hpk |
| rw [hreverseRight i p k q] |
| exact neg_ne_zero.mpr hJ |
| · rw [he1] |
| rcases lt_or_gt_of_ne hkq with hkq | hqk |
| · apply kernel_ordered_eval_zero node J P hP hpi hkq hpk hpq hik hiq |
| rw [hreverseLeft i p k q] |
| exact neg_ne_zero.mpr hJ |
| · rw [he2] |
| apply kernel_ordered_eval_zero node J P hP hpi hqk hpq hpk hiq hik |
| rw [hreverseLeft i p q k, hreverseRight i p k q, neg_neg] |
| exact hJ |
|
|
| end Paper170 |
|
|
| end |
| end |
|
|
| section |
|
|
| /-! The local test polynomial reduces the global tensor sum to its adjacent-edge pairings. -/ |
| noncomputable section |
| open scoped BigOperators |
| namespace Paper170 |
|
|
| theorem evalFour_liftUnivariate (x u y v : ℝ) (i : Fin 4) (U : Polynomial ℝ) : |
| evalFour x u y v (liftUnivariate i U) = U.eval (![x,u,y,v] i) := by |
| change MvPolynomial.aeval ![x,u,y,v] (Polynomial.aeval (MvPolynomial.X i) U) = _ |
| rw [← Polynomial.aeval_algHom_apply] |
| simp |
|
|
| theorem evalFour_liftBivariate13 (x u y v : ℝ) (B : Poly2) : |
| evalFour x u y v (liftBivariate 1 3 B) = evalTwo u v B := by |
| have h : (MvPolynomial.aeval ![x,u,y,v]).comp |
| (MvPolynomial.aeval ![MvPolynomial.X 1,MvPolynomial.X 3] : Poly2 →ₐ[ℝ] Poly4) = |
| MvPolynomial.aeval ![u,v] := by |
| ext i |
| fin_cases i <;> simp |
| exact congrArg (fun f : Poly2 →ₐ[ℝ] ℝ => f B) h |
|
|
| theorem evalFour_localTestPolynomial (x u y v : ℝ) (P : Poly4) |
| (U V : Polynomial ℝ) (B : Poly2) : |
| evalFour x u y v (localTestPolynomial P U V B) = |
| evalFour x u y v P * (u-v) * (u-y) * (v-x) * |
| U.eval x * V.eval y * evalTwo u v B := by |
| have hm (Q R : Poly4) : evalFour x u y v (Q*R) = evalFour x u y v Q*evalFour x u y v R := |
| map_mul (MvPolynomial.aeval ![x,u,y,v]) Q R |
| simp only [localTestPolynomial, hm, evalFour_liftUnivariate, evalFour_liftBivariate13] |
| simp [evalFour] |
|
|
| def vertexTestSummand {n : ℕ} (node : Fin n → ℝ) (J : CrossingTensor n) (H : Poly4) |
| (i p k q : Fin n) : ℝ := |
| J i p k q * nodeWeight node i * nodeWeight node p * nodeWeight node k * nodeWeight node q * |
| evalFour (node i) (node p) (node k) (node q) H |
|
|
| theorem vertexTestSummand_offDiagonal {n s : ℕ} (node : Fin n → ℝ) (J : CrossingTensor n) |
| (hloopLeft : ∀i k q, J i i k q=0) (hloopRight : ∀i p k, J i p k k=0) |
| (hreverseLeft : ∀i p k q, J p i k q = -J i p k q) |
| (hreverseRight : ∀i p k q, J i p q k = -J i p k q) |
| (P : endpointSymmetricSpace s) (hP : supportEvaluation s node J P=0) |
| (U V : Polynomial ℝ) (B : Poly2) (i p k q : Fin n) (hik : i≠k) : |
| vertexTestSummand node J (localTestPolynomial P.val U V B) i p k q = 0 := by |
| by_cases hip : i=p |
| · subst p |
| simp [vertexTestSummand, hloopLeft] |
| by_cases hkq : k=q |
| · subst q |
| simp [vertexTestSummand, hloopRight] |
| by_cases hpq : p=q |
| · subst q |
| simp [vertexTestSummand, evalFour_localTestPolynomial] |
| by_cases hpk : p=k |
| · subst k |
| simp [vertexTestSummand, evalFour_localTestPolynomial] |
| by_cases hiq : i=q |
| · subst q |
| simp [vertexTestSummand, evalFour_localTestPolynomial] |
| by_cases hJ : J i p k q=0 |
| · simp [vertexTestSummand, hJ] |
| have hz := kernel_independent_eval_zero node J hreverseLeft hreverseRight P hP |
| hip hkq hik hiq hpk hpq hJ |
| simp [vertexTestSummand, evalFour_localTestPolynomial, hz] |
|
|
| theorem orderPairing_weight_form {ι : Type*} [Fintype ι] (node : ι → ℝ) |
| (order : LinearOrder ι) (A B : Poly2) : |
| orderPairing node order A B = ∑p, ∑q, |
| halfOrder order p q * (node p-node q) * nodeWeight node p * nodeWeight node q * |
| evalTwo (node p) (node q) A * evalTwo (node p) (node q) B := by |
| simp only [orderPairing, weightedPairing, nodeWeight, div_eq_mul_inv, mul_inv] |
| apply Finset.sum_congr rfl |
| intro p _ |
| apply Finset.sum_congr rfl |
| intro q _ |
| ring |
|
|
| theorem vertexTestSummand_diagonal {n : ℕ} (node : Fin n → ℝ) |
| (hn : Function.Injective node) (J : CrossingTensor n) |
| (orders : ∀i : Fin n, LinearOrder {j : Fin n // j≠i}) |
| (hlocal : ∀i (p q : {j : Fin n // j≠i}), J i p.val i q.val=halfOrder (orders i) p q) |
| (P : Poly4) (U V : Polynomial ℝ) (B : Poly2) (i : Fin n) |
| (p q : {j : Fin n // j≠i}) : |
| vertexTestSummand node J (localTestPolynomial P U V B) i p.val i q.val = |
| (nodeWeight node i)^2 * U.eval (node i) * V.eval (node i) * |
| (halfOrder (orders i) p q * (node p.val-node q.val) * |
| nodeWeight (fun j : {j : Fin n // j≠i} => node j.val) p * |
| nodeWeight (fun j : {j : Fin n // j≠i} => node j.val) q * |
| evalTwo (node p.val) (node q.val) (vertexSpecialization (node i) P) * |
| evalTwo (node p.val) (node q.val) B) := by |
| rw [vertexTestSummand, evalFour_localTestPolynomial, hlocal] |
| rw [neighbor_nodeWeight node hn, neighbor_nodeWeight node hn, vertex_eval] |
| ring |
|
|
| theorem polynomialTest_local_reduction {n s : ℕ} (node : Fin n → ℝ) |
| (hn : Function.Injective node) (J : CrossingTensor n) |
| (orders : ∀i : Fin n, LinearOrder {j : Fin n // j≠i}) |
| (hloopLeft : ∀i k q, J i i k q=0) (hloopRight : ∀i p k, J i p k k=0) |
| (hreverseLeft : ∀i p k q, J p i k q = -J i p k q) |
| (hreverseRight : ∀i p k q, J i p q k = -J i p k q) |
| (hlocal : ∀i (p q : {j : Fin n // j≠i}), J i p.val i q.val=halfOrder (orders i) p q) |
| (P : endpointSymmetricSpace s) (hP : supportEvaluation s node J P=0) |
| (U V : Polynomial ℝ) (B : Poly2) : |
| polynomialTest node J (localTestPolynomial P.val U V B) = |
| ∑i, (nodeWeight node i)^2 * U.eval (node i) * V.eval (node i) * |
| orderPairing (fun j : {j : Fin n // j≠i} => node j.val) (orders i) |
| (vertexSpecialization (node i) P.val) B := by |
| change (∑i, ∑p, ∑k, ∑q, vertexTestSummand node J (localTestPolynomial P.val U V B) i p k q)=_ |
| apply Finset.sum_congr rfl |
| intro i _ |
| have hk (p : Fin n) : |
| (∑k, ∑q, vertexTestSummand node J (localTestPolynomial P.val U V B) i p k q) = |
| ∑q, vertexTestSummand node J (localTestPolynomial P.val U V B) i p i q := by |
| apply Finset.sum_eq_single i |
| · intro k _ hki |
| apply Finset.sum_eq_zero |
| intro q _ |
| exact vertexTestSummand_offDiagonal node J hloopLeft hloopRight hreverseLeft hreverseRight |
| P hP U V B i p k q hki.symm |
| · simp |
| simp_rw [hk] |
| rw [sum_away i _ (by simp [vertexTestSummand,hloopLeft])] |
| have hq (p : {j : Fin n // j≠i}) : |
| (∑q, vertexTestSummand node J (localTestPolynomial P.val U V B) i p.val i q) = |
| ∑q : {j : Fin n // j≠i}, vertexTestSummand node J (localTestPolynomial P.val U V B) i p.val i q.val := |
| sum_away i _ (by simp [vertexTestSummand,hloopRight]) |
| simp_rw [hq, vertexTestSummand_diagonal node hn J orders hlocal] |
| rw [orderPairing_weight_form] |
| simp only [Finset.mul_sum] |
|
|
| end Paper170 |
|
|
| end |
| end |
|
|
| section |
|
|
| /-! Lagrange isolation of each vertex and the full kernel vertex-vanishing theorem. -/ |
| noncomputable section |
| open scoped BigOperators |
| namespace Paper170 |
|
|
| def vertexPairingFunctional {n : ℕ} (node : Fin n → ℝ) |
| (orders : ∀i : Fin n, LinearOrder {j : Fin n // j≠i}) (P : Poly4) (B : Poly2) : |
| Polynomial ℝ →ₗ[ℝ] ℝ := |
| ∑i, ((nodeWeight node i)^2 * |
| orderPairing (fun j : {j : Fin n // j≠i} => node j.val) (orders i) |
| (vertexSpecialization (node i) P) B) • (Polynomial.aeval (node i)).toLinearMap |
|
|
| theorem vertexPairingFunctional_apply {n : ℕ} (node : Fin n → ℝ) |
| (orders : ∀i : Fin n, LinearOrder {j : Fin n // j≠i}) (P : Poly4) (B : Poly2) |
| (W : Polynomial ℝ) : |
| vertexPairingFunctional node orders P B W = |
| ∑i, (nodeWeight node i)^2 * W.eval (node i) * |
| orderPairing (fun j : {j : Fin n // j≠i} => node j.val) (orders i) |
| (vertexSpecialization (node i) P) B := by |
| simp only [vertexPairingFunctional, LinearMap.sum_apply, LinearMap.smul_apply, |
| AlgHom.toLinearMap_apply, Polynomial.aeval_def, Algebra.algebraMap_self, Polynomial.eval₂_id, smul_eq_mul] |
| apply Finset.sum_congr rfl |
| intro i _ |
| ring |
|
|
| section CrossingTensor |
| variable {s : ℕ} (hs : 2 ≤ s) (node : Fin (2*s+1) → ℝ) |
| (hnode : Function.Injective node) (J : CrossingTensor (2*s+1)) |
| (orders : ∀i : Fin (2*s+1), LinearOrder {j : Fin (2*s+1) // j≠i}) |
| (hloopLeft : ∀i k q, J i i k q=0) (hloopRight : ∀i p k, J i p k k=0) |
| (hreverseLeft : ∀i p k q, J p i k q = -J i p k q) |
| (hreverseRight : ∀i p k q, J i p q k = -J i p k q) |
| (hskew : ∀i p k q, J k q i p = -J i p k q) |
| (hlocal : ∀i (p q : {j : Fin (2*s+1) // j≠i}), J i p.val i q.val=halfOrder (orders i) p q) |
| (htests : ∀H ∈ box4 (2*s-1), polynomialTest node J H=0) |
|
|
| include hs hnode hloopLeft hloopRight hreverseLeft hreverseRight hlocal htests in |
| theorem vertexPairingFunctional_zero (P : endpointSymmetricSpace s) |
| (hP : supportEvaluation s node J P=0) (B : Poly2) (hB : B∈rectangle (s-1) (s-1)) |
| (W : Polynomial ℝ) (hW : W∈Polynomial.degreeLT ℝ (2*s+1)) : |
| vertexPairingFunctional node orders P.val B W=0 := by |
| have hspan : Submodule.span ℝ {Q : Polynomial ℝ | ∃U V : Polynomial ℝ, |
| U.natDegree≤s ∧ V.natDegree≤s ∧ Q=U*V} ≤ |
| LinearMap.ker (vertexPairingFunctional node orders P.val B) := by |
| rw [Submodule.span_le] |
| rintro Q ⟨U,V,hU,hV,rfl⟩ |
| change vertexPairingFunctional node orders P.val B (U*V)=0 |
| have hz := htests (localTestPolynomial P.val U V B) (local_test_degree s hs P.val P.property U V hU hV B hB) |
| rw [polynomialTest_local_reduction node hnode J orders hloopLeft hloopRight |
| hreverseLeft hreverseRight hlocal P hP U V B] at hz |
| rw [vertexPairingFunctional_apply] |
| convert hz using 1 |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [Polynomial.eval_mul] |
| ring |
| rw [products_span_degree] at hspan |
| exact hspan hW |
|
|
| include hs hnode hloopLeft hloopRight hreverseLeft hreverseRight hlocal htests in |
| theorem kernel_local_pairing_zero (P : endpointSymmetricSpace s) |
| (hP : supportEvaluation s node J P=0) (i : Fin (2*s+1)) (B : Poly2) |
| (hB : B∈rectangle (s-1) (s-1)) : |
| orderPairing (fun j : {j : Fin (2*s+1) // j≠i} => node j.val) (orders i) |
| (vertexSpecialization (node i) P.val) B = 0 := by |
| classical |
| let W := Lagrange.basis Finset.univ node i |
| have hW : W∈Polynomial.degreeLT ℝ (2*s+1) := by |
| apply Polynomial.mem_degreeLT.mpr |
| rw [Lagrange.degree_basis hnode.injOn (Finset.mem_univ i)] |
| simp only [Finset.card_univ, Fintype.card_fin, Nat.add_sub_cancel_right] |
| exact_mod_cast (show 2*s < 2*s+1 by omega) |
| have hz := vertexPairingFunctional_zero hs node hnode J orders hloopLeft hloopRight |
| hreverseLeft hreverseRight hlocal htests P hP B hB W hW |
| rw [vertexPairingFunctional_apply] at hz |
| have heq : (∑j, (nodeWeight node j)^2 * W.eval (node j) * |
| orderPairing (fun k : {k : Fin (2*s+1) // k≠j} => node k.val) (orders j) |
| (vertexSpecialization (node j) P.val) B) = |
| (nodeWeight node i)^2 * |
| orderPairing (fun j : {j : Fin (2*s+1) // j≠i} => node j.val) (orders i) |
| (vertexSpecialization (node i) P.val) B := by |
| rw [Finset.sum_eq_single i] |
| · rw [show W.eval (node i)=1 from Lagrange.eval_basis_self hnode.injOn (Finset.mem_univ i), mul_one] |
| · intro j _ hji |
| rw [show W.eval (node j)=0 from Lagrange.eval_basis_of_ne hji.symm (Finset.mem_univ j)] |
| simp |
| · simp |
| rw [heq] at hz |
| exact (mul_eq_zero.mp hz).resolve_left (pow_ne_zero 2 (weight_nonzero node hnode i)) |
|
|
| include hs hnode orders hloopLeft hloopRight hreverseLeft hreverseRight hskew hlocal htests in |
| theorem kernel_vertex_vanishing (P : endpointSymmetricSpace s) |
| (hP : supportEvaluation s node J P=0) : ∀i, vertexSpecialization (node i) P.val=0 := by |
| have hlocal' : ∀j (p q : {j' : Fin (2*s+1) // j'≠j}), |
| J j p.val j q.val=halfOrder (orders j) p q := by |
| intro j p q |
| by_cases hpq : p=q |
| · subst q |
| have hh := hskew j p.val j p.val |
| have hz : J j p.val j p.val=0 := by linarith |
| have hpp := @lt_irrefl _ (orders j).toPartialOrder.toPreorder p |
| simp only [hz,halfOrder,ite_eq_right hpp] |
| · exact hlocal j p q |
| intro i |
| apply order_detector s hs (by simp [Fintype.card_subtype_compl]) |
| (fun j : {j : Fin (2*s+1) // j≠i} => node j.val) |
| (hnode.comp Subtype.val_injective) (orders i) _ (vertexSpecialization_rectangle s P (node i)) |
| intro B hB |
| exact kernel_local_pairing_zero hs node hnode J orders hloopLeft hloopRight |
| hreverseLeft hreverseRight hlocal' htests P hP i B hB |
|
|
| end CrossingTensor |
| end Paper170 |
|
|
| end |
| end |
|
|
| end OAI |
|
|
