| import OAI.Computability.MatchingCount.RawOddCompiler |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.Raw.Optimize |
| open Algorithm Finset |
| local instance : Preorder ℤ := Int.instLinearOrder.toPreorder |
|
|
| def capacities (n : ℕ) (a : Matrix ℤ) : Matrix ℕ := |
| matrix n (fun i j => if i < j then (get a i j).toNat else if j < i then (get a j i).toNat else 0) |
| lemma capacities_rep {n : ℕ} (a : Table n ℤ) : |
| capacities n (tableRep a)=matrixRep (Algorithm.capacities a) := by |
| apply matrix_eq_rep |
| intro i j |
| simp only [get_tableRep,Algorithm.capacities,Fin.lt_def] |
|
|
| def zeroRow (n : ℕ) : Row := (matrix n (fun _ _ => 0),0) |
| def degreeRow (n v : ℕ) (positive : Bool) : Row := |
| (matrix n (fun i j => if i < j then |
| if i=v ∨ j=v then (if positive then 1 else -1) else 0 else 0),if positive then -1 else 1) |
| def cutRow (n : ℕ) (S : Cut) : Row := |
| (matrix n (fun i j => if i < j then |
| if (mem S i && !mem S j) || (mem S j && !mem S i) then -1 else 0 else 0),1) |
| lemma zeroRow_rep (n : ℕ) : zeroRow n=rowRep (Algorithm.zeroRow (n := n)) := by |
| apply Prod.ext |
| · apply matrix_eq_rep |
| intro i j |
| simp [toTable,tabulate,Algorithm.zeroRow] |
| · rfl |
| lemma degreeRow_rep {n : ℕ} (v : Fin n) (b : Bool) : degreeRow n v.val b=rowRep (Algorithm.degreeRow v b) := by |
| apply Prod.ext |
| · apply matrix_eq_rep |
| intro i j |
| by_cases h : i < j <;> simp [toTable,tabulate,Algorithm.degreeRow,Fin.ext_iff,h] |
| · rfl |
| lemma cutRow_rep {n : ℕ} (S : Finset (Fin n)) : cutRow n (cutRep S)=rowRep (Algorithm.cutRow S) := by |
| apply Prod.ext |
| · apply matrix_eq_rep |
| intro i j |
| by_cases h : i < j <;> simp [toTable,tabulate,Algorithm.cutRow,h] |
| · rfl |
|
|
| def rows (n : ℕ) (a : Matrix ℤ) : List Row := |
| zeroRow n :: ((List.range n).flatMap (fun v => [degreeRow n v true,degreeRow n v false])) ++ |
| [cutRow n (oddFlat (n,(capacities n a,full n)))] |
| lemma rows_rep {n : ℕ} (hn : 2≤n) (he : Even n) (a : Table n ℤ) : |
| rows n (tableRep a)=(integralRows a).map rowRep := by |
| have hu : (univ : Finset (Fin n)).card=n := Fintype.card_fin n |
| unfold rows integralRows |
| rw [capacities_rep,full_rep,oddFlat_rep _ _ (by simpa only [hu] using he) (by simpa only [hu] using hn)] |
| simp only [zeroRow_rep,cutRow_rep,List.map_append,List.map_cons,List.map_nil, |
| DenseOracle.oddCut_eq,DenseOracle.view_make] |
| congr 2 |
| rw [range_eq_fin,List.flatMap_map,List.map_flatMap] |
| congr 1 |
| funext v |
| simp only [degreeRow_rep,List.map_cons,List.map_nil] |
|
|
| lemma argmax_map {α β γ : Type} [Preorder γ] [DecidableLT γ] (l : List α) (f : α → β) (g : β → γ) : |
| (l.map f).argmax g=(l.argmax (g ∘ f)).map f := |
| @StackCode.argmin_map_exact α β γᵒᵈ _ _ l f g |
|
|
| def selectedRow (n D : ℕ) (a : Matrix ℤ) : Row := |
| ((rows n a).argmax (rowNumerator D a)).getD (zeroRow n) |
| lemma selectedRow_rep {n : ℕ} (hn : 2≤n) (he : Even n) (D : ℕ) (a : Table n ℤ) : |
| selectedRow n D (tableRep a)=rowRep (integralRow D a) := by |
| unfold selectedRow integralRow |
| rw [rows_rep hn he,argmax_map] |
| have hf : rowNumerator D (tableRep a) ∘ rowRep=Algorithm.rowNumerator D a := by |
| funext r |
| exact rowNumerator_rep D a r |
| rw [hf] |
| cases h : (integralRows a).argmax (Algorithm.rowNumerator D a) with |
| | none => exact zeroRow_rep n |
| | some r => rfl |
| end BinaryMatching.Raw.Optimize |
| end |
|
|
| end OAI |
|
|
