File size: 9,359 Bytes
97c3405 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 | import OAI.Combinatorics.CompleteCrossing.Plane
import OAI.Combinatorics.Crossing.FiniteAffineCover
namespace OAI
/-! Affine polygonal subdivisions and chain parametrizations. -/
section
noncomputable section
open Set
open Zarankiewicz
open scoped Classical
namespace Paper170
/-- An affine cover retaining its actual interval endpoints. -/
structure AffineCoverData {a b : Plane} (γ : Path a b) where
intervals : Finset (unitInterval × unitInterval)
ordered : ∀ ab ∈ intervals, ab.1 < ab.2
cover : ∀ t : unitInterval, ∃ ab ∈ intervals, ab.1 ≤ t ∧ t ≤ ab.2
affine : ∀ ab ∈ intervals, ∀ t : unitInterval,
γ (intervalSegment ab.1 ab.2 t) = Zarankiewicz.segmentPoint (γ ab.1) (γ ab.2) t.val
def AffineCoverData.segment (a b : Plane) : AffineCoverData (Path.segment a b) where
intervals := {(0,1)}
ordered := by
intro ab hab
have h : ab = (0,1) := Finset.mem_singleton.mp hab
subst ab
norm_num
cover := fun t => ⟨(0,1), Finset.mem_singleton_self _, t.property⟩
affine := by
intro ab hab t
have h : ab = (0,1) := Finset.mem_singleton.mp hab
subst ab
simp only [intervalSegment_zero_one, Path.source, Path.target, Path.segment_apply,
AffineMap.lineMap_apply_module, Zarankiewicz.segmentPoint]
def AffineCoverData.trans {a b c : Plane} {γ : Path a b} {η : Path b c}
(S : AffineCoverData γ) (T : AffineCoverData η) : AffineCoverData (γ.trans η) where
intervals := S.intervals.image (fun ab => (intervalLeft ab.1, intervalLeft ab.2)) ∪
T.intervals.image (fun ab => (intervalRight ab.1, intervalRight ab.2))
ordered := by
intro ab hab
rcases Finset.mem_union.mp hab with hab | hab
· obtain ⟨cd,hcd,rfl⟩ := Finset.mem_image.mp hab
exact intervalLeft_strictMono (S.ordered cd hcd)
· obtain ⟨cd,hcd,rfl⟩ := Finset.mem_image.mp hab
exact intervalRight_strictMono (T.ordered cd hcd)
cover := by
intro t
by_cases ht : t.val ≤ 1/2
· let u : unitInterval := ⟨2*t.val, by constructor <;> linarith [t.property.1]⟩
obtain ⟨ab,hab,ha,hb⟩ := S.cover u
have hu : intervalLeft u=t := by apply Subtype.ext; change (2*t.val)/2=t.val; ring
refine ⟨(intervalLeft ab.1,intervalLeft ab.2),
Finset.mem_union_left _ (Finset.mem_image.mpr ⟨ab,hab,rfl⟩), ?_, ?_⟩
· change intervalLeft ab.1 ≤ t
rw [←hu]
exact intervalLeft_strictMono.monotone ha
· change t ≤ intervalLeft ab.2
rw [←hu]
exact intervalLeft_strictMono.monotone hb
· let u : unitInterval := ⟨2*t.val-1, by constructor <;> linarith [t.property.2]⟩
obtain ⟨ab,hab,ha,hb⟩ := T.cover u
have hu : intervalRight u=t := by apply Subtype.ext; change (1+(2*t.val-1))/2=t.val; ring
refine ⟨(intervalRight ab.1,intervalRight ab.2),
Finset.mem_union_right _ (Finset.mem_image.mpr ⟨ab,hab,rfl⟩), ?_, ?_⟩
· change intervalRight ab.1 ≤ t
rw [←hu]
exact intervalRight_strictMono.monotone ha
· change t ≤ intervalRight ab.2
rw [←hu]
exact intervalRight_strictMono.monotone hb
affine := by
intro ab hab t
rcases Finset.mem_union.mp hab with hab | hab
· obtain ⟨cd,hcd,rfl⟩ := Finset.mem_image.mp hab
rw [intervalSegment_left, path_trans_intervalLeft, path_trans_intervalLeft, path_trans_intervalLeft]
exact S.affine cd hcd t
· obtain ⟨cd,hcd,rfl⟩ := Finset.mem_image.mp hab
rw [intervalSegment_right, path_trans_intervalRight, path_trans_intervalRight, path_trans_intervalRight]
exact T.affine cd hcd t
lemma AffineCoverData.trans_endpoints {a b c : Plane} {γ : Path a b} {η : Path b c}
(S : AffineCoverData γ) (T : AffineCoverData η) (B : Set Plane)
(hS : ∀ ab ∈ S.intervals, γ ab.1 ∈ B ∧ γ ab.2 ∈ B)
(hT : ∀ ab ∈ T.intervals, η ab.1 ∈ B ∧ η ab.2 ∈ B) :
∀ ab ∈ (S.trans T).intervals, (γ.trans η) ab.1 ∈ B ∧ (γ.trans η) ab.2 ∈ B := by
intro ab hab
rcases Finset.mem_union.mp hab with hab | hab
· obtain ⟨cd,hcd,rfl⟩ := Finset.mem_image.mp hab
simpa only [path_trans_intervalLeft] using hS cd hcd
· obtain ⟨cd,hcd,rfl⟩ := Finset.mem_image.mp hab
simpa only [path_trans_intervalRight] using hT cd hcd
lemma AffineCoverData.subdivision {a b : Plane} {γ : Path a b}
(S : AffineCoverData γ) (B : Set Plane) (ha : a ∈ B) (hb : b ∈ B)
(hS : ∀ ab ∈ S.intervals, γ ab.1 ∈ B ∧ γ ab.2 ∈ B) :
∃ P : PolygonalParametrization γ, ∀ i, γ (P.knot i) ∈ B := by
let T : Finset unitInterval := insert 0 (insert 1 (S.intervals.image Prod.fst ∪ S.intervals.image Prod.snd))
obtain ⟨k, _, t, ht, h0, h1, hR⟩ := exists_sorted_unitInterval_finset T (by simp [T]) (by simp [T])
have hleft (ab : unitInterval × unitInterval) (hab : ab ∈ S.intervals) : ab.1 ∈ range t := by
rw [hR]
exact Finset.mem_insert_of_mem (Finset.mem_insert_of_mem
(Finset.mem_union_left _ (Finset.mem_image.mpr ⟨ab,hab,rfl⟩)))
have hright (ab : unitInterval × unitInterval) (hab : ab ∈ S.intervals) : ab.2 ∈ range t := by
rw [hR]
exact Finset.mem_insert_of_mem (Finset.mem_insert_of_mem
(Finset.mem_union_right _ (Finset.mem_image.mpr ⟨ab,hab,rfl⟩)))
let P : Zarankiewicz.PolygonalParametrization γ := {
pieces := k
knot := t
increasing := ht
first := h0
last := h1
affine := by
intro i u
let mid : unitInterval := ⟨1/2, by norm_num⟩
let z := intervalSegment (t i.castSucc) (t i.succ) mid
have hz : t i.castSucc < z ∧ z < t i.succ :=
intervalSegment_strict_between _ _ mid (ht (by change i.val < i.val+1; omega)) (by
constructor <;> change (_ : ℝ) < _ <;> norm_num [mid])
obtain ⟨ab,hab,ha,hb⟩ := S.cover z
have hlo : ab.1 ≤ t i.castSucc := by
by_contra hn
obtain ⟨j,hj⟩ := hleft ab hab
exact strictMono_no_between_successors t ht i j
⟨by rw [hj]; exact lt_of_not_ge hn, by rw [hj]; exact ha.trans_lt hz.2⟩
have hhi : t i.succ ≤ ab.2 := by
by_contra hn
obtain ⟨j,hj⟩ := hright ab hab
exact strictMono_no_between_successors t ht i j
⟨by rw [hj]; exact hz.1.trans_le hb, by rw [hj]; exact lt_of_not_ge hn⟩
have hle : t i.castSucc ≤ t i.succ := ht.monotone (by change i.val ≤ i.val+1; omega)
exact path_affine_restrict γ ab.1 ab.2 (S.ordered ab hab) (S.affine ab hab)
(t i.castSucc) (t i.succ) ⟨hlo,hle.trans hhi⟩ ⟨hlo.trans hle,hhi⟩ u }
refine ⟨ofZarankiewiczParametrization P, ?_⟩
intro i
have hi : t i ∈ T := by
change t i ∈ (T : Set unitInterval)
rw [←hR]
exact ⟨i,rfl⟩
simp only [T, Finset.mem_insert, Finset.mem_union, Finset.mem_image] at hi
rcases hi with hi | hi | ⟨ab,hab,hi⟩ | ⟨ab,hab,hi⟩
· change γ (t i) ∈ B
simpa [hi] using ha
· change γ (t i) ∈ B
simpa [hi] using hb
· change γ (t i) ∈ B
simpa only [←hi] using (hS ab hab).1
· change γ (t i) ∈ B
simpa only [←hi] using (hS ab hab).2
end Paper170
end
end
section
noncomputable section
open Set
open Zarankiewicz
open scoped Classical
namespace Paper170
lemma polygonalArcPath_safe_cover (v : ℕ → Plane) (B : Set Plane) (n : ℕ)
(hn : 0 < n) (hv : ∀ i, i ≤ n → v i ∈ B) :
∃ S : AffineCoverData (polygonalArcPath v n),
∀ ab ∈ S.intervals, polygonalArcPath v n ab.1 ∈ B ∧ polygonalArcPath v n ab.2 ∈ B := by
induction n using Nat.strong_induction_on with
| h n ih =>
cases n with
| zero => omega
| succ n =>
cases n with
| zero =>
refine ⟨AffineCoverData.segment (v 0) (v 1), ?_⟩
intro ab hab
have he : ab = (0,1) := Finset.mem_singleton.mp hab
subst ab
exact ⟨by simpa only [polygonalArcPath, Path.source] using hv 0 (by omega),
by simpa only [polygonalArcPath, Path.target] using hv 1 le_rfl⟩
| succ n =>
obtain ⟨S,hS⟩ := ih (n+1) (by omega) (by omega) (fun i hi => hv i (by omega))
let T := AffineCoverData.segment (v (n+1)) (v (n+2))
refine ⟨S.trans T, S.trans_endpoints T B hS ?_⟩
intro ab hab
have he : ab = (0,1) := Finset.mem_singleton.mp hab
subst ab
exact ⟨by simpa only [Path.source] using hv (n+1) (by omega),
by simpa only [Path.target] using hv (n+2) le_rfl⟩
def PolygonalParametrization.cast {a b c d : Plane} {γ : Path a b}
(P : PolygonalParametrization γ) (ha : c = a) (hb : d = b) :
PolygonalParametrization (γ.cast ha hb) where
pieces := P.pieces
positive := P.positive
knot := P.knot
increasing := P.increasing
first := P.first
last := P.last
affine := P.affine
lemma chain_subdivision_avoiding {O : Set Plane} {a b : Plane}
(P : PolygonalChain O a b) (hP : 0 < P.pieces) (B : Set Plane)
(hv : ∀ i, i ≤ P.pieces → P.vertices i ∈ B) :
∃ Q : PolygonalParametrization P.path, ∀ i, P.path (Q.knot i) ∈ B := by
obtain ⟨S,hS⟩ := polygonalArcPath_safe_cover P.vertices B P.pieces hP hv
obtain ⟨Q,hQ⟩ := S.subdivision B (hv 0 (Nat.zero_le _)) (hv _ le_rfl) hS
exact ⟨Q.cast P.first.symm P.last.symm, hQ⟩
end Paper170
end
end
end OAI
|