| import OAI.Geometry.PeriodicTiling.TileDilation |
| import OAI.Geometry.PeriodicTiling.PlaneLattices |
| import Mathlib.Algebra.BigOperators.Field |
| import Mathlib.Algebra.Ring.Periodic |
| import Mathlib.Analysis.SpecificLimits.Basic |
| import Mathlib.Data.Fintype.EquivFin |
| import Mathlib.Topology.Bases |
| import Mathlib.Topology.Compactness.Compact |
| import Mathlib.Topology.Order.Compact |
| import Mathlib.Topology.Sequences |
| import Mathlib.Tactic.Abel |
| import Mathlib.Tactic.FieldSimp |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.Positivity |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| universe uι |
|
|
| noncomputable section |
|
|
| namespace PeriodicTilingThree |
|
|
| open Set Filter |
| open scoped BigOperators Topology |
|
|
| def directionalAverage (a : Plane → ℝ) (q : ℕ) (v : Plane) (N : ℕ) (x : Plane) : ℝ := |
| (∑ k ∈ Finset.range (N + 1), a (x - (1 + q * (k + 1)) • v)) / (N + 1 : ℕ) |
|
|
| theorem directionalAverage_nonneg {a : Plane → ℝ} (ha : ∀ x, 0 ≤ a x) |
| (q : ℕ) (v : Plane) (N : ℕ) (x : Plane) : |
| 0 ≤ directionalAverage a q v N x := by |
| unfold directionalAverage |
| exact div_nonneg (Finset.sum_nonneg fun k _ => ha _) (by positivity) |
|
|
| theorem directionalAverage_le_one {a : Plane → ℝ} (ha : ∀ x, a x ≤ 1) |
| (q : ℕ) (v : Plane) (N : ℕ) (x : Plane) : |
| directionalAverage a q v N x ≤ 1 := by |
| have hN : (0 : ℝ) < (N + 1 : ℕ) := by positivity |
| apply (div_le_iff₀ hN).2 |
| calc |
| _ ≤ ∑ _k ∈ Finset.range (N + 1), (1 : ℝ) := |
| Finset.sum_le_sum fun k _ => ha _ |
| _ = _ := by simp |
|
|
| theorem directionalAverage_translate_sub (a : Plane → ℝ) (q : ℕ) |
| (v : Plane) (N : ℕ) (x : Plane) : |
| directionalAverage a q v N (x + q • v) - directionalAverage a q v N x = |
| (a (x - v) - a (x - (1 + q * (N + 1)) • v)) / (N + 1 : ℕ) := by |
| have hshift (k : ℕ) : |
| x + q • v - (1 + q * (k + 1)) • v = x - (1 + q * k) • v := by |
| have hk : 1 + q * (k + 1) = (1 + q * k) + q := by ring |
| rw [hk, add_nsmul] |
| abel |
| unfold directionalAverage |
| simp_rw [hshift] |
| rw [← sub_div, ← Finset.sum_sub_distrib] |
| congr 1 |
| simpa only [Nat.mul_zero, Nat.add_zero, one_nsmul] using |
| Finset.sum_range_sub' (fun k => a (x - (1 + q * k) • v)) (N + 1) |
|
|
| theorem directionalAverage_translate_error {a : Plane → ℝ} |
| (ha0 : ∀ x, 0 ≤ a x) (ha1 : ∀ x, a x ≤ 1) |
| (q : ℕ) (v : Plane) (N : ℕ) (x : Plane) : |
| |directionalAverage a q v N (x + q • v) - directionalAverage a q v N x| ≤ |
| 1 / (N + 1 : ℕ) := by |
| rw [directionalAverage_translate_sub, abs_div, |
| abs_of_pos (show (0 : ℝ) < (N + 1 : ℕ) by positivity)] |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| apply abs_le.mpr |
| constructor <;> linarith [ha0 (x - v), ha1 (x - v), |
| ha0 (x - (1 + q * (N + 1)) • v), ha1 (x - (1 + q * (N + 1)) • v)] |
|
|
| theorem sum_directionalAverage {F : Finset Plane} (h0 : (0 : Plane) ∈ F) |
| {a : Plane → ℝ} {q : ℕ} |
| (hD : ∀ (k : ℕ) (x : Plane), ∑ f ∈ F, a (x - (1 + q * k) • f) = 1) |
| (N : ℕ) (x : Plane) : |
| (∑ f ∈ F.erase 0, directionalAverage a q f N x) = 1 - a x := by |
| classical |
| have hs (k : ℕ) : |
| (∑ f ∈ F.erase 0, a (x - (1 + q * (k + 1)) • f)) = 1 - a x := by |
| have he := Finset.sum_erase_add F |
| (fun f => a (x - (1 + q * (k + 1)) • f)) h0 |
| rw [hD (k + 1) x] at he |
| simpa only [smul_zero, sub_zero] using (eq_sub_iff_add_eq.mpr he) |
| unfold directionalAverage |
| rw [← Finset.sum_div, Finset.sum_comm] |
| simp_rw [hs] |
| simp only [Finset.sum_const, Finset.card_range, nsmul_eq_mul] |
| exact mul_div_cancel_left₀ (1 - a x) (by positivity) |
|
|
| theorem exists_common_directional_subsequence {ι : Type uι} [Countable ι] |
| (u : ℕ → ι → Plane → ℝ) |
| (hu0 : ∀ N i x, 0 ≤ u N i x) (hu1 : ∀ N i x, u N i x ≤ 1) : |
| ∃ (φ : ι → Plane → ℝ) (σ : ℕ → ℕ), StrictMono σ ∧ |
| (∀ i x, 0 ≤ φ i x ∧ φ i x ≤ 1) ∧ |
| ∀ i x, Tendsto (fun N => u (σ N) i x) atTop (𝓝 (φ i x)) := by |
| let u' : ℕ → ((ι × Plane) → Set.Icc (0 : ℝ) 1) := |
| fun N ix => ⟨u N ix.1 ix.2, hu0 N ix.1 ix.2, hu1 N ix.1 ix.2⟩ |
| obtain ⟨l, σ, hσ, hl⟩ := CompactSpace.tendsto_subseq u' |
| refine ⟨fun i x => (l (i, x) : ℝ), σ, hσ, ?_, ?_⟩ |
| · intro i x |
| exact (l (i, x)).property |
| · intro i x |
| exact ((continuous_subtype_val.comp (continuous_apply (i, x))).tendsto l).comp hl |
|
|
| theorem exists_ungrouped_directional_limits {F : Finset Plane} (h0 : (0 : Plane) ∈ F) |
| {a : Plane → ℝ} (ha0 : ∀ x, 0 ≤ a x) (ha1 : ∀ x, a x ≤ 1) |
| {q : ℕ} |
| (hD : ∀ (k : ℕ) (x : Plane), ∑ f ∈ F, a (x - (1 + q * k) • f) = 1) : |
| ∃ φ : ↥(F.erase 0) → Plane → ℝ, |
| (∀ f x, 0 ≤ φ f x ∧ φ f x ≤ 1) ∧ |
| (∀ x, a x + ∑ f, φ f x = 1) ∧ |
| ∀ f, Function.Periodic (φ f) (q • (f : Plane)) := by |
| classical |
| obtain ⟨φ, σ, hσ, hφ, hlim⟩ := exists_common_directional_subsequence |
| (fun N (f : ↥(F.erase 0)) x => directionalAverage a q f N x) |
| (fun N f x => directionalAverage_nonneg ha0 q f N x) |
| (fun N f x => directionalAverage_le_one ha1 q f N x) |
| refine ⟨φ, hφ, ?_, ?_⟩ |
| · intro x |
| have hsum := tendsto_finsetSum Finset.univ (fun (f : ↥(F.erase 0)) _ => hlim f x) |
| have havg (N : ℕ) : |
| (∑ f : ↥(F.erase 0), directionalAverage a q f (σ N) x) = 1 - a x := by |
| exact (Finset.sum_coe_sort (F.erase 0) |
| (fun f : Plane => directionalAverage a q f (σ N) x)).trans |
| (sum_directionalAverage h0 hD (σ N) x) |
| have heq : (∑ f, φ f x) = 1 - a x := |
| tendsto_nhds_unique hsum (by simpa only [havg] using |
| (tendsto_const_nhds : Tendsto (fun _ : ℕ => 1 - a x) atTop (𝓝 (1 - a x)))) |
| linarith |
| · intro f x |
| have herr := (hlim f (x + q • (f : Plane))).sub (hlim f x) |
| have hbound : Tendsto (fun N : ℕ => (1 : ℝ) / (σ N + 1 : ℕ)) atTop (𝓝 0) := |
| (tendsto_one_div_atTop_nhds_zero_nat.comp (tendsto_add_atTop_nat 1)).comp |
| hσ.tendsto_atTop |
| have hz := squeeze_zero (fun N => abs_nonneg |
| (directionalAverage a q f (σ N) (x + q • (f : Plane)) - |
| directionalAverage a q f (σ N) x)) |
| (fun N => directionalAverage_translate_error ha0 ha1 q f (σ N) x) hbound |
| have heq : |φ f (x + q • (f : Plane)) - φ f x| = 0 := |
| tendsto_nhds_unique herr.abs hz |
| exact sub_eq_zero.mp (abs_eq_zero.mp heq) |
|
|
| theorem Tiles.exists_ungrouped_directional_limits {F : Finset Plane} {A : Set Plane} |
| (h : Tiles F A) (h0 : (0 : Plane) ∈ F) : |
| ∃ φ : ↥(F.erase 0) → Plane → ℝ, |
| (∀ f x, 0 ≤ φ f x ∧ φ f x ≤ 1) ∧ |
| (∀ x, tileIndicator ℝ A x + ∑ f, φ f x = 1) ∧ |
| ∀ f, Function.Periodic (φ f) (F.card.factorial • (f : Plane)) := by |
| exact PeriodicTilingThree.exists_ungrouped_directional_limits h0 |
| (fun x => tileIndicator_nonneg A x) (fun x => tileIndicator_le_one A x) |
| (fun k x => h.sum_tileIndicator_dilate_factorial k x) |
|
|
| theorem exists_grouped_directional_functions {ι : Type uι} [Fintype ι] |
| (v : ι → Plane) (hv : ∀ i, v i ≠ 0) (φ : ι → Plane → ℝ) |
| (hφ : ∀ i x, 0 ≤ φ i x) (hp : ∀ i, Function.Periodic (φ i) (v i)) |
| {a : Plane → ℝ} (ha : ∀ x, 0 ≤ a x) |
| (hsum : ∀ x, a x + ∑ i, φ i x = 1) : |
| ∃ (m : ℕ) (w : Fin m → Plane) (ψ : Fin m → Plane → ℝ), |
| (∀ j, w j ≠ 0) ∧ |
| (∀ i j, i ≠ j → planeDet (w i) (w j) ≠ 0) ∧ |
| (∀ j x, 0 ≤ ψ j x ∧ ψ j x ≤ 1) ∧ |
| (∀ x, a x + ∑ j, ψ j x = 1) ∧ |
| ∀ j, Function.Periodic (ψ j) (w j) := by |
| classical |
| let r : Setoid ι := |
| { r := fun i j => planeDet (v i) (v j) = 0 |
| iseqv := ⟨fun i => planeDet_self (v i), |
| fun {i j} hij => by rw [planeDet_swap, hij, neg_zero], |
| fun {i j k} hij hjk => planeDet_zero_trans (hv j) hij hjk⟩ } |
| let Q := Quotient r |
| let : Fintype Q := Fintype.ofFinite Q |
| let cls : ι → Q := Quotient.mk r |
| let fiber (j : Q) : Finset ι := Finset.univ.filter (fun i => cls i = j) |
| have mem_fiber (i : ι) (j : Q) : i ∈ fiber j ↔ cls i = j := by |
| simp [fiber] |
| have out_mem (j : Q) : j.out ∈ fiber j := |
| (mem_fiber _ _).2 (Quotient.out_eq j) |
| have hex (j : Q) : ∃ w : Plane, w ≠ 0 ∧ ∀ i ∈ fiber j, ∃ n : ℤ, w = n • v i := by |
| have himage : ((fiber j).image v).Nonempty := |
| ⟨v j.out, Finset.mem_image_of_mem v (out_mem j)⟩ |
| obtain ⟨w, hw, hm⟩ := exists_common_collinear_multiple ((fiber j).image v) himage |
| (by |
| intro z hz |
| obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hz |
| exact hv i) |
| (by |
| intro z hz z' hz' |
| obtain ⟨i, hi, rfl⟩ := Finset.mem_image.mp hz |
| obtain ⟨i', hi', rfl⟩ := Finset.mem_image.mp hz' |
| exact Quotient.exact (((mem_fiber i j).1 hi).trans ((mem_fiber i' j).1 hi').symm)) |
| exact ⟨w, hw, fun i hi => hm (v i) (Finset.mem_image_of_mem v hi)⟩ |
| choose w hw hm using hex |
| let ψ : Q → Plane → ℝ := fun j x => ∑ i ∈ fiber j, φ i x |
| have hψ (j : Q) (x : Plane) : 0 ≤ ψ j x := |
| Finset.sum_nonneg (fun i _ => hφ i x) |
| have htotal (x : Plane) : (∑ j, ψ j x) = ∑ i, φ i x := by |
| simp only [ψ, fiber, Finset.sum_filter] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [Finset.sum_eq_single (cls i)] |
| · simp only [ite_true] |
| · intro j _ hji |
| exact ite_eq_right (Ne.symm hji) |
| · intro hi |
| exact False.elim (hi (Finset.mem_univ _)) |
| have hψone (j : Q) (x : Plane) : ψ j x ≤ 1 := by |
| have hj : ψ j x ≤ ∑ j', ψ j' x := |
| Finset.single_le_sum (fun j' _ => hψ j' x) (Finset.mem_univ j) |
| rw [htotal] at hj |
| linarith [hsum x, ha x] |
| have hper (j : Q) : Function.Periodic (ψ j) (w j) := by |
| intro x |
| apply Finset.sum_congr rfl |
| intro i hi |
| obtain ⟨n, hn⟩ := hm j i hi |
| rw [hn] |
| exact (hp i).zsmul n x |
| have hpair (j k : Q) (hjk : j ≠ k) : planeDet (w j) (w k) ≠ 0 := by |
| intro hdet |
| obtain ⟨n, hn⟩ := hm j j.out (out_mem j) |
| obtain ⟨m, hmk⟩ := hm k k.out (out_mem k) |
| have hn0 : n ≠ 0 := by |
| intro hn0 |
| exact hw j (by simpa [hn0] using hn) |
| have hm0 : m ≠ 0 := by |
| intro hm0 |
| exact hw k (by simpa [hm0] using hmk) |
| rw [hn, hmk, planeDet_zsmul_left, planeDet_zsmul_right] at hdet |
| have hz : planeDet (v j.out) (v k.out) = 0 := |
| (mul_eq_zero.mp ((mul_eq_zero.mp hdet).resolve_left hn0)).resolve_left hm0 |
| apply hjk |
| calc |
| j = cls j.out := (Quotient.out_eq j).symm |
| _ = cls k.out := Quotient.sound hz |
| _ = k := Quotient.out_eq k |
| let e : Fin (Fintype.card Q) ≃ Q := (Fintype.equivFin Q).symm |
| refine ⟨Fintype.card Q, fun j => w (e j), fun j => ψ (e j), |
| fun j => hw (e j), ?_, ?_, ?_, fun j => hper (e j)⟩ |
| · intro i j hij |
| exact hpair (e i) (e j) (fun he => hij (e.injective he)) |
| · intro j x |
| exact ⟨hψ (e j) x, hψone (e j) x⟩ |
| · intro x |
| rw [e.sum_comp (fun j => ψ j x), htotal] |
| exact hsum x |
|
|
| theorem Tiles.exists_directional_decomposition {F : Finset Plane} {A : Set Plane} |
| (h : Tiles F A) (h0 : (0 : Plane) ∈ F) : |
| ∃ (m : ℕ) (v : Fin m → Plane) (φ : Fin m → Plane → ℝ), |
| (∀ j, v j ≠ 0) ∧ |
| (∀ i j, i ≠ j → planeDet (v i) (v j) ≠ 0) ∧ |
| (∀ j x, 0 ≤ φ j x ∧ φ j x ≤ 1) ∧ |
| (∀ x, tileIndicator ℝ A x + ∑ j, φ j x = 1) ∧ |
| ∀ j, Function.Periodic (φ j) (v j) := by |
| classical |
| obtain ⟨φ, hφ, hsum, hp⟩ := h.exists_ungrouped_directional_limits h0 |
| apply exists_grouped_directional_functions |
| (fun f : ↥(F.erase 0) => F.card.factorial • (f : Plane)) _ φ |
| (fun f x => (hφ f x).1) hp (fun x => tileIndicator_nonneg A x) hsum |
| intro f |
| have hq : (F.card.factorial : ℤ) ≠ 0 := by |
| exact_mod_cast Nat.factorial_ne_zero F.card |
| simpa only [natCast_zsmul] using |
| zsmul_plane_ne_zero hq (Finset.mem_erase.mp f.property).1 |
|
|
| end PeriodicTilingThree |
|
|
| end |
|
|
| end OAI |
|
|
