| import Mathlib |
| import OAI.Probability.BinarySweep.Trajectories.EndpointEvents |
| |
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps |
| open Sparse |
|
|
| attribute [local instance] Classical.propDecidable |
| variable {b h : ℕ} {bits : Fin b → ℕ} |
|
|
| lemma gridPartialSweep_endpoint (g : GridChoices bits) (e : GridSlot bits × GridSlot bits) |
| (he : gridSweep bits g e.1=e.2) (t : Fin (b+1)) : |
| gridPartialSweep bits g t e.1=independentPosition e t := by |
| have hh := independentPosition_of_path (fun t => gridPartialSweep bits g t e.1) |
| (gridPartialSweep_changes bits g e.1) t |
| simpa only [gridPartialSweep_zero,Equiv.Perm.one_apply,gridPartialSweep_last,he] using hh.symm |
|
|
| lemma path_completion_finite {L : Type*} [Fintype L] |
| (pos : Fin (b+1) → L → GridSlot bits) (hi : ∀t, Function.Injective (pos t)) |
| (hc : ∀j l i, i≠j → pos j.succ l i=pos j.castSucc l i) : |
| ∃g : GridChoices bits, ∀j l, gridLayer bits g j (pos j.castSucc l)=pos j.succ l := by |
| let K : PathFamily bits (Fintype.card L) := |
| {position := fun t i => pos t ((Fintype.equivFin L).symm i) |
| disjoint := fun t => (hi t).comp (Fintype.equivFin L).symm.injective |
| changes_only_stage := fun j k i h => hc j _ i h} |
| obtain ⟨g,hg⟩ := pathEvent_nonempty K |
| refine ⟨g,fun j l => ?_⟩ |
| have hh := hg j (Fintype.equivFin L l) |
| change gridLayer bits g j (pos j.castSucc ((Fintype.equivFin L).symm |
| (Fintype.equivFin L l)))=pos j.succ ((Fintype.equivFin L).symm (Fintype.equivFin L l)) at hh |
| simpa only [Equiv.symm_apply_apply] using hh |
|
|
| variable {I : Type*} [Fintype I] [DecidableEq I] (H : PathFamily bits h) |
|
|
| def EndpointValid (A : Finset I) (e : I → GridSlot bits × GridSlot bits) : Prop := |
| (∀t, ∀i∈A, ∀a∈A, independentPosition (e i) t=independentPosition (e a) t → i=a) ∧ |
| (∀t, ∀i∈A, ∀k, independentPosition (e i) t≠H.position t k) |
|
|
| omit [Fintype I] [DecidableEq I] in |
| lemma endpointValid_mono {A B : Finset I} {e : I → GridSlot bits × GridSlot bits} |
| (hAB : A⊆B) (he : EndpointValid H B e) : EndpointValid H A e := |
| ⟨fun t i hi a ha => he.1 t i (hAB hi) a (hAB ha), |
| fun t i hi k => he.2 t i (hAB hi) k⟩ |
|
|
| omit [Fintype I] [DecidableEq I] in |
| lemma endpointValid_completion (A : Finset I) (e : I → GridSlot bits × GridSlot bits) |
| (he : EndpointValid H A e) : |
| ∃g : GridChoices bits, pathEvent H g ∧ ∀i∈A, gridSweep bits g (e i).1=(e i).2 := by |
| let pos (t : Fin (b+1)) : Fin h ⊕ A → GridSlot bits := |
| Sum.elim (H.position t) (fun i => independentPosition (e i) t) |
| have hi (t) : Function.Injective (pos t) := by |
| apply (H.disjoint t).sumElim |
| · intro i a hh |
| exact Subtype.ext (he.1 t i i.property a a.property hh) |
| · intro k i hh |
| exact he.2 t i i.property k hh.symm |
| have hc (j : Fin b) (l : Fin h ⊕ A) (i : Fin b) (hij : i≠j) : |
| pos j.succ l i=pos j.castSucc l i := by |
| cases l with |
| | inl k => exact H.changes_only_stage j k i hij |
| | inr a => exact independentPosition_changes (e a) j i hij |
| obtain ⟨g,hg⟩ := path_completion_finite pos hi hc |
| refine ⟨g,fun j k => hg j (.inl k),?_⟩ |
| intro i hi |
| apply (gridSweep_endpoint_iff g (e i)).mpr |
| intro j |
| exact (endpoint_gridLayer_iff g (e i) j).mp (hg j (.inr ⟨i,hi⟩)) |
|
|
| lemma endpointValid_of_placement_event {k : ℕ} (x : Placement H k 0) |
| (y : Placement H k (Fin.last b)) (A : Finset (Fin k)) |
| (g : ConditionalChoices H) (he : ∀i∈A, gridSweep bits g.val (x i).val=(y i).val) : |
| EndpointValid H A (fun i => ((x i).val,(y i).val)) := by |
| constructor |
| · intro t i hi a ha hp |
| rw [← gridPartialSweep_endpoint g.val _ (he i hi), |
| ← gridPartialSweep_endpoint g.val _ (he a ha)] at hp |
| exact x.injective (Subtype.ext ((gridPartialSweep bits g.val t).injective hp)) |
| · intro t i hi k hp |
| rw [← gridPartialSweep_endpoint g.val _ (he i hi), |
| ← gridPartialSweep_path H g.val g.property] at hp |
| exact (x i).property ⟨k,((gridPartialSweep bits g.val t).injective hp).symm⟩ |
|
|
| lemma endpointValid_placement_iff {k : ℕ} (x : Placement H k 0) |
| (y : Placement H k (Fin.last b)) (A : Finset (Fin k)) : |
| EndpointValid H A (fun i => ((x i).val,(y i).val)) ↔ |
| ∃g : ConditionalChoices H, ∀i∈A, gridSweep bits g.val (x i).val=(y i).val := by |
| constructor |
| · intro he |
| obtain ⟨g,hg,hp⟩ := endpointValid_completion H A _ he |
| exact ⟨⟨g,hg⟩,hp⟩ |
| · rintro ⟨g,hg⟩ |
| exact endpointValid_of_placement_event H x y A g hg |
|
|
| omit [Fintype I] in |
| lemma endpointValid_insert (A : Finset I) (e : I → GridSlot bits × GridSlot bits) (i : I) |
| (hh : ∀t k, independentPosition (e i) t≠H.position t k) |
| (ha : ∀t a, a≠i → independentPosition (e a) t≠independentPosition (e i) t) : |
| EndpointValid H (insert i A) e ↔ EndpointValid H A e := by |
| constructor |
| · exact endpointValid_mono H (Finset.subset_insert _ _) |
| · rintro ⟨hp,hq⟩ |
| constructor |
| · intro t a hA c hC hac |
| rcases Finset.mem_insert.mp hA with rfl | hA |
| · rcases Finset.mem_insert.mp hC with rfl | hC |
| · rfl |
| · by_contra hne |
| exact ha t c (Ne.symm hne) hac.symm |
| · rcases Finset.mem_insert.mp hC with rfl | hC |
| · by_contra hne |
| exact ha t a hne hac |
| · exact hp t a hA c hC hac |
| · intro t a hA k |
| rcases Finset.mem_insert.mp hA with rfl | hA |
| · exact hh t k |
| · exact hq t a hA k |
|
|
| end BinaryCoordinateSweeps |
| |
| end |
|
|
| end OAI |
|
|
