| import OAI.Computability.LoopMatching.Model |
| import Mathlib.Data.List.Nodup |
|
|
| namespace OAI |
|
|
| /-! Polynomial-time approximation of weighted matchings with singleton loops. -/ |
|
|
| namespace LoopMatching |
|
|
| def crossRecord (n : ℕ) (r : LoopRecord) (d : ℕ) : BinaryMatching.Record := |
| ⟨r.vertex, n + d, r.multiplicity⟩ |
|
|
| def crossRecords (n j : ℕ) (rs : List LoopRecord) : List BinaryMatching.Record := |
| rs.flatMap fun r => (List.range j).map (crossRecord n r) |
|
|
| lemma mem_crossRecords {n j : ℕ} {rs : List LoopRecord} {e : BinaryMatching.Record} : |
| e ∈ crossRecords n j rs ↔ ∃ r ∈ rs, ∃ d < j, crossRecord n r d = e := by |
| simp [crossRecords] |
|
|
| lemma crossRecords_length (n j : ℕ) (rs : List LoopRecord) : |
| (crossRecords n j rs).length = rs.length * j := by |
| induction rs with |
| | nil => simp [crossRecords] |
| | cons r rs ih => |
| change (((List.range j).map (crossRecord n r)) ++ crossRecords n j rs).length = |
| (rs.length + 1) * j |
| rw [List.length_append, List.length_map, List.length_range, ih] |
| simp [Nat.add_mul, Nat.add_comm] |
|
|
| lemma crossRecords_unique (n j : ℕ) (rs : List LoopRecord) |
| (h : (rs.map LoopRecord.vertex).Nodup) : |
| ((crossRecords n j rs).map (fun e => (e.left,e.right))).Nodup := by |
| induction rs with |
| | nil => simp [crossRecords] |
| | cons r rs ih => |
| obtain ⟨hn,ht⟩ := List.nodup_cons.mp h |
| simp only [crossRecords, List.flatMap_cons, List.map_append, List.map_map] |
| apply List.nodup_append.mpr |
| refine ⟨?_, ih ht, ?_⟩ |
| · apply (List.nodup_range (n := j)).map |
| intro a b hab |
| have hh := congrArg Prod.snd hab |
| dsimp [Function.comp_def, crossRecord] at hh |
| omega |
| · intro a ha b hb hab |
| obtain ⟨d,hd,rfl⟩ := List.mem_map.mp ha |
| obtain ⟨e,he,rfl⟩ := List.mem_map.mp hb |
| obtain ⟨s,hs,c,hc,rfl⟩ := mem_crossRecords.mp he |
| have hv := congrArg Prod.fst hab |
| dsimp [Function.comp_def, crossRecord] at hv |
| exact hn (List.mem_map.mpr ⟨s,hs,hv.symm⟩) |
|
|
| def expand (G : Input) (j : ℕ) : BinaryMatching.Input where |
| n := G.n + j |
| records := G.ordinary.records ++ crossRecords G.n j G.loops |
| valid := by |
| intro e he |
| rcases List.mem_append.mp he with he | he |
| · obtain ⟨hlt,hbound⟩ := G.ordinary.valid e he |
| change e.right < G.n at hbound |
| exact ⟨hlt,by omega⟩ |
| · obtain ⟨r,hr,d,hd,rfl⟩ := mem_crossRecords.mp he |
| have hrn := G.valid r hr |
| change r.vertex < G.n at hrn |
| dsimp [crossRecord] |
| constructor <;> omega |
| unique := by |
| rw [List.map_append] |
| apply List.nodup_append.mpr |
| refine ⟨G.ordinary.unique, crossRecords_unique _ _ _ G.unique, ?_⟩ |
| intro a ha b hb hab |
| obtain ⟨e,he,rfl⟩ := List.mem_map.mp ha |
| obtain ⟨f,hf,rfl⟩ := List.mem_map.mp hb |
| obtain ⟨r,hr,d,hd,rfl⟩ := mem_crossRecords.mp hf |
| have hn := (G.ordinary.valid e he).2 |
| change e.right < G.n at hn |
| have hh := congrArg Prod.snd hab |
| dsimp [crossRecord] at hh |
| omega |
|
|
| @[simp] lemma expand_n (G : Input) (j : ℕ) : (expand G j).n = G.n+j := rfl |
|
|
| @[simp] lemma expand_records_length (G : Input) (j : ℕ) : |
| (expand G j).records.length = G.ordinary.records.length + G.loops.length*j := by |
| simp [expand, crossRecords_length] |
|
|
| lemma expand_records_length_le (G : Input) {j : ℕ} (hj : j ≤ G.n) : |
| (expand G j).records.length ≤ G.ordinary.records.length + G.loops.length*G.n := by |
| rw [expand_records_length] |
| exact Nat.add_le_add_left (Nat.mul_le_mul_left _ hj) _ |
|
|
| def oldPair (G : Input) (j : ℕ) (e : BinaryMatching.Pair G.n) : |
| BinaryMatching.Pair (expand G j).n := |
| ⟨(⟨e.val.1.val,by have := e.val.1.isLt; simp only [expand_n]; omega⟩, |
| ⟨e.val.2.val,by have := e.val.2.isLt; simp only [expand_n]; omega⟩),e.property⟩ |
| |
| def crossPair (G : Input) (j : ℕ) (v : Fin G.n) (d : Fin j) : |
| BinaryMatching.Pair (expand G j).n := |
| ⟨(⟨v.val,by have := v.isLt; simp only [expand_n]; omega⟩, |
| ⟨G.n+d.val,by have := d.isLt; simp only [expand_n]; omega⟩),by |
| change v.val < G.n+d.val |
| have := v.isLt |
| omega⟩ |
|
|
| def dummyPair (G : Input) (j : ℕ) (e : BinaryMatching.Pair j) : |
| BinaryMatching.Pair (expand G j).n := |
| ⟨(⟨G.n+e.val.1.val,by have := e.val.1.isLt; simp only [expand_n]; omega⟩, |
| ⟨G.n+e.val.2.val,by have := e.val.2.isLt; simp only [expand_n]; omega⟩),by |
| change G.n+e.val.1.val < G.n+e.val.2.val |
| have := e.property |
| exact Nat.add_lt_add_left this _⟩ |
|
|
| private lemma find_some_unique {α : Type*} (p : α → Bool) (xs : List α) (a : α) |
| (ha : a ∈ xs) (hp : p a = true) (hu : ∀ b ∈ xs, p b = true → b=a) : |
| xs.find? p = some a := by |
| cases hf : xs.find? p with |
| | none => exact False.elim ((List.find?_eq_none.mp hf a ha) hp) |
| | some b => |
| have hb := hu b (List.mem_of_find?_eq_some hf) (List.find?_some hf) |
| exact congrArg some hb |
|
|
| private lemma find_cross_block (n j i d : ℕ) (r : LoopRecord) (hd : d<j) : |
| ((List.range j).map (crossRecord n r)).find? |
| (fun e => e.left=i && e.right=n+d) = |
| if r.vertex=i then some (crossRecord n r d) else none := by |
| by_cases hi : r.vertex=i |
| · rw [ite_eq_left hi] |
| apply find_some_unique |
| · exact List.mem_map.mpr ⟨d,List.mem_range.mpr hd,rfl⟩ |
| · simp [crossRecord,hi] |
| · intro b hb hp |
| obtain ⟨c,hc,rfl⟩ := List.mem_map.mp hb |
| have he : n+c=n+d := by simpa [crossRecord,hi] using hp |
| have : c=d := by omega |
| subst c |
| rfl |
| · rw [ite_eq_right hi] |
| apply List.find?_eq_none.mpr |
| intro b hb |
| obtain ⟨c,hc,rfl⟩ := List.mem_map.mp hb |
| simp [crossRecord,hi] |
|
|
| private lemma find_crossRecords (n j i d : ℕ) (rs : List LoopRecord) (hd : d<j) : |
| (crossRecords n j rs).find? (fun e => e.left=i && e.right=n+d) = |
| (rs.find? (fun r => r.vertex == i)).map (fun r => crossRecord n r d) := by |
| induction rs with |
| | nil => simp [crossRecords] |
| | cons r rs ih => |
| change ((((List.range j).map (crossRecord n r)) ++ crossRecords n j rs).find? |
| (fun e => e.left=i && e.right=n+d)) = |
| ((r :: rs).find? (fun r => r.vertex == i)).map (fun r => crossRecord n r d) |
| rw [List.find?_append, find_cross_block n j i d r hd] |
| by_cases hi : r.vertex=i |
| · simp [hi] |
| · simp [hi, ih] |
|
|
| lemma multiplicity_expand_old (G : Input) (j : ℕ) (e : BinaryMatching.Pair G.n) : |
| BinaryMatching.multiplicity (expand G j) (oldPair G j e) = |
| BinaryMatching.multiplicity G.ordinary e := by |
| have hn : (crossRecords G.n j G.loops).find? |
| (fun r => r.left=e.val.1.val && r.right=e.val.2.val) = none := by |
| apply List.find?_eq_none.mpr |
| intro r hr |
| obtain ⟨s,hs,d,hd,rfl⟩ := mem_crossRecords.mp hr |
| have he := e.val.2.isLt |
| have hne : G.n+d ≠ e.val.2.val := by omega |
| simp [crossRecord,hne] |
| change (match (G.ordinary.records ++ crossRecords G.n j G.loops).find? |
| (fun r => r.left=e.val.1.val && r.right=e.val.2.val) with |
| | none => 0 | some r => r.multiplicity) = |
| (match G.ordinary.records.find? |
| (fun r => r.left=e.val.1.val && r.right=e.val.2.val) with |
| | none => 0 | some r => r.multiplicity) |
| rw [List.find?_append, hn] |
| cases G.ordinary.records.find? (fun r => r.left=e.val.1.val && r.right=e.val.2.val) <;> rfl |
| |
| lemma multiplicity_expand_cross (G : Input) (j : ℕ) (v : Fin G.n) (d : Fin j) : |
| BinaryMatching.multiplicity (expand G j) (crossPair G j v d) = loopMultiplicity G v := by |
| have hn : G.ordinary.records.find? |
| (fun r => r.left=v.val && r.right=G.n+d.val) = none := by |
| apply List.find?_eq_none.mpr |
| intro r hr |
| have hb := (G.ordinary.valid r hr).2 |
| change r.right < G.n at hb |
| have hne : r.right ≠ G.n+d.val := by omega |
| simp [hne] |
| change (match (G.ordinary.records ++ crossRecords G.n j G.loops).find? |
| (fun r => r.left=v.val && r.right=G.n+d.val) with |
| | none => 0 | some r => r.multiplicity) = loopMultiplicity G v |
| rw [List.find?_append, hn] |
| change (match (crossRecords G.n j G.loops).find? |
| (fun r => r.left=v.val && r.right=G.n+d.val) with |
| | none => 0 | some r => r.multiplicity) = _ |
| rw [find_crossRecords G.n j v.val d.val G.loops d.isLt] |
| unfold loopMultiplicity |
| cases G.loops.find? (fun r => r.vertex == v.val) <;> rfl |
| |
| lemma multiplicity_expand_dummy (G : Input) (j : ℕ) (e : BinaryMatching.Pair j) : |
| BinaryMatching.multiplicity (expand G j) (dummyPair G j e) = 0 := by |
| have hn : (expand G j).records.find? |
| (fun r => r.left=G.n+e.val.1.val && r.right=G.n+e.val.2.val) = none := by |
| apply List.find?_eq_none.mpr |
| intro r hr |
| have hb : r.left < G.n := by |
| rcases List.mem_append.mp hr with hr | hr |
| · obtain ⟨hlt,hbound⟩ := G.ordinary.valid r hr |
| change r.right < G.n at hbound |
| omega |
| · obtain ⟨s,hs,d,hd,rfl⟩ := mem_crossRecords.mp hr |
| exact G.valid s hs |
| have hne : r.left ≠ G.n+e.val.1.val := by omega |
| simp [hne] |
| change (match (expand G j).records.find? |
| (fun r => r.left=G.n+e.val.1.val && r.right=G.n+e.val.2.val) with |
| | none => 0 | some r => r.multiplicity) = 0 |
| rw [hn] |
|
|
| end LoopMatching |
|
|
| end OAI |
|
|
