| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Reduction.CircleCost |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace LargeIndependentSets.ShortestPaths |
|
|
| open scoped ENNReal |
|
|
| lemma pathDistance_surjective {X Y : Type*} (e : X → Y) (he : Function.Surjective e) |
| (w : Y → Y → ℝ≥0∞) (x y : X) : |
| pathDistance (fun a b => w (e a) (e b)) x y = pathDistance w (e x) (e y) := by |
| unfold pathDistance |
| apply le_antisymm |
| · apply le_iInf |
| intro zs |
| obtain ⟨ws,hws⟩ := List.map_surjective_iff.mpr he zs |
| apply iInf_le_of_le ws |
| rw [walkLength_reindex,hws] |
| · apply le_iInf |
| intro zs |
| rw [walkLength_reindex] |
| exact iInf_le_of_le (zs.map e) le_rfl |
|
|
| theorem cover_allPairs_exact {Q : Type*} [DecidableEq Q] {M : Q → Type*} |
| [∀ q, Fintype (M q)] [∀ q, DecidableEq (M q)] |
| (S : ProjectionSystem Q M) [∀ q q' π, Decidable (S.imposed q q' π)] |
| {D : ℕ} [NeZero D] {n : ℕ} (e : Fin n → GridLocation M D) |
| (he : Function.Surjective e) (i j : Fin n) : |
| let a : Matrix n := Vector.ofFn (fun x => Vector.ofFn (fun y => linkCost S (e x) (e y))) |
| (a.allPairs.get i j : ℝ≥0∞)/(D : ℝ≥0∞) = pathDistance S.linkLength (e i) (e j) := by |
| dsimp only |
| rw [Matrix.scaled_allPairs_exact] |
| have hh : (fun x y : Fin n => |
| ((Matrix.get (Vector.ofFn (fun x => Vector.ofFn (fun y => linkCost S (e x) (e y)))) x y : ℝ≥0∞) / |
| (D : ℝ≥0∞))) = (fun x y => S.linkLength (e x) (e y)) := by |
| funext x y |
| simpa only [Matrix.get,Vector.getElem_ofFn] using linkCost_exact S (e x) (e y) |
| rw [hh,pathDistance_surjective e he] |
|
|
| end LargeIndependentSets.ShortestPaths |
|
|
| namespace LargeIndependentSets.GeometryNames |
|
|
| section |
| open scoped ENNReal Classical BigOperators |
|
|
| def mixed {U V : Type*} {n : ℕ} (u : Fin n → U) (v : Fin n → V) (i : ℕ) : |
| MixedTuple U V n i := |
| ⟨fun k => if k.val < i then Sum.inl (v k) else Sum.inr (u k),by |
| intro k; by_cases hk : k.val < i <;> simp [hk]⟩ |
|
|
| @[simp] lemma mixed_val {U V : Type*} {n : ℕ} (u : Fin n → U) (v : Fin n → V) |
| (i : ℕ) (k : Fin n) : (mixed u v i).val k = |
| if k.val < i then Sum.inl (v k) else Sum.inr (u k) := rfl |
|
|
| lemma mixed_surjective {U V : Type*} [Nonempty U] [Nonempty V] {n i : ℕ} |
| (q : MixedTuple U V n i) : ∃ u v, mixed u v i=q := by |
| let u : Fin n → U := fun k => (q.val k).elim (fun _ => Classical.choice inferInstance) id |
| let v : Fin n → V := fun k => (q.val k).elim id (fun _ => Classical.choice inferInstance) |
| refine ⟨u,v,Subtype.ext ?_⟩ |
| funext k |
| have h := q.property k |
| cases he : q.val k with |
| | inl a => |
| have hk : k.val < i := by simpa [he] using h.symm |
| simp [mixed,u,v,he,hk] |
| | inr a => |
| have hk : ¬k.val < i := by simpa [he] using h.symm |
| simp [mixed,u,v,he,hk] |
|
|
| abbrev StaticPoint (L R : Type) (n D : ℕ) := |
| Σ i : Fin (n+1), MixedTuple L R n i.val → ZMod D |
|
|
| def decode {U V L R : Type} {n D : ℕ} |
| (u : Fin n → U) (v : Fin n → V) (a : StaticPoint L R n D) : |
| GridLocation (LayerAnswer L R (U:=U) (V:=V) (n:=n)) D := |
| ⟨⟨a.1,mixed u v a.1.val⟩,a.2⟩ |
|
|
| lemma decode_surjective {U V L R : Type} [Nonempty U] [Nonempty V] {n D : ℕ} |
| (x : GridLocation (LayerAnswer L R (U:=U) (V:=V) (n:=n)) D) : |
| ∃ u v a, decode u v a=x := by |
| rcases x with ⟨⟨i,q⟩,x⟩ |
| obtain ⟨u,v,h⟩ := mixed_surjective q |
| refine ⟨u,v,⟨i,x⟩,?_⟩ |
| cases h |
| rfl |
|
|
| abbrev Node (L R : Type) (n D nu nv : ℕ) := |
| ((Fin n → Fin nu) × (Fin n → Fin nv)) × StaticPoint L R n D |
|
|
| def nodeDecode {L R : Type} {n D nu nv : ℕ} (x : Node L R n D nu nv) := |
| decode x.1.1 x.1.2 x.2 |
|
|
| lemma nodeDecode_surjective {L R : Type} {n D nu nv : ℕ} (hu : 0<nu) (hv : 0<nv) : |
| Function.Surjective (@nodeDecode L R n D nu nv) := by |
| let : Nonempty (Fin nu) := ⟨⟨0,hu⟩⟩ |
| let : Nonempty (Fin nv) := ⟨⟨0,hv⟩⟩ |
| intro x |
| obtain ⟨u,v,a,h⟩ := decode_surjective x |
| exact ⟨((u,v),a),h⟩ |
|
|
| def nodeEquiv (L R : Type) [Fintype L] [Fintype R] (n D nu nv : ℕ) [NeZero D] : |
| Node L R n D nu nv ≃ Fin ((nu^n*nv^n)*Fintype.card (StaticPoint L R n D)) := |
| (Equiv.prodCongr ((Equiv.prodCongr finFunctionFinEquiv finFunctionFinEquiv).trans |
| finProdFinEquiv) (Fintype.equivFin (StaticPoint L R n D))).trans finProdFinEquiv |
|
|
| def names (L R : Type) [Fintype L] [Fintype R] (n D nu nv : ℕ) [NeZero D] := |
| fun i => nodeDecode ((nodeEquiv L R n D nu nv).symm i) |
|
|
| lemma names_surjective (L R : Type) [Fintype L] [Fintype R] (n D nu nv : ℕ) [NeZero D] |
| (hu : 0<nu) (hv : 0<nv) : Function.Surjective (names L R n D nu nv) := |
| (nodeDecode_surjective hu hv).comp (nodeEquiv L R n D nu nv).symm.surjective |
|
|
| end |
|
|
| open scoped Classical |
|
|
| def PointStep {L R : Type} {n D : ℕ} (h : Fin n) (f : L → R) |
| (a b : StaticPoint L R n D) : Prop := |
| ∃ (x : MixedTuple L R n h.val → ZMod D) (y : MixedTuple L R n (h.val+1) → ZMod D), |
| a=⟨h.castSucc,x⟩ ∧ b=⟨h.succ,y⟩ ∧ x=y ∘ mixedProject h f |
|
|
| def QuestionStep {U V L R C : Type} {n : ℕ} (lc : LabelCoverData U V L R C) |
| (h : Fin n) (c : C) (u u' : Fin n → U) (v v' : Fin n → V) : Prop := |
| u h=lc.left c ∧ v' h=lc.right c ∧ |
| ∀ k, k≠h → if k.val<h.val then v k=v' k else u k=u' k |
| |
| lemma questionStep_iff {U V L R C : Type} {n : ℕ} (lc : LabelCoverData U V L R C) |
| (h : Fin n) (c : C) (u u' : Fin n → U) (v v' : Fin n → V) : |
| QuestionStep lc h c u u' v v' ↔ |
| (mixed u v h.val).val h=Sum.inr (lc.left c) ∧ |
| (mixed u' v' (h.val+1)).val h=Sum.inl (lc.right c) ∧ |
| ∀ k, k≠h → (mixed u v h.val).val k=(mixed u' v' (h.val+1)).val k := by |
| simp only [QuestionStep,mixed_val,lt_self_iff_false,ite_false,Sum.inr.injEq, |
| Nat.lt_succ_self,ite_true,Sum.inl.injEq] |
| apply and_congr_right |
| intro _ |
| apply and_congr_right |
| intro _ |
| apply forall_congr' |
| intro k |
| by_cases hk : k=h |
| · simp [hk] |
| · have hne : k.val≠h.val := fun e => hk (Fin.ext e) |
| by_cases hl : k.val<h.val |
| · simp [hk,hl,show k.val<h.val+1 by omega] |
| · simp [hk,hl,show ¬k.val<h.val+1 by omega] |
|
|
| lemma forward_iff {U V L R C : Type} {n D : ℕ} (lc : LabelCoverData U V L R C) |
| (u u' : Fin n → U) (v v' : Fin n → V) (a b : StaticPoint L R n D) : |
| (layeredSystem lc n).ForwardZero D (decode u v a) (decode u' v' b) ↔ |
| ∃ h c, PointStep h (lc.project c) a b ∧ QuestionStep lc h c u u' v v' := by |
| constructor |
| · intro hz |
| rw [ShortestPaths.forwardZero_iff] at hz |
| obtain ⟨π,hπ,hcoord⟩ := hz |
| rcases a with ⟨i,a⟩ |
| rcases b with ⟨j,b⟩ |
| change LayerImposed lc n ⟨i,mixed u v i.val⟩ ⟨j,mixed u' v' j.val⟩ π at hπ |
| cases hπ with |
| | adjacent h q q' c hl hr ho => |
| refine ⟨h,c,?_,?_⟩ |
| · exact ⟨a,b,rfl,rfl,hcoord⟩ |
| · exact (questionStep_iff lc h c u u' v v').mpr ⟨hl,hr,ho⟩ |
| · rintro ⟨h,c,⟨x,y,rfl,rfl,hxy⟩,hq⟩ |
| rw [ShortestPaths.forwardZero_iff] |
| obtain ⟨hl,hr,ho⟩ := (questionStep_iff lc h c u u' v v').mp hq |
| exact ⟨mixedProject h (lc.project c),.adjacent h _ _ c hl hr ho,hxy⟩ |
| |
| end LargeIndependentSets.GeometryNames |
| |
| end |
| |
| end OAI |
| |
