| import OAI.GroupTheory.Hyperbolic.Model |
|
|
| namespace OAI |
|
|
| namespace Release075 |
|
|
| universe u v |
|
|
| open scoped BigOperators |
|
|
| theorem det_abs_le_prod_row_norm {n : ℕ} (A : Matrix (Fin n) (Fin n) ℝ) : |
| |A.det| ≤ ∏ i, ‖(WithLp.toLp 2 (A i) : EuclideanSpace ℝ (Fin n))‖ := by |
| let b := EuclideanSpace.basisFun (Fin n) ℝ |
| let v : Fin n → EuclideanSpace ℝ (Fin n) := fun i => WithLp.toLp 2 (A i) |
| have : Fact (Module.finrank ℝ (EuclideanSpace ℝ (Fin n)) = n) := ⟨by simp⟩ |
| have h := b.toBasis.orientation.abs_volumeForm_apply_le v |
| rw [b.toBasis.orientation.volumeForm_robust b rfl] at h |
| have hmat : b.toBasis.toMatrix v = A.transpose := by |
| ext i j |
| simp [Module.Basis.toMatrix_apply, b, v, Matrix.transpose_apply] |
| simpa [Module.Basis.det_apply, hmat, Matrix.det_transpose, v] using h |
|
|
| /-- A matrix has a spanning independent subset of its rows, with the expected size. -/ |
| theorem exists_row_basis {ι κ K : Type*} [Fintype ι] [Fintype κ] [Field K] |
| (M : Matrix ι κ K) : |
| ∃ S : Finset ι, S.card = M.rank ∧ |
| LinearIndependent K (fun i : S => M i.val) ∧ |
| ∀ i, ∃ c : S → K, M i = ∑ j : S, c j • M j.val := by |
| classical |
| obtain ⟨T, _, _, hspan, hlin⟩ := exists_linearIndepOn_extension |
| (linearIndepOn_empty K M.row) (Set.empty_subset (Set.univ : Set ι)) |
| let S := T.toFinset |
| have hS : (S : Set ι) = T := Set.coe_toFinset T |
| have hlinS : LinearIndepOn K M.row (S : Set ι) := by rw [hS]; exact hlin |
| have hrange : Set.range (fun i : S => M.row i.val) = M.row '' (S : Set ι) := by |
| ext x |
| simp |
| have hsp : Submodule.span K (Set.range (fun i : S => M.row i.val)) = |
| Submodule.span K (Set.range M.row) := by |
| rw [hrange] |
| apply le_antisymm |
| · exact Submodule.span_mono (Set.image_subset_range _ _) |
| · apply Submodule.span_le.mpr |
| rw [hS] |
| simpa only [Set.image_univ] using hspan |
| refine ⟨S, ?_, hlinS, ?_⟩ |
| · rw [M.rank_eq_finrank_span_row, ← hsp] |
| simpa only [Finset.coe_sort_coe, Fintype.card_coe] using (finrank_span_eq_card hlinS).symm |
| · intro i |
| have hi : M.row i ∈ Submodule.span K (Set.range (fun j : S => M.row j.val)) := by |
| rw [hsp] |
| exact Submodule.subset_span (Set.mem_range_self i) |
| rcases (Submodule.mem_span_range_iff_exists_fun K).mp hi with ⟨c, hc⟩ |
| exact ⟨c, hc.symm⟩ |
|
|
| /-- Factoring a common divisor from all rows outside a specified set. -/ |
| theorem pow_sub_card_dvd_det {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (A : Matrix ι ι ℤ) (S : Finset ι) (q : ℤ) |
| (h : ∀ i, i ∉ S → ∀ j, q ∣ A i j) : |
| q ^ (Fintype.card ι - S.card) ∣ A.det := by |
| classical |
| have hd : ∀ i j, (if i ∈ S then (1 : ℤ) else q) ∣ A i j := by |
| intro i j |
| split_ifs with hi |
| · exact one_dvd _ |
| · exact h i hi j |
| choose B hB using hd |
| have hA : A = Matrix.of (fun i j => (if i ∈ S then (1 : ℤ) else q) * B i j) := by |
| ext i j |
| exact hB i j |
| have hprod : (∏ i : ι, if i ∈ S then (1 : ℤ) else q) = |
| q ^ (Fintype.card ι - S.card) := by |
| simp only [Finset.prod_ite, Finset.prod_const_one, one_mul, Finset.prod_const] |
| congr 1 |
| have hcard := Finset.card_filter_add_card_filter_not (s := Finset.univ) (· ∈ S) |
| have hfilter : Finset.univ.filter (· ∈ S) = S := by ext; simp |
| rw [hfilter, Finset.card_univ] at hcard |
| omega |
| refine ⟨Matrix.det (Matrix.of B), ?_⟩ |
| rw [hA] |
| simpa only [hprod, Matrix.of_apply] using Matrix.det_mul_column (fun i => if i ∈ S then (1 : ℤ) else q) (Matrix.of B) |
|
|
| /-- The integral determinant detects the rank lost in reduction modulo a prime. -/ |
| theorem pow_card_sub_rank_dvd_det {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (A : Matrix ι ι ℤ) (q : ℕ) [Fact q.Prime] : |
| (q : ℤ) ^ (Fintype.card ι - (A.map (Int.cast : ℤ → ZMod q)).rank) ∣ A.det := by |
| classical |
| let M : Matrix ι ι (ZMod q) := A.map Int.cast |
| obtain ⟨S, hScard, _, hspan⟩ := exists_row_basis M |
| choose c hc using hspan |
| let C : Matrix ι ι ℤ := fun i j => |
| if i ∈ S then 0 else if hj : j ∈ S then (c i ⟨j, hj⟩).cast else 0 |
| have hCC : C * C = 0 := by |
| ext i j |
| simp only [Matrix.mul_apply, Matrix.zero_apply] |
| apply Finset.sum_eq_zero |
| intro k _ |
| by_cases hk : k ∈ S |
| · simp [C, hk] |
| · by_cases hi : i ∈ S <;> simp [C, hi, hk] |
| have hunit : IsUnit (1 - C).det := by |
| apply isUnit_iff_dvd_one.mpr |
| refine ⟨(1 + C).det, ?_⟩ |
| rw [← Matrix.det_mul] |
| have hinv : (1 - C) * (1 + C) = 1 := by |
| simp [mul_add, sub_mul, hCC] |
| rw [hinv, Matrix.det_one] |
| have hdiv : ∀ i, i ∉ S → ∀ j, (q : ℤ) ∣ ((1 - C) * A) i j := by |
| intro i hi j |
| apply (ZMod.intCast_zmod_eq_zero_iff_dvd _ q).mp |
| rw [sub_mul, one_mul] |
| simp only [Matrix.sub_apply, Matrix.mul_apply, Int.cast_sub, Int.cast_sum, Int.cast_mul] |
| apply sub_eq_zero.mpr |
| have hrestrict : (∑ k : ι, (C i k : ZMod q) * (A k j : ZMod q)) = |
| ∑ k ∈ S, (C i k : ZMod q) * (A k j : ZMod q) := by |
| symm |
| apply Finset.sum_subset (Finset.subset_univ S) |
| intro k _ hk |
| simp [C, hi, hk] |
| rw [hrestrict, ← Finset.sum_coe_sort] |
| have heval := congrArg (fun v : ι → ZMod q => v j) (hc i) |
| simpa [C, hi, M, Matrix.map_apply, Finset.sum_apply, Pi.smul_apply, smul_eq_mul] using heval |
| have hd := pow_sub_card_dvd_det ((1 - C) * A) S (q : ℤ) hdiv |
| rw [Matrix.det_mul] at hd |
| rw [← hScard] |
| exact hunit.dvd_mul_left.mp hd |
|
|
| /-- A full-rank minor exists over a field; both index maps are injective. -/ |
| theorem exists_full_rank_minor {ι κ K : Type*} [Fintype ι] [Fintype κ] [Field K] |
| (M : Matrix ι κ K) : |
| ∃ (f : Fin M.rank → ι) (g : Fin M.rank → κ), |
| Function.Injective f ∧ Function.Injective g ∧ (M.submatrix f g).det ≠ 0 := by |
| classical |
| obtain ⟨S, hScard, hSlin, _⟩ := exists_row_basis M |
| have hScard' : Fintype.card S = M.rank := by simpa using hScard |
| let eS : Fin M.rank ≃ S := (Fintype.equivFinOfCardEq hScard').symm |
| let f : Fin M.rank → ι := fun i => (eS i).val |
| let R : Matrix (Fin M.rank) κ K := M.submatrix f id |
| have hRlin : LinearIndependent K R.row := hSlin.comp eS eS.injective |
| have hRrank : R.rank = M.rank := by |
| simpa only [Fintype.card_fin] using hRlin.rank_matrix |
| obtain ⟨T, hTcard, hTlin, _⟩ := exists_row_basis R.transpose |
| have hTcard' : Fintype.card T = M.rank := by |
| simpa only [Fintype.card_coe, Matrix.rank_transpose, hRrank] using hTcard |
| let eT : Fin M.rank ≃ T := (Fintype.equivFinOfCardEq hTcard').symm |
| let g : Fin M.rank → κ := fun i => (eT i).val |
| have hBlin : LinearIndependent K (M.submatrix f g).col := hTlin.comp eT eT.injective |
| refine ⟨f, g, Subtype.val_injective.comp eS.injective, |
| Subtype.val_injective.comp eT.injective, ?_⟩ |
| exact Matrix.nonsingular_iff_det_ne_zero.mp (Matrix.Nonsingular.of_linearIndependent_col hBlin) |
|
|
| /-- The squared form of Hadamard's inequality avoids fractional exponents. -/ |
| theorem det_sq_le_pow_of_row_sq_le {n : ℕ} (A : Matrix (Fin n) (Fin n) ℝ) |
| (r : ℝ) (hrow : ∀ i, ∑ j, A i j ^ 2 ≤ r) : A.det ^ 2 ≤ r ^ n := by |
| have h := det_abs_le_prod_row_norm A |
| have hsquare : A.det ^ 2 ≤ |
| (∏ i, ‖(WithLp.toLp 2 (A i) : EuclideanSpace ℝ (Fin n))‖) ^ 2 := by |
| simpa only [sq_abs] using pow_le_pow_left₀ (abs_nonneg A.det) h 2 |
| rw [← Finset.prod_pow] at hsquare |
| apply hsquare.trans |
| calc |
| (∏ i, ‖(WithLp.toLp 2 (A i) : EuclideanSpace ℝ (Fin n))‖ ^ 2) |
| ≤ ∏ _i : Fin n, r := by |
| apply Finset.prod_le_prod₀ |
| · intro i _; positivity |
| · intro i _ |
| simpa only [EuclideanSpace.real_norm_sq_eq] using hrow i |
| _ = r ^ n := by simp |
|
|
| /-- A nonsingular integer matrix loses less than half its rank modulo a prime |
| larger than the common squared row-norm bound. -/ |
| theorem nonsingular_rank_reduction_half {n : ℕ} (A : Matrix (Fin n) (Fin n) ℤ) |
| (hdet : A.det ≠ 0) (r : ℝ) (hr : 1 ≤ r) |
| (hrow : ∀ i, ∑ j, (A i j : ℝ) ^ 2 ≤ r) |
| (q : ℕ) [Fact q.Prime] (hqr : r < q) : |
| n ≤ 2 * (A.map (Int.cast : ℤ → ZMod q)).rank := by |
| let AR : Matrix (Fin n) (Fin n) ℝ := A.map Int.cast |
| let d := (A.map (Int.cast : ℤ → ZMod q)).rank |
| have hcastdet : AR.det = (A.det : ℝ) := by |
| simpa [AR] using (RingHom.map_det (Int.castRingHom ℝ) A).symm |
| have hbound : AR.det ^ 2 ≤ r ^ n := det_sq_le_pow_of_row_sq_le AR r hrow |
| have hdiv : (q : ℤ) ^ (n - d) ∣ A.det := by |
| simpa only [Fintype.card_fin] using pow_card_sub_rank_dvd_det A q |
| have hleI : (q : ℤ) ^ (n - d) ≤ |A.det| := |
| Int.le_of_dvd (abs_pos.mpr hdet) ((dvd_abs _ _).mpr hdiv) |
| have hleR : (q : ℝ) ^ (n - d) ≤ |AR.det| := by |
| rw [hcastdet] |
| exact_mod_cast hleI |
| have hsq := pow_le_pow_left₀ (pow_nonneg (Nat.cast_nonneg q) (n - d)) hleR 2 |
| rw [sq_abs, ← pow_mul] at hsq |
| by_cases hn : n = 0 |
| · simp [hn] |
| have hrnonneg : 0 ≤ r := le_trans zero_le_one hr |
| have hstrict : (q : ℝ) ^ ((n - d) * 2) < (q : ℝ) ^ n := |
| (hsq.trans hbound).trans_lt (pow_lt_pow_left₀ hqr hrnonneg hn) |
| have hexp : (n - d) * 2 < n := |
| (pow_lt_pow_iff_right₀ (lt_of_le_of_lt hr hqr)).mp hstrict |
| change n ≤ 2 * d |
| omega |
|
|
| theorem rank_reduction_half {ι κ : Type*} [Fintype ι] [Fintype κ] |
| (M : Matrix ι κ ℤ) (r : ℝ) (hr : 1 ≤ r) |
| (hrow : ∀ i, ∑ j, (M i j : ℝ) ^ 2 ≤ r) |
| (q : ℕ) [Fact q.Prime] (hqr : r < q) : |
| (M.map (Int.cast : ℤ → ℝ)).rank ≤ |
| 2 * (M.map (Int.cast : ℤ → ZMod q)).rank := by |
| classical |
| let MR := M.map (Int.cast : ℤ → ℝ) |
| obtain ⟨f, g, _, hg, hdet⟩ := exists_full_rank_minor MR |
| let B := M.submatrix f g |
| have hBR : B.map (Int.cast : ℤ → ℝ) = MR.submatrix f g := by |
| rw [Matrix.submatrix_map] |
| have hBdet : B.det ≠ 0 := by |
| intro h |
| apply hdet |
| have hcast : (B.map (Int.cast : ℤ → ℝ)).det = (B.det : ℝ) := by |
| simpa using (RingHom.map_det (Int.castRingHom ℝ) B).symm |
| rw [← hBR, hcast, h] |
| simp |
| have hBrow : ∀ i, ∑ j, (B i j : ℝ) ^ 2 ≤ r := by |
| intro i |
| apply le_trans _ (hrow (f i)) |
| change (∑ j, (M (f i) (g j) : ℝ) ^ 2) ≤ _ |
| rw [← Finset.sum_image (f := fun j => (M (f i) j : ℝ) ^ 2) |
| (s := Finset.univ) hg.injOn] |
| exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (by |
| intro j _ _; positivity) |
| have hh := nonsingular_rank_reduction_half B hBdet r hr hBrow q hqr |
| apply hh.trans |
| apply Nat.mul_le_mul_left |
| change ((M.submatrix f g).map (Int.cast : ℤ → ZMod q)).rank ≤ _ |
| rw [← Matrix.submatrix_map] |
| exact Matrix.rank_submatrix_le _ _ _ |
|
|
| /-- The trace-rank inequality used on a Gram matrix in the finite quotient. -/ |
| theorem trace_sq_le_rank_mul_trace_sq {ι : Type*} [Fintype ι] |
| (A : Matrix ι ι ℝ) (hA : A.IsHermitian) : |
| A.trace ^ 2 ≤ (A.rank : ℝ) * (A * A).trace := by |
| classical |
| have htrace : (A * A).trace = ∑ i, hA.eigenvalues i ^ 2 := by |
| conv_lhs => rw [hA.spectral_theorem, ← map_mul, Matrix.diagonal_mul_diagonal, |
| Unitary.conjStarAlgAut_apply, Matrix.trace_mul_cycle, Unitary.coe_star_mul_self, |
| one_mul, Matrix.trace_diagonal] |
| simp [pow_two] |
| rw [hA.trace_eq_sum_eigenvalues, htrace, hA.rank_eq_card_non_zero_eigs] |
| let T : Finset ι := Finset.univ.filter (fun i => hA.eigenvalues i ≠ 0) |
| have hcard : Fintype.card {i // hA.eigenvalues i ≠ 0} = T.card := by |
| simp [T, Fintype.card_subtype] |
| have hsum : (∑ i ∈ T, hA.eigenvalues i) = ∑ i, hA.eigenvalues i := |
| Finset.sum_filter_ne_zero _ |
| have hsum2 : (∑ i ∈ T, hA.eigenvalues i ^ 2) = ∑ i, hA.eigenvalues i ^ 2 := by |
| apply Finset.sum_subset (Finset.filter_subset _ _) |
| intro i _ hi |
| have : hA.eigenvalues i = 0 := by simpa [T] using hi |
| simp [this] |
| have hcs := Finset.sum_mul_sq_le_sq_mul_sq T (fun _ => (1 : ℝ)) hA.eigenvalues |
| simpa [hsum, hsum2, hcard] using hcs |
|
|
| /-- Subadditivity of matrix rank over a field. -/ |
| theorem rank_add_le {ι κ K : Type*} [Fintype ι] [Fintype κ] [Field K] |
| (A B : Matrix ι κ K) : (A + B).rank ≤ A.rank + B.rank := by |
| rw [Matrix.rank, Matrix.mulVecLin_add] |
| exact (Submodule.finrank_mono (LinearMap.range_add_le _ _)).trans |
| (Submodule.finrank_add_le_finrank_add_finrank _ _) |
|
|
| theorem rank_sum_le {ι κ τ K : Type*} [Fintype ι] [Fintype κ] [Field K] |
| (s : Finset τ) (A : τ → Matrix ι κ K) : (∑ t ∈ s, A t).rank ≤ ∑ t ∈ s, (A t).rank := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp [Matrix.rank_zero] |
| | @insert t s ht ih => |
| simp only [Finset.sum_insert ht] |
| exact (rank_add_le _ _).trans (Nat.add_le_add_left ih _) |
|
|
| /-- The left regular permutation representation over any coefficient semiring. -/ |
| def regularMatrix {F R : Type*} [Group F] [Fintype F] [DecidableEq F] [Semiring R] : |
| F →* Matrix F F R := Matrix.permMatrixHom.comp (MulAction.toPermHom F F) |
|
|
| @[simp] theorem regularMatrix_apply {F R : Type*} [Group F] [Fintype F] |
| [DecidableEq F] [Semiring R] (g a b : F) : |
| regularMatrix (R := R) g a b = if a = g * b then 1 else 0 := by |
| simp [regularMatrix, Matrix.permMatrixHom, Equiv.Perm.permMatrix, |
| PEquiv.toMatrix, Equiv.toPEquiv_apply, inv_mul_eq_iff_eq_mul] |
|
|
| @[simp] theorem regularMatrix_transpose {F R : Type*} [Group F] [Fintype F] |
| [DecidableEq F] [Semiring R] (g : F) : |
| (regularMatrix (R := R) g).transpose = regularMatrix g⁻¹ := by |
| ext a b |
| simp [eq_inv_mul_iff_mul_eq, eq_comm] |
|
|
| @[simp] theorem regularMatrix_trace {F R : Type*} [Group F] [Fintype F] |
| [DecidableEq F] [Semiring R] (g : F) : |
| (regularMatrix (R := R) g).trace = if g = 1 then (Fintype.card F : R) else 0 := by |
| by_cases hg : g = 1 |
| · subst g; simp |
| · have hfix : ∀ a : F, a ≠ g * a := by |
| intro a ha |
| exact hg (mul_right_cancel (show g * a = 1 * a by simpa using ha.symm)) |
| simp [Matrix.trace, hfix, hg] |
|
|
| /-- Flatten a rectangular matrix of blocks, with the block index first. -/ |
| def flattenMatrix {ι κ α β R : Type*} (A : Matrix ι κ (Matrix α β R)) : |
| Matrix (ι × α) (κ × β) R := fun i j => A i.1 j.1 i.2 j.2 |
|
|
| @[simp] theorem flattenMatrix_apply {ι κ α β R : Type*} |
| (A : Matrix ι κ (Matrix α β R)) (i : ι × α) (j : κ × β) : |
| flattenMatrix A i j = A i.1 j.1 i.2 j.2 := rfl |
|
|
| theorem flattenMatrix_mul {ι κ τ F R : Type*} [Fintype κ] [Fintype F] |
| [DecidableEq F] [Semiring R] (A : Matrix ι κ (Matrix F F R)) |
| (B : Matrix κ τ (Matrix F F R)) : |
| flattenMatrix (A * B) = flattenMatrix A * flattenMatrix B := by |
| ext ⟨i,a⟩ ⟨j,b⟩ |
| simp [flattenMatrix, Matrix.mul_apply, Fintype.sum_prod_type, Matrix.sum_apply] |
|
|
| theorem flattenMatrix_transpose {ι κ α β R : Type*} |
| (A : Matrix ι κ (Matrix α β R)) : |
| (flattenMatrix A).transpose = flattenMatrix (Matrix.of fun i j => (A j i).transpose) := rfl |
|
|
| theorem flattenMatrix_trace {ι F R : Type*} [Fintype ι] [Fintype F] |
| [AddCommMonoid R] (A : Matrix ι ι (Matrix F F R)) : |
| (flattenMatrix A).trace = ∑ i, (A i i).trace := by |
| simp [Matrix.trace, Fintype.sum_prod_type, flattenMatrix] |
|
|
| /-- The block regular-representation matrix attached to one line label. -/ |
| def quotientMatrix {ι F R : Type*} [Group F] [Fintype F] [DecidableEq F] |
| [Semiring R] (g : ι → ι → F) : Matrix (ι × F) (ι × F) R := |
| flattenMatrix (Matrix.of fun u v => regularMatrix (g u v)) |
|
|
| theorem quotientMatrix_gram {ι F R : Type*} [Fintype ι] [Group F] |
| [Fintype F] [DecidableEq F] [Semiring R] (g : ι → ι → F) : |
| quotientMatrix (R := R) g * (quotientMatrix g).transpose = |
| flattenMatrix (Matrix.of fun u u' => ∑ v, regularMatrix (g u v * (g u' v)⁻¹)) := by |
| rw [quotientMatrix, flattenMatrix_transpose, ← flattenMatrix_mul] |
| congr 1 |
| ext u u' a b |
| simp [Matrix.of_apply, Matrix.mul_apply, Matrix.sum_apply, ← map_mul] |
|
|
| theorem quotientMatrix_gram_trace {ι F R : Type*} [Fintype ι] [Group F] |
| [Fintype F] [DecidableEq F] [Semiring R] (g : ι → ι → F) : |
| (quotientMatrix (R := R) g * (quotientMatrix g).transpose).trace = |
| (Fintype.card ι : R) ^ 2 * Fintype.card F := by |
| rw [quotientMatrix_gram, flattenMatrix_trace] |
| simp only [Matrix.of_apply, mul_inv_cancel, map_one, Matrix.trace_sum] |
| simp [pow_two, mul_assoc] |
|
|
| /-- The second trace expansion, before counting degenerate rectangles. -/ |
| theorem quotientMatrix_gram_sq_trace {ι F R : Type*} [Fintype ι] [Group F] |
| [Fintype F] [DecidableEq F] [Semiring R] (g : ι → ι → F) : |
| ((quotientMatrix (R := R) g * (quotientMatrix g).transpose) * |
| (quotientMatrix g * (quotientMatrix g).transpose)).trace = |
| ∑ u, ∑ u', ∑ v, ∑ v', (regularMatrix (R := R) |
| (g u v * (g u' v)⁻¹ * g u' v' * (g u v')⁻¹)).trace := by |
| rw [quotientMatrix_gram, ← flattenMatrix_mul, flattenMatrix_trace] |
| simp only [Matrix.mul_apply, Matrix.of_apply, Matrix.sum_mul, Matrix.mul_sum, ← map_mul, |
| Matrix.trace_sum, mul_assoc] |
| apply Finset.sum_congr rfl |
| intro u _ |
| apply Finset.sum_congr rfl |
| intro u' _ |
| exact Finset.sum_comm |
|
|
| /-- Nondegenerate rectangular words survive in the finite group. -/ |
| def RectanglesSurvive {ι F : Type*} [Group F] (g : ι → ι → F) : Prop := |
| ∀ u u' v v', u ≠ u' → v ≠ v' → |
| g u v * (g u' v)⁻¹ * g u' v' * (g u v')⁻¹ ≠ 1 |
|
|
| /-- The exact count `2r^3-r^2` of degenerate index choices. -/ |
| theorem quotientMatrix_gram_sq_trace_of_rectangles {ι F R : Type*} [Fintype ι] |
| [Group F] [Fintype F] [DecidableEq F] [CommRing R] |
| (g : ι → ι → F) (hg : RectanglesSurvive g) : |
| ((quotientMatrix (R := R) g * (quotientMatrix g).transpose) * |
| (quotientMatrix g * (quotientMatrix g).transpose)).trace = |
| (2 * (Fintype.card ι : R) ^ 3 - (Fintype.card ι : R) ^ 2) * Fintype.card F := by |
| classical |
| rw [quotientMatrix_gram_sq_trace] |
| have ht (u u' v v' : ι) : |
| (regularMatrix (R := R) (g u v * (g u' v)⁻¹ * g u' v' * (g u v')⁻¹)).trace = |
| (if u = u' then (Fintype.card F : R) else 0) + |
| (if v = v' then (Fintype.card F : R) else 0) - |
| (if u = u' ∧ v = v' then (Fintype.card F : R) else 0) := by |
| by_cases hu : u = u' |
| · subst u' |
| simp only [mul_inv_cancel, one_mul, regularMatrix_trace, |
| true_and, add_sub_cancel_right] |
| · by_cases hv : v = v' |
| · subst v' |
| simp [mul_assoc, hu] |
| · simp only [regularMatrix_trace, ite_eq_right (hg u u' v v' hu hv), ite_eq_right hu, |
| ite_eq_right hv, ite_eq_right (not_and.mpr (fun h => (hu h).elim)), add_zero, sub_zero] |
| simp only [ht, Finset.sum_sub_distrib, Finset.sum_add_distrib, ite_and] |
| simp [pow_succ, mul_assoc, sub_mul] |
| ring |
|
|
| /-- Each integral row has exactly one unit entry per block column. -/ |
| theorem quotientMatrix_row_sq {ι F : Type*} [Fintype ι] [Group F] |
| [Fintype F] [DecidableEq F] (g : ι → ι → F) (i : ι × F) : |
| ∑ j, ((quotientMatrix (R := ℤ) g i j : ℤ) : ℝ) ^ 2 = Fintype.card ι := by |
| rw [Fintype.sum_prod_type] |
| simp [quotientMatrix, flattenMatrix, Matrix.of_apply, ← inv_mul_eq_iff_eq_mul] |
|
|
| /-- Casting the integral matrix gives the corresponding coefficient representation. -/ |
| theorem quotientMatrix_map {ι F R : Type*} [Group F] [Fintype F] |
| [DecidableEq F] [Ring R] (g : ι → ι → F) : |
| (quotientMatrix (R := ℤ) g).map (Int.cast : ℤ → R) = quotientMatrix (R := R) g := by |
| ext i j |
| simp [quotientMatrix, flattenMatrix] |
|
|
| theorem quotientMatrix_rank_real_lower {ι F : Type*} [Fintype ι] [Group F] |
| [Fintype F] [DecidableEq F] (g : ι → ι → F) (hg : RectanglesSurvive g) : |
| Fintype.card ι * Fintype.card F ≤ 2 * (quotientMatrix (R := ℝ) g).rank := by |
| by_cases hzero : Fintype.card ι = 0 |
| · simp [hzero] |
| let Y := quotientMatrix (R := ℝ) g |
| have hA : (Y * Y.transpose).IsHermitian := by |
| exact Matrix.isHermitian_mul_conjTranspose_self Y |
| have hArank : (Y * Y.transpose).rank = Y.rank := by |
| exact Matrix.rank_self_mul_conjTranspose Y |
| have h := trace_sq_le_rank_mul_trace_sq (Y * Y.transpose) hA |
| rw [hArank] at h |
| change (quotientMatrix (R := ℝ) g * (quotientMatrix g).transpose).trace ^ 2 ≤ _ at h |
| rw [quotientMatrix_gram_trace] at h |
| change _ ≤ (Y.rank : ℝ) * ((quotientMatrix (R := ℝ) g * (quotientMatrix g).transpose) * |
| (quotientMatrix g * (quotientMatrix g).transpose)).trace at h |
| rw [quotientMatrix_gram_sq_trace_of_rectangles g hg] at h |
| let r : ℝ := Fintype.card ι |
| let D : ℝ := Fintype.card F |
| have hr : 0 < r := by |
| dsimp [r] |
| exact_mod_cast Nat.pos_of_ne_zero hzero |
| have hD : 0 < D := by |
| dsimp [D] |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card F) |
| have hk : 0 ≤ (Y.rank : ℝ) := Nat.cast_nonneg _ |
| have hcancel : (r ^ 3 * D) * (r * D) ≤ (r ^ 3 * D) * (2 * (Y.rank : ℝ)) := by |
| calc |
| _ = (r ^ 2 * D) ^ 2 := by ring |
| _ ≤ (Y.rank : ℝ) * ((2 * r ^ 3 - r ^ 2) * D) := h |
| _ ≤ _ := by nlinarith [mul_nonneg (mul_nonneg hk (sq_nonneg r)) hD.le] |
| have hf := (mul_le_mul_iff_right₀ (show 0 < r ^ 3 * D by positivity)).mp hcancel |
| dsimp [r, D, Y] at hf |
| exact_mod_cast hf |
|
|
| theorem quotientMatrix_rank_mod_lower {ι F : Type*} [Fintype ι] [Group F] |
| [Fintype F] [DecidableEq F] (g : ι → ι → F) (hg : RectanglesSurvive g) |
| (q : ℕ) [Fact q.Prime] (hq : Fintype.card ι < q) : |
| Fintype.card ι * Fintype.card F ≤ 4 * (quotientMatrix (R := ZMod q) g).rank := by |
| by_cases hzero : Fintype.card ι = 0 |
| · simp [hzero] |
| have hr : (1 : ℝ) ≤ Fintype.card ι := by exact_mod_cast Nat.one_le_iff_ne_zero.mpr hzero |
| have hqr : (Fintype.card ι : ℝ) < q := by exact_mod_cast hq |
| have hred := rank_reduction_half (quotientMatrix (R := ℤ) g) (Fintype.card ι) hr |
| (fun i => (quotientMatrix_row_sq g i).le) q hqr |
| rw [quotientMatrix_map, quotientMatrix_map] at hred |
| have hreal := quotientMatrix_rank_real_lower g hg |
| omega |
|
|
| /-- Block direct sum with the line-label index first. -/ |
| def diagonalBlocks {I ι κ K : Type*} [DecidableEq I] [Zero K] |
| (Y : I → Matrix ι κ K) : Matrix (I × ι) (I × κ) K := |
| Matrix.of fun x y => if x.1 = y.1 then Y x.1 x.2 y.2 else 0 |
|
|
| /-- The lower rank bound for a direct sum, proved by its full-rank block minors. -/ |
| theorem sum_rank_le_rank_diagonalBlocks {I ι κ K : Type*} [Fintype I] |
| [Fintype ι] [Fintype κ] [DecidableEq I] [Field K] |
| (Y : I → Matrix ι κ K) : (∑ i, (Y i).rank) ≤ (diagonalBlocks Y).rank := by |
| classical |
| choose f g hf hg hdet using fun i => exists_full_rank_minor (Y i) |
| let B : ∀ i, Matrix (Fin (Y i).rank) (Fin (Y i).rank) K := |
| fun i => (Y i).submatrix (f i) (g i) |
| let rows : (Σ i, Fin (Y i).rank) → I × ι := fun x => (x.1, f x.1 x.2) |
| let cols : (Σ i, Fin (Y i).rank) → I × κ := fun x => (x.1, g x.1 x.2) |
| have hminor : (diagonalBlocks Y).submatrix rows cols = Matrix.blockDiagonal' B := by |
| ext ⟨i,a⟩ ⟨j,b⟩ |
| by_cases hij : i = j |
| · subst j |
| simp [diagonalBlocks, rows, cols, B] |
| · simp [diagonalBlocks, rows, cols, Matrix.blockDiagonal'_apply_ne _ _ _ hij, hij] |
| have hBunit : IsUnit B := Pi.isUnit_iff.mpr (fun i => |
| (Matrix.isUnit_iff_isUnit_det _).mpr (isUnit_iff_ne_zero.mpr (hdet i))) |
| have hunit : IsUnit (Matrix.blockDiagonal' B) := |
| hBunit.map (Matrix.blockDiagonal'RingHom (fun i => Fin (Y i).rank) K) |
| have hrank := Matrix.rank_of_isUnit (Matrix.blockDiagonal' B) hunit |
| calc |
| (∑ i, (Y i).rank) = Fintype.card (Σ i, Fin (Y i).rank) := by simp |
| _ = (Matrix.blockDiagonal' B).rank := hrank.symm |
| _ ≤ (diagonalBlocks Y).rank := by |
| rw [← hminor] |
| exact Matrix.rank_submatrix_le _ _ _ |
|
|
| theorem rank_neg {ι κ K : Type*} [Fintype ι] [Fintype κ] [Field K] |
| (A : Matrix ι κ K) : (-A).rank = A.rank := by |
| simpa using Matrix.rank_smul_of_mem_nonZeroDivisors A |
| (mem_nonZeroDivisors_of_ne_zero (show (-1 : K) ≠ 0 by simp)) |
|
|
| /-- The rank-one scalar matrix `f fᵀ` tensored with a matrix. -/ |
| def weightedMatrix {I ι κ K : Type*} [Mul K] (f : I → K) (Z : Matrix ι κ K) : |
| Matrix (I × ι) (I × κ) K := Matrix.of fun x y => f x.1 * f y.1 * Z x.2 y.2 |
|
|
| /-- A rank-one tensor weight never increases rank. -/ |
| theorem weightedMatrix_rank_le {I ι κ K : Type*} [Fintype I] [Fintype ι] |
| [Fintype κ] [Field K] (f : I → K) (Z : Matrix ι κ K) : |
| (weightedMatrix f Z).rank ≤ Z.rank := by |
| classical |
| let L : Matrix (I × ι) ι K := Matrix.of fun x a => if x.2 = a then f x.1 else 0 |
| let R : Matrix κ (I × κ) K := Matrix.of fun b y => if b = y.2 then f y.1 else 0 |
| have hfactor : weightedMatrix f Z = L * Z * R := by |
| ext ⟨i,a⟩ ⟨j,b⟩ |
| simp [weightedMatrix, L, R, Matrix.mul_apply, mul_ite, ite_mul] |
| ring |
| rw [hfactor] |
| exact (Matrix.rank_mul_le_left _ _).trans (Matrix.rank_mul_le_right _ _) |
|
|
| /-- Exchanging the incidence sums turns the punctured-line certificate into a |
| block-diagonal matrix identity. The coefficient order in each matrix is unchanged. -/ |
| theorem tensor_certificate {P I ι κ K : Type*} [Fintype P] [Fintype I] |
| [DecidableEq I] [Field K] (inc : P → Finset I) (f : P → I → K) |
| (Y : I → Matrix ι κ K) |
| (hline : ∀ i j k, (∑ z, if i ∈ inc z then f z j * f z k else 0) = |
| -(if j = i ∧ k = i then 1 else 0)) : |
| (∑ z, weightedMatrix (f z) (∑ i ∈ inc z, Y i)) = -diagonalBlocks Y := by |
| classical |
| ext ⟨j,a⟩ ⟨k,b⟩ |
| simp only [Matrix.sum_apply, weightedMatrix, Matrix.of_apply, Matrix.neg_apply, |
| diagonalBlocks] |
| simp only [Finset.mul_sum] |
| have hsum (z : P) : (∑ i ∈ inc z, f z j * f z k * Y i a b) = |
| ∑ i, (if i ∈ inc z then f z j * f z k else 0) * Y i a b := by |
| simp [ite_mul] |
| simp_rw [hsum] |
| rw [Finset.sum_comm] |
| simp_rw [← Finset.sum_mul, hline, neg_mul, ite_mul, one_mul, zero_mul] |
| by_cases hjk : j = k |
| · subst k |
| simp |
| · simp [hjk, show ∀ i, ¬(j = i ∧ k = i) by rintro i ⟨rfl,rfl⟩; exact hjk rfl] |
| |
| theorem rank_budget_of_line_certificate {P I ι κ K : Type*} [Fintype P] |
| [Fintype I] [Fintype ι] [Fintype κ] [DecidableEq I] [Field K] |
| (inc : P → Finset I) (f : P → I → K) (Y : I → Matrix ι κ K) |
| (hline : ∀ i j k, (∑ z, if i ∈ inc z then f z j * f z k else 0) = |
| -(if j = i ∧ k = i then 1 else 0)) : |
| (∑ i, (Y i).rank) ≤ ∑ z, (∑ i ∈ inc z, Y i).rank := by |
| calc |
| _ ≤ (diagonalBlocks Y).rank := sum_rank_le_rank_diagonalBlocks Y |
| _ = (-diagonalBlocks Y).rank := (rank_neg _).symm |
| _ = (∑ z, weightedMatrix (f z) (∑ i ∈ inc z, Y i)).rank := by |
| rw [tensor_certificate inc f Y hline] |
| _ ≤ ∑ z, (weightedMatrix (f z) (∑ i ∈ inc z, Y i)).rank := rank_sum_le _ _ |
| _ ≤ _ := Finset.sum_le_sum (fun z _ => weightedMatrix_rank_le _ _) |
|
|
| /-- A local Cartesian block factors through one copy of the finite regular module. -/ |
| theorem quotientMatrix_sum_rank_le {ι s t F K : Type*} [Fintype ι] |
| [Fintype s] [Fintype t] [Group F] [Fintype F] [DecidableEq F] [Field K] |
| (L : ι → s → F) (R : ι → t → F) : |
| (∑ j : s, ∑ k : t, quotientMatrix (R := K) (fun u v => (L u j)⁻¹ * R v k)).rank ≤ |
| Fintype.card F := by |
| classical |
| let A : Matrix (ι × F) F K := Matrix.of fun x a => |
| (∑ j, regularMatrix (R := K) (L x.1 j)⁻¹) x.2 a |
| let B : Matrix F (ι × F) K := Matrix.of fun b y => |
| (∑ k, regularMatrix (R := K) (R y.1 k)) b y.2 |
| have hfactor : |
| (∑ j : s, ∑ k : t, quotientMatrix (R := K) (fun u v => (L u j)⁻¹ * R v k)) = |
| A * B := by |
| ext ⟨u,a⟩ ⟨v,b⟩ |
| simp only [Matrix.sum_apply, quotientMatrix, flattenMatrix_apply, Matrix.of_apply, |
| map_mul, Matrix.mul_apply, A, B] |
| simp only [Finset.sum_mul, Finset.mul_sum] |
| simp_rw [Finset.sum_comm (s := (Finset.univ : Finset t)) |
| (t := (Finset.univ : Finset F))] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro j _ |
| exact Finset.sum_comm |
| rw [hfactor] |
| exact (Matrix.rank_mul_le_left _ _).trans (Matrix.rank_le_card_width _) |
|
|
| /-- An arbitrary relabeling of a Cartesian block does not affect its summed |
| regular-representation matrix. Opposite-index shifts are permitted independently. -/ |
| theorem quotientMatrix_sum_reindex {ι B s t F K : Type*} [Fintype B] |
| [Fintype s] [Fintype t] [Group F] [Fintype F] [DecidableEq F] [Semiring K] |
| (g : B → ι → ι → F) (L : ι → s → F) (R : ι → t → F) |
| (e : ι → ι → B ≃ s × t) |
| (h : ∀ i u v, g i u v = (L u (e u v i).1)⁻¹ * R v (e u v i).2) : |
| (∑ i, quotientMatrix (R := K) (g i)) = |
| ∑ j : s, ∑ k : t, quotientMatrix (R := K) (fun u v => (L u j)⁻¹ * R v k) := by |
| ext ⟨u,a⟩ ⟨v,b⟩ |
| simp only [Matrix.sum_apply, quotientMatrix, flattenMatrix_apply, Matrix.of_apply, h] |
| exact (Equiv.sum_comp (e u v) (fun p : s × t => |
| (regularMatrix (R := K) ((L u p.1)⁻¹ * R v p.2)) a b)).trans |
| (Fintype.sum_prod_type _) |
|
|
| /-- A polynomial below the finite-field power-sum threshold has zero total sum. -/ |
| theorem polynomial_sum_eq_zero {K : Type*} [Field K] [Fintype K] |
| (p : Polynomial K) (hdeg : p.natDegree < Fintype.card K - 1) : |
| ∑ x, p.eval x = 0 := by |
| simp only [Polynomial.eval_eq_sum_range] |
| rw [Finset.sum_comm] |
| apply Finset.sum_eq_zero |
| intro i hi |
| rw [← Finset.mul_sum, FiniteField.sum_pow_lt_card_sub_one K i |
| (lt_of_le_of_lt (Nat.le_of_lt_succ (Finset.mem_range.mp hi)) hdeg), mul_zero] |
|
|
| def gridLagrange {T K : Type*} [Fintype T] [Field K] [DecidableEq K] |
| (S : Finset K) (a x : T → K) : K := |
| ∏ t, ∏ w ∈ S.erase (a t), (x t - w) / (a t - w) |
|
|
| @[simp] theorem gridLagrange_self {T K : Type*} [Fintype T] [Field K] |
| [DecidableEq K] (S : Finset K) (a : T → K) : gridLagrange S a a = 1 := by |
| apply Finset.prod_eq_one |
| intro t _ |
| apply Finset.prod_eq_one |
| intro w hw |
| exact div_self (sub_ne_zero.mpr (Finset.mem_erase.mp hw).1.symm) |
|
|
| theorem gridLagrange_other {T K : Type*} [Fintype T] [Field K] |
| [DecidableEq K] (S : Finset K) (a x : T → K) (hx : ∀ t, x t ∈ S) |
| (hax : a ≠ x) : gridLagrange S a x = 0 := by |
| classical |
| obtain ⟨t, ht⟩ := Function.ne_iff.mp hax |
| apply Finset.prod_eq_zero (Finset.mem_univ t) |
| apply Finset.prod_eq_zero (Finset.mem_erase.mpr ⟨ht.symm, hx t⟩) |
| simp |
|
|
| /-- Restriction of the grid Lagrange basis along the parametrized affine line. -/ |
| noncomputable def gridLagrangeLine {T K : Type*} [Fintype T] [Field K] [DecidableEq K] |
| (S : Finset K) (a b v : T → K) : Polynomial K := |
| ∏ t, ∏ w ∈ S.erase (a t), |
| (Polynomial.C (b t - w) + Polynomial.X * Polynomial.C (v t)) * |
| Polynomial.C ((a t - w)⁻¹) |
|
|
| @[simp] theorem gridLagrangeLine_eval {T K : Type*} [Fintype T] [Field K] |
| [DecidableEq K] (S : Finset K) (a b v : T → K) (x : K) : |
| (gridLagrangeLine S a b v).eval x = gridLagrange S a (fun t => b t + x * v t) := by |
| simp only [gridLagrangeLine, gridLagrange, Polynomial.eval_prod, |
| Polynomial.eval_mul, Polynomial.eval_add, Polynomial.eval_C, Polynomial.eval_X, |
| div_eq_mul_inv] |
| apply Finset.prod_congr rfl |
| intro t _ |
| apply Finset.prod_congr rfl |
| intro w _ |
| ring |
|
|
| theorem gridLagrangeLine_natDegree_le {T K : Type*} [Fintype T] [Field K] |
| [DecidableEq K] (S : Finset K) (a b v : T → K) (ha : ∀ t, a t ∈ S) : |
| (gridLagrangeLine S a b v).natDegree ≤ Fintype.card T * (S.card - 1) := by |
| apply (Polynomial.natDegree_prod_le _ _).trans |
| calc |
| _ ≤ ∑ t : T, (S.card - 1) := by |
| apply Finset.sum_le_sum |
| intro t _ |
| apply (Polynomial.natDegree_prod_le _ _).trans |
| calc |
| _ ≤ ∑ _w ∈ S.erase (a t), 1 := by |
| apply Finset.sum_le_sum |
| intro w _ |
| apply Polynomial.natDegree_mul_le.trans |
| simp only [Polynomial.natDegree_C, add_zero] |
| apply (Polynomial.natDegree_add_le _ _).trans |
| apply max_le |
| · simp |
| · exact Polynomial.natDegree_mul_le.trans (by simp) |
| _ = S.card - 1 := by simp [Finset.card_erase_of_mem (ha t)] |
| _ = _ := by simp |
|
|
| /-- Every entry of the rank-one weight matrix has zero sum over a full line. -/ |
| theorem polygon_weight_line_sum {T K : Type*} [Fintype T] [Field K] [Fintype K] |
| [DecidableEq K] (S : Finset K) (a a' b v : T → K) |
| (ha : ∀ t, a t ∈ S) (ha' : ∀ t, a' t ∈ S) |
| (hdeg : 2 * (Fintype.card T * (S.card - 1)) < Fintype.card K - 1) : |
| (∑ x : K, gridLagrange S a (fun t => b t + x * v t) * |
| gridLagrange S a' (fun t => b t + x * v t)) = 0 := by |
| have h := polynomial_sum_eq_zero (gridLagrangeLine S a b v * gridLagrangeLine S a' b v) |
| (lt_of_le_of_lt (Polynomial.natDegree_mul_le.trans (Nat.add_le_add |
| (gridLagrangeLine_natDegree_le S a b v ha) |
| (gridLagrangeLine_natDegree_le S a' b v ha'))) (by omega)) |
| simpa only [Polynomial.eval_mul, gridLagrangeLine_eval] using h |
|
|
| /-- Finite separating families can be combined into one finite target. -/ |
| theorem exists_finite_separating_family {G : Type u} {ι : Type v} [Group G] [Fintype ι] |
| [Group.ResiduallyFinite G] (w : ι → G) (hw : ∀ i, w i ≠ 1) : |
| ∃ (Q : Type (max u v)) (_ : Group Q) (_ : Fintype Q) (φ : G →* Q), ∀ i, φ (w i) ≠ 1 := by |
| classical |
| choose H hH using fun i => Group.exists_finiteIndexNormalSubgroup_notMem (w i) (hw i) |
| let Q := ∀ i, G ⧸ (H i).toSubgroup |
| let : ∀ i, Fintype (G ⧸ (H i).toSubgroup) := fun i => Fintype.ofFinite _ |
| let φ : G →* Q := MonoidHom.pi (fun i => QuotientGroup.mk' (H i).toSubgroup) |
| refine ⟨Q, inferInstance, inferInstance, φ, ?_⟩ |
| intro i hi |
| have h := congrFun hi i |
| exact hH i ((QuotientGroup.eq_one_iff (w i)).mp h) |
|
|
| /-- Standard affine parametrization, with the marked point at parameter zero. -/ |
| def affineLineMap {T K : Type*} [Field K] (a v : T → K) (x : K) : T → K := |
| fun t => a t + x * v t |
|
|
| theorem affineLineMap_injective {T K : Type*} [Field K] (a v : T → K) |
| (hv : v ≠ 0) : Function.Injective (affineLineMap a v) := by |
| classical |
| obtain ⟨t, ht⟩ := Function.ne_iff.mp hv |
| intro x y hxy |
| have h := congrFun hxy t |
| exact mul_right_cancel₀ ht (add_left_cancel h) |
|
|
| /-- The geometric affine line punctured only at its own marked point. -/ |
| noncomputable def puncturedLine {T K : Type*} [Fintype T] [Field K] [Fintype K] |
| (a v : T → K) : Finset (T → K) := by |
| classical |
| exact (Finset.univ.erase 0).image (affineLineMap a v) |
|
|
| /-- Summation on a punctured line subtracts exactly the value at its own mark. -/ |
| theorem puncturedLine_sum {T K R : Type*} [Fintype T] [Field K] [Fintype K] |
| [AddCommGroup R] (a v : T → K) (hv : v ≠ 0) (w : (T → K) → R) : |
| (∑ z ∈ puncturedLine a v, w z) = (∑ x, w (affineLineMap a v x)) - w a := by |
| classical |
| have hzero : affineLineMap a v 0 = a := by ext t; simp [affineLineMap] |
| rw [puncturedLine, Finset.sum_image (affineLineMap_injective a v hv).injOn, |
| Finset.sum_erase_eq_sub (Finset.mem_univ 0), hzero] |
| |
| noncomputable def lineIncidence {T I K : Type*} [Fintype T] [Fintype I] |
| [Field K] [Fintype K] (a v : I → T → K) (z : T → K) : Finset I := by |
| classical |
| exact Finset.univ.filter (fun i => z ∈ puncturedLine (a i) (v i)) |
|
|
| /-- The exact finite-field punctured-line matrix certificate, with no asymptotic |
| or characteristic assumption beyond its explicit degree threshold. -/ |
| theorem grid_line_certificate {T I K : Type*} [Fintype T] [Fintype I] |
| [DecidableEq T] [DecidableEq I] [Field K] [Fintype K] [DecidableEq K] |
| (S : Finset K) (a v : I → T → K) (ha : ∀ i t, a i t ∈ S) |
| (hinj : Function.Injective a) (hv : ∀ i, v i ≠ 0) |
| (hdeg : 2 * (Fintype.card T * (S.card - 1)) < Fintype.card K - 1) : |
| ∀ i j k, (∑ z, if i ∈ lineIncidence a v z then |
| gridLagrange S (a j) z * gridLagrange S (a k) z else 0) = |
| -(if j = i ∧ k = i then 1 else 0) := by |
| classical |
| intro i j k |
| have heval (j : I) : gridLagrange S (a j) (a i) = if j = i then 1 else 0 := by |
| by_cases hji : j = i |
| · subst j; simp |
| · rw [ite_eq_right hji] |
| exact gridLagrange_other S (a j) (a i) (ha i) (fun h => hji (hinj h)) |
| have hs : (∑ z, if i ∈ lineIncidence a v z then |
| gridLagrange S (a j) z * gridLagrange S (a k) z else 0) = |
| ∑ z ∈ puncturedLine (a i) (v i), gridLagrange S (a j) z * gridLagrange S (a k) z := by |
| simp [lineIncidence] |
| rw [hs, puncturedLine_sum (a i) (v i) (hv i)] |
| rw [show (∑ x, gridLagrange S (a j) (affineLineMap (a i) (v i) x) * |
| gridLagrange S (a k) (affineLineMap (a i) (v i) x)) = 0 from |
| polygon_weight_line_sum S (a j) (a k) (a i) (v i) (ha j) (ha k) hdeg] |
| by_cases hj : j = i <;> by_cases hk : k = i <;> simp_all |
| |
| theorem two_block_sizes (r d : ℕ) (hr : 0 < r) (hd : 4 * r ^ 2 ≤ d) : |
| ∃ n₁ n₂ : ℕ, r ≤ n₁ ∧ r ≤ n₂ ∧ n₂ < 2 * r ∧ |
| d = r * n₁ + (r + 1) * n₂ := by |
| have hmod : d % r < r := Nat.mod_lt d hr |
| have hquot : 4 * r ≤ d / r := (Nat.le_div_iff_mul_le hr).mpr (by nlinarith) |
| have hsub : r + 1 + d % r ≤ d / r := by omega |
| refine ⟨d / r - (r + 1 + d % r), r + d % r, by omega, by omega, by omega, ?_⟩ |
| have hdecomp := Nat.div_add_mod d r |
| have hdiff := Nat.sub_add_cancel hsub |
| nlinarith |
|
|
| structure CartesianBlock (I : Type*) (r : ℕ) where |
| s : ℕ |
| t : ℕ |
| hs : r ≤ s |
| ht : r ≤ t |
| spos : 0 < s |
| tpos : 0 < t |
| labels : Finset I |
| coordinates : labels ≃ ZMod s × ZMod t |
|
|
| instance {I : Type*} {r : ℕ} (b : CartesianBlock I r) : NeZero b.s := ⟨b.spos.ne'⟩ |
| instance {I : Type*} {r : ℕ} (b : CartesianBlock I r) : NeZero b.t := ⟨b.tpos.ne'⟩ |
|
|
| /-- Opposite-index shifts are bijections of the block coordinates. -/ |
| def CartesianBlock.shifted {I : Type*} {r : ℕ} (b : CartesianBlock I r) |
| (u v : Fin r) : b.labels ≃ ZMod b.s × ZMod b.t := |
| b.coordinates.trans (Equiv.prodCongr (Equiv.addRight (v.val : ZMod b.s)) |
| (Equiv.addRight (u.val : ZMod b.t))) |
|
|
| theorem CartesianBlock.quotient_rank_le {I F K : Type*} {r : ℕ} |
| [Group F] [Fintype F] [DecidableEq F] [Field K] |
| (b : CartesianBlock I r) (g : I → Fin r → Fin r → F) |
| (L : Fin r → ZMod b.s → F) (R : Fin r → ZMod b.t → F) |
| (hrel : ∀ (i : b.labels) u v, |
| g i u v = (L u ((b.coordinates i).1 + (v.val : ZMod b.s)))⁻¹ * |
| R v ((b.coordinates i).2 + (u.val : ZMod b.t))) : |
| (∑ i ∈ b.labels, quotientMatrix (R := K) (g i)).rank ≤ Fintype.card F := by |
| classical |
| rw [Finset.sum_subtype b.labels (fun _ => Iff.rfl)] |
| rw [quotientMatrix_sum_reindex (fun i : b.labels => g i) L R b.shifted hrel] |
| exact quotientMatrix_sum_rank_le L R |
|
|
| /-- Every sufficiently large finite set has the two Cartesian blocks required by |
| the construction; the coordinate bijections are chosen without deleting labels. -/ |
| theorem exists_two_cartesian_blocks {I : Type*} [DecidableEq I] (r : ℕ) (hr : 0 < r) |
| (A : Finset I) (hA : 4 * r ^ 2 ≤ A.card) : |
| ∃ b₀ b₁ : CartesianBlock I r, |
| Disjoint b₀.labels b₁.labels ∧ b₀.labels ∪ b₁.labels = A := by |
| classical |
| obtain ⟨n₁,n₂,hn₁,hn₂,_,heq⟩ := two_block_sizes r A.card hr hA |
| obtain ⟨A₀,hA₀,hcard⟩ := Finset.exists_subset_card_eq (show r * n₁ ≤ A.card by omega) |
| let A₁ := A \ A₀ |
| have hcard₁ : A₁.card = (r + 1) * n₂ := by rw [Finset.card_sdiff_of_subset hA₀, hcard, heq]; omega |
| let : NeZero r := ⟨hr.ne'⟩ |
| let : NeZero n₁ := ⟨(hr.trans_le hn₁).ne'⟩ |
| let : NeZero n₂ := ⟨(hr.trans_le hn₂).ne'⟩ |
| let b₀ : CartesianBlock I r := |
| {s := r, t := n₁, hs := le_rfl, ht := hn₁, spos := hr, tpos := hr.trans_le hn₁, |
| labels := A₀, coordinates := Fintype.equivOfCardEq (by simpa using hcard)} |
| let b₁ : CartesianBlock I r := |
| {s := r+1, t := n₂, hs := Nat.le_succ r, ht := hn₂, spos := Nat.succ_pos r, |
| tpos := hr.trans_le hn₂, |
| labels := A₁, coordinates := Fintype.equivOfCardEq (by simpa using hcard₁)} |
| refine ⟨b₀,b₁,?_,?_⟩ |
| · exact Finset.disjoint_sdiff |
| · exact Finset.union_sdiff_of_subset hA₀ |
|
|
| /-- The numerical rank contradiction. The exceptional incidences are retained; |
| the ambient dimension, not a deletion, bounds their matrices. -/ |
| theorem finite_quotient_rank_obstruction {P I F : Type*} [Fintype P] [Fintype I] |
| [DecidableEq I] [Group F] [Fintype F] [DecidableEq F] |
| (r q : ℕ) [Fact q.Prime] (hq : r < q) |
| (inc : P → Finset I) (f : P → I → ZMod q) (E : Finset P) |
| (g : I → Fin r → Fin r → F) (hg : ∀ i, RectanglesSurvive (g i)) |
| (hline : ∀ i j k, (∑ z, if i ∈ inc z then f z j * f z k else 0) = |
| -(if j = i ∧ k = i then 1 else 0)) |
| (hlocal : ∀ z, z ∉ E → (∑ i ∈ inc z, quotientMatrix (R := ZMod q) (g i)).rank ≤ |
| 2 * Fintype.card F) |
| (hbudget : 4 * (2 * Fintype.card P + r * E.card) < Fintype.card I * r) : False := by |
| classical |
| let D := Fintype.card F |
| let Y := fun i => quotientMatrix (R := ZMod q) (g i) |
| let Z := fun z => ∑ i ∈ inc z, Y i |
| have lower : Fintype.card I * r * D ≤ 4 * ∑ i, (Y i).rank := by |
| have h := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset I)) => |
| quotientMatrix_rank_mod_lower (g i) (hg i) q (by simpa using hq)) |
| simpa [Y, D, ← Finset.mul_sum, mul_assoc] using h |
| have middle : (∑ i, (Y i).rank) ≤ ∑ z, (Z z).rank := |
| rank_budget_of_line_certificate inc f Y hline |
| have upper : (∑ z, (Z z).rank) ≤ (2 * Fintype.card P + r * E.card) * D := by |
| have hbound (z : P) : (Z z).rank ≤ 2 * D + if z ∈ E then r * D else 0 := by |
| by_cases hz : z ∈ E |
| · rw [ite_eq_left hz] |
| have hrank : (Z z).rank ≤ r * D := by |
| simpa [D] using Matrix.rank_le_card_height (Z z) |
| omega |
| · rw [ite_eq_right hz, add_zero] |
| exact hlocal z hz |
| calc |
| _ ≤ ∑ z, (2 * D + if z ∈ E then r * D else 0) := Finset.sum_le_sum (fun z _ => hbound z) |
| _ = _ := by simp [Finset.sum_add_distrib, add_mul]; ring |
| have hc : Fintype.card I * r * D ≤ (4 * (2 * Fintype.card P + r * E.card)) * D := by |
| calc |
| _ ≤ 4 * ∑ i, (Y i).rank := lower |
| _ ≤ 4 * ∑ z, (Z z).rank := Nat.mul_le_mul_left _ middle |
| _ ≤ 4 * ((2 * Fintype.card P + r * E.card) * D) := Nat.mul_le_mul_left _ upper |
| _ = _ := by ring |
| exact (Nat.not_le_of_gt (Nat.mul_lt_mul_of_pos_right hbudget |
| (Fintype.card_pos : 0 < D))) hc |
|
|
| /-- The exact defining relation of a single block, retaining the order `L⁻¹R`. -/ |
| def CartesianBlock.Relations {I G : Type*} [Group G] {r : ℕ} |
| (b : CartesianBlock I r) (g : I → Fin r → Fin r → G) : Prop := |
| ∃ (L : Fin r → ZMod b.s → G) (R : Fin r → ZMod b.t → G), |
| ∀ (i : b.labels) u v, g i u v = |
| (L u ((b.coordinates i).1 + (v.val : ZMod b.s)))⁻¹ * |
| R v ((b.coordinates i).2 + (u.val : ZMod b.t)) |
|
|
| theorem CartesianBlock.Relations.map {I G F : Type*} [Group G] [Group F] {r : ℕ} |
| {b : CartesianBlock I r} {g : I → Fin r → Fin r → G} |
| (h : b.Relations g) (φ : G →* F) : b.Relations (fun i u v => φ (g i u v)) := by |
| obtain ⟨L,R,hrel⟩ := h |
| refine ⟨fun u j => φ (L u j), fun v k => φ (R v k), ?_⟩ |
| intros |
| simp [hrel] |
|
|
| theorem two_block_quotient_rank_le {I F K : Type*} [DecidableEq I] |
| [Group F] [Fintype F] [DecidableEq F] [Field K] {r : ℕ} |
| (A : Finset I) (g : I → Fin r → Fin r → F) |
| (b₀ b₁ : CartesianBlock I r) |
| (hdis : Disjoint b₀.labels b₁.labels) (hunion : b₀.labels ∪ b₁.labels = A) |
| (h₀ : b₀.Relations g) (h₁ : b₁.Relations g) : |
| (∑ i ∈ A, quotientMatrix (R := K) (g i)).rank ≤ 2 * Fintype.card F := by |
| obtain ⟨L₀,R₀,h₀⟩ := h₀ |
| obtain ⟨L₁,R₁,h₁⟩ := h₁ |
| rw [← hunion, Finset.sum_union hdis] |
| have h := (rank_add_le _ _).trans (Nat.add_le_add |
| (b₀.quotient_rank_le (K := K) g L₀ R₀ h₀) |
| (b₁.quotient_rank_le (K := K) g L₁ R₁ h₁)) |
| simpa [two_mul] using h |
|
|
| /-- All specified nontrivial rectangular words can be preserved in one finite |
| image if the group is residually finite. -/ |
| theorem exists_finite_preserving_rectangles {I : Type u} {G : Type v} [Fintype I] [Group G] |
| [Group.ResiduallyFinite G] {r : ℕ} (g : I → Fin r → Fin r → G) |
| (hg : ∀ i, RectanglesSurvive (g i)) : |
| ∃ (Q : Type (max u v)) (_ : Group Q) (_ : Fintype Q) (φ : G →* Q), |
| ∀ i, RectanglesSurvive (fun u v => φ (g i u v)) := by |
| classical |
| let J := {x : I × Fin r × Fin r × Fin r × Fin r // x.2.1 ≠ x.2.2.1 ∧ x.2.2.2.1 ≠ x.2.2.2.2} |
| let w : J → G := fun x => g x.val.1 x.val.2.1 x.val.2.2.2.1 * |
| (g x.val.1 x.val.2.2.1 x.val.2.2.2.1)⁻¹ * |
| g x.val.1 x.val.2.2.1 x.val.2.2.2.2 * (g x.val.1 x.val.2.1 x.val.2.2.2.2)⁻¹ |
| have hw (x : J) : w x ≠ 1 := hg _ _ _ _ _ x.property.1 x.property.2 |
| obtain ⟨Q,hQ,hfin,φ,hφ⟩ := exists_finite_separating_family w hw |
| refine ⟨Q,hQ,hfin,φ,?_⟩ |
| intro i u u' v v' hu hv |
| have h := hφ ⟨(i,u,u',v,v'),hu,hv⟩ |
| simpa [w] using h |
|
|
| theorem not_residuallyFinite_of_line_blocks {T I G : Type*} |
| [Fintype T] [Fintype I] [DecidableEq T] [DecidableEq I] [Group G] |
| (r q : ℕ) [Fact q.Prime] (hq : r < q) |
| (S : Finset (ZMod q)) (a v : I → T → ZMod q) |
| (ha : ∀ i t, a i t ∈ S) (hinj : Function.Injective a) (hv : ∀ i, v i ≠ 0) |
| (hdeg : 2 * (Fintype.card T * (S.card - 1)) < q - 1) |
| (E : Finset (T → ZMod q)) (g : I → Fin r → Fin r → G) |
| (hg : ∀ i, RectanglesSurvive (g i)) |
| (hblocks : ∀ z, z ∉ E → ∃ b₀ b₁ : CartesianBlock I r, |
| Disjoint b₀.labels b₁.labels ∧ b₀.labels ∪ b₁.labels = lineIncidence a v z ∧ |
| b₀.Relations g ∧ b₁.Relations g) |
| (hbudget : 4 * (2 * Fintype.card (T → ZMod q) + r * E.card) < Fintype.card I * r) : |
| ¬ Group.ResiduallyFinite G := by |
| classical |
| intro hRF |
| let := hRF |
| obtain ⟨Q,hQ,hfin,φ,hφ⟩ := exists_finite_preserving_rectangles g hg |
| let := hQ |
| let := hfin |
| apply finite_quotient_rank_obstruction r q hq (lineIncidence a v) |
| (fun z i => gridLagrange S (a i) z) E (fun i u v => φ (g i u v)) hφ |
| (grid_line_certificate S a v ha hinj hv (by simpa using hdeg)) _ hbudget |
| intro z hz |
| obtain ⟨b₀,b₁,hd,hu,h₀,h₁⟩ := hblocks z hz |
| exact two_block_quotient_rank_le _ _ b₀ b₁ hd hu (h₀.map φ) (h₁.map φ) |
|
|
| end Release075 |
|
|
| end OAI |
|
|
