File size: 5,222 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 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 | import OAI.Computability.MatchingCount.BinaryAlgorithm
namespace OAI
section
namespace BinaryMatching.DenseOracle
open Finset UnitFlow CutAlgebra OddCutParity
variable {n : ℕ}
abbrev Matrix (n : ℕ) (α : Type) := Vector (Vector α n) n
def make {α : Type} (f : Fin n → Fin n → α) : Matrix n α :=
Vector.ofFn (fun i => Vector.ofFn (f i))
def view {α : Type} (a : Matrix n α) : Fin n → Fin n → α := fun i j => a[i][j]
@[simp] lemma view_make {α : Type} (f : Fin n → Fin n → α) : view (make f)=f := by
funext i j; simp [view,make]
abbrev Paths (n : ℕ) := Vector (Option (List (Fin n))) n
def pathView (p : Paths n) : ResidualSearch.Table n := fun v => p[v]
def pathInitial (a : Fin n) : Paths n := Vector.ofFn (ResidualSearch.initial a)
def pathStep (c : Matrix n ℕ) (b : Matrix n ℤ) (p : Paths n) : Paths n :=
Vector.ofFn (ResidualSearch.step (UnitMincut.residual (view c) (view b)) (pathView p))
def search (c : Matrix n ℕ) (b : Matrix n ℤ) (a : Fin n) : ℕ → Paths n
| 0 => pathInitial a
| k+1 => pathStep c b (search c b a k)
lemma pathView_ofFn (p : ResidualSearch.Table n) : pathView (Vector.ofFn p)=p := by
funext v; simp [pathView]
lemma search_view (c : Matrix n ℕ) (b : Matrix n ℤ) (a : Fin n) (k : ℕ) :
pathView (search c b a k)=ResidualSearch.search (UnitMincut.residual (view c) (view b)) a k := by
induction k with
| zero => exact pathView_ofFn _
| succ k ih => simp only [search,pathStep,pathView_ofFn,ih,ResidualSearch.search]
def augment (c : Matrix n ℕ) (a z : Fin n) (b : Matrix n ℤ) : Matrix n ℤ :=
match (search c b a n)[z] with
| none => b
| some p => make (fun i j => view b i j+pathFlow p i j)
def iterate (c : Matrix n ℕ) (a z : Fin n) : ℕ → Matrix n ℤ
| 0 => make (fun _ _ => 0)
| k+1 => augment c a z (iterate c a z k)
lemma augment_view (c : Matrix n ℕ) (a z : Fin n) (b : Matrix n ℤ) :
view (augment c a z b)=UnitMincut.augment (view c) a z (view b) := by
have hs := congrFun (search_view c b a n) z
change (search c b a n)[z]=_ at hs
simp only [augment,hs,UnitMincut.augment]
cases h : ResidualSearch.search (UnitMincut.residual (view c) (view b)) a n z <;>
simp only [view_make]
lemma iterate_view (c : Matrix n ℕ) (a z : Fin n) (k : ℕ) :
view (iterate c a z k)=UnitMincut.iterate (view c) a z k := by
induction k with
| zero => exact view_make _
| succ k ih => simp only [iterate,augment_view,ih,UnitMincut.iterate]
def mincut (c : Matrix n ℕ) (a z : Fin n) : Finset (Fin n) :=
let b := iterate c a z (UnitMincut.sourceCapacity (view c) a)
ResidualSearch.reached (pathView (search c b a n))
lemma mincut_eq (c : Matrix n ℕ) (a z : Fin n) : mincut c a z=UnitMincut.mincut (view c) a z := by
unfold mincut UnitMincut.mincut
dsimp only
rw [search_view]
have h := iterate_view c a z (UnitMincut.sourceCapacity (view c) a)
rw [h]
def terminalCut (c : Matrix n ℕ) (U : Finset (Fin n)) : Finset (Fin n) :=
let cuts := (((List.finRange n).product (List.finRange n)).filter
(fun az => decide (az.1∈U ∧ az.2∈U ∧ az.1≠az.2))).map
(fun az => mincut c az.1 az.2)
((cuts.argmin (cutCapacity (view c))).getD ∅)
lemma terminalCut_eq (c : Matrix n ℕ) (U : Finset (Fin n)) :
terminalCut c U=TerminalMincut.terminalCut (view c) U := by
simp only [terminalCut,mincut_eq,TerminalMincut.terminalCut,TerminalMincut.pairCuts]
def contract (c : Matrix n ℕ) (f : Fin n → Fin n) : Matrix n ℕ := make (push (view c) f)
@[simp] lemma contract_view (c : Matrix n ℕ) (f : Fin n → Fin n) :
view (contract c f)=push (view c) f := view_make _
def recurse : ℕ → Matrix n ℕ → Finset (Fin n) → Finset (Fin n)
| 0,_,_ => ∅
| k+1,c,U =>
let A := terminalCut c U
if OddSide U A then A else
match OddMincut.outside A, OddMincut.outside Aᶜ with
| some r,some q =>
let f := contractMap A r
let g := contractMap Aᶜ q
let X := recurse k (contract c f) (A∩U)
let Y := recurse k (contract c g) (Aᶜ∩U)
OddMincut.cheaper (view c) (lift f X) (lift g Y)
| _,_ => ∅
lemma recurse_eq (k : ℕ) (c : Matrix n ℕ) (U : Finset (Fin n)) :
recurse k c U=OddMincut.recurse k (view c) U := by
induction k generalizing c U with
| zero => rfl
| succ k ih =>
simp only [recurse,terminalCut_eq,OddMincut.recurse]
split
· rfl
· cases h₁ : OddMincut.outside (TerminalMincut.terminalCut (view c) U) <;>
cases h₂ : OddMincut.outside (TerminalMincut.terminalCut (view c) U)ᶜ <;>
simp only [ih,contract_view]
def oddCut (c : Matrix n ℕ) (U : Finset (Fin n)) : Finset (Fin n) := recurse U.card c U
lemma oddCut_eq (c : Matrix n ℕ) (U : Finset (Fin n)) :
oddCut c U=OddMincut.oddCut (view c) U := recurse_eq _ _ _
theorem oddCut_correct (c : Matrix n ℕ) (hc : ∀ i j, view c i j=view c j i)
(U : Finset (Fin n)) (he : Even U.card) (hU : 2≤U.card) :
OddSide U (oddCut c U) ∧
∀ S, OddSide U S → cutCapacity (view c) (oddCut c U) ≤ cutCapacity (view c) S := by
rw [oddCut_eq]
exact OddMincut.oddCut_correct _ hc _ he hU
end BinaryMatching.DenseOracle
end
end OAI
|