File size: 4,914 Bytes
ea76aac | 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 | import OAI.Computability.MatchingCount.RawSearchCompiler
namespace OAI
section
namespace BinaryMatching.Raw
open Finset
def augment (n : ℕ) (c : Matrix ℕ) (a z : ℕ) (b : Matrix ℤ) : Matrix ℤ :=
match nth (search n c b a n) z with
| none => b
| some p => matrix n (fun i j => get b i j+pathFlow p i j)
def flow (n : ℕ) (c : Matrix ℕ) (a z k : ℕ) : Matrix ℤ :=
(augment n c a z)^[k] (matrix n (fun _ _ => 0))
def sourceCapacity (n : ℕ) (c : Matrix ℕ) (a : ℕ) : ℕ := (tab n (get c a)).sum
def mincut (n : ℕ) (c : Matrix ℕ) (a z : ℕ) : Cut :=
reached n (search n c (flow n c a z (sourceCapacity n c a)) a n)
def cutCapacity (n : ℕ) (c : Matrix ℕ) (S : Cut) : ℕ :=
(tab n (fun i => (tab n (fun j => if mem S i && !mem S j then get c i j else 0)).sum)).sum
def pairs (n : ℕ) : List (ℕ×ℕ) := (List.range n).flatMap (fun i => (List.range n).map (i,·))
def pairCuts (n : ℕ) (c : Matrix ℕ) (U : Cut) : List Cut :=
((pairs n).filter (fun az => mem U az.1 && mem U az.2 && decide (az.1≠az.2))).map
(fun az => mincut n c az.1 az.2)
def terminalCut (n : ℕ) (c : Matrix ℕ) (U : Cut) : Cut :=
((pairCuts n c U).argmin (cutCapacity n c)).getD (empty n)
lemma augment_rep {n : ℕ} (c : Fin n → Fin n → ℕ) (a z : Fin n) (b : UnitFlow.Matrix (Fin n)) :
augment n (matrixRep c) a.val z.val (matrixRep b)=matrixRep (UnitMincut.augment c a z b) := by
unfold augment
rw [search_rep,nth_pathRep]
unfold UnitMincut.augment
cases h : ResidualSearch.search (UnitMincut.residual c b) a n z with
| none => rfl
| some p =>
simp only [Option.map_some]
apply matrix_eq_rep
intro i j
simp only [get_rep,pathFlow_rep]
lemma flow_rep {n : ℕ} (c : Fin n → Fin n → ℕ) (a z : Fin n) (k : ℕ) :
flow n (matrixRep c) a.val z.val k=matrixRep (UnitMincut.iterate c a z k) := by
induction k with
| zero => exact matrix_eq_rep _ _ (fun _ _ => rfl)
| succ k ih =>
simp only [flow,Function.iterate_succ_apply'] at *
rw [ih,augment_rep]
rfl
lemma sourceCapacity_rep {n : ℕ} (c : Fin n → Fin n → ℕ) (a : Fin n) :
sourceCapacity n (matrixRep c) a.val=UnitMincut.sourceCapacity c a := by
simp [sourceCapacity,sum_tab,UnitMincut.sourceCapacity]
lemma mincut_rep {n : ℕ} (c : Fin n → Fin n → ℕ) (a z : Fin n) :
mincut n (matrixRep c) a.val z.val=cutRep (UnitMincut.mincut c a z) := by
simp only [mincut,sourceCapacity_rep,flow_rep,search_rep,reached_rep,UnitMincut.mincut]
lemma cutCapacity_rep {n : ℕ} (c : Fin n → Fin n → ℕ) (S : Finset (Fin n)) :
cutCapacity n (matrixRep c) (cutRep S)=UnitFlow.cutCapacity c S := by
simp only [cutCapacity,sum_tab,mem_rep,Bool.and_eq_true,Bool.not_eq_true',decide_eq_true_eq,
decide_eq_false_iff_not,get_rep]
simp only [ite_and,Finset.sum_ite_irrel,Finset.sum_const_zero]
simp only [Finset.sum_ite_mem,Finset.univ_inter]
unfold UnitFlow.cutCapacity
apply Finset.sum_congr rfl
intro i hi
rw [show Sᶜ=univ.filter (fun j => j∉S) by ext; simp]
simp only [Finset.sum_filter]
lemma pairs_rep (n : ℕ) : pairs n=(((List.finRange n).product (List.finRange n)).map
(fun az => (az.1.val,az.2.val))) := by
simp only [pairs,List.product,range_eq_fin,List.flatMap_map,List.map_flatMap,List.map_map,Function.comp_def]
lemma pairCuts_rep {n : ℕ} (c : Fin n → Fin n → ℕ) (U : Finset (Fin n)) :
pairCuts n (matrixRep c) (cutRep U)=(TerminalMincut.pairCuts c U).map cutRep := by
unfold pairCuts TerminalMincut.pairCuts
rw [pairs_rep,List.filter_map,List.map_map,List.map_map]
have hp : (fun az : Fin n×Fin n => mem (cutRep U) az.1.val && mem (cutRep U) az.2.val &&
decide (az.1.val≠az.2.val))=(fun az => decide (az.1∈U ∧ az.2∈U ∧ az.1≠az.2)) := by
funext az
simp [Fin.ext_iff,Bool.and_assoc]
simp only [Function.comp_def]
rw [hp]
apply List.map_congr_left
intro az haz
exact mincut_rep c az.1 az.2
lemma argmin_map_eq {α β : Type} (f : α → β) (l : List α) (g : β → ℕ) :
(l.map f).argmin g=(l.argmin (g ∘ f)).map f := by
induction l using List.reverseRecOn with
| nil => rfl
| append_singleton l a ih =>
rw [List.map_append,List.map_singleton,List.argmin_concat,List.argmin_concat,ih]
cases h : l.argmin (g ∘ f) with
| none => rfl
| some b => simp only [Option.map_some,Function.comp_apply]; split_ifs <;> rfl
lemma terminalCut_rep {n : ℕ} (c : Fin n → Fin n → ℕ) (U : Finset (Fin n)) :
terminalCut n (matrixRep c) (cutRep U)=cutRep (TerminalMincut.terminalCut c U) := by
unfold terminalCut TerminalMincut.terminalCut
rw [pairCuts_rep,argmin_map_eq]
have hg : cutCapacity n (matrixRep c) ∘ cutRep=UnitFlow.cutCapacity c := by
funext S; exact cutCapacity_rep c S
rw [hg,empty_rep]
cases h : (TerminalMincut.pairCuts c U).argmin (UnitFlow.cutCapacity c) <;> rfl
end BinaryMatching.Raw
end
end OAI
|