| import OAI.Computability.MatchingCount.RawFlowSize |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.Raw |
| open StackCode Polynomial |
| abbrev FlowContext := ℕ×(Matrix ℕ×(ℕ×ℕ)) |
| abbrev FlowState := FlowContext×Matrix ℤ |
|
|
| def flowStep (s : FlowState) : FlowState := |
| (s.1,augment s.1.1 s.1.2.1 s.1.2.2.1 s.1.2.2.2 s.2) |
| def flowInitial (z : FlowContext×ℕ) : FlowState := |
| (z.1,matrix z.1.1 (fun _ _ => 0)) |
| lemma flowStep_iterate (z : FlowContext×ℕ) (j : ℕ) : |
| flowStep^[j] (flowInitial z)=(z.1,flow z.1.1 z.1.2.1 z.1.2.2.1 z.1.2.2.2 j) := by |
| induction j with |
| | zero => rfl |
| | succ j ih => simp only [Function.iterate_succ_apply',ih,flowStep,flow] |
|
|
| namespace Compiler |
| open StackCode.Poly |
| @[fun_prop] theorem reached_poly : Poly (fun z : ℕ×Paths => reached z.1 z.2) := by |
| unfold reached |
| exact Poly.rawTab Prod.fst (fun z : (ℕ×Paths)×ℕ => (nth z.1.2 z.2).isSome) |
| (by fun_prop) (by fun_prop) |
| @[fun_prop] theorem pathFlow_poly : Poly (fun z : List ℕ×(ℕ×ℕ) => pathFlow z.1 z.2.1 z.2.2) := by |
| unfold pathFlow |
| have h : Poly (fun z : (List ℕ×(ℕ×ℕ))×(ℕ×ℕ) => |
| ((if decide (z.1.2.1=z.2.2) && decide (z.1.2.2=z.2.1) then 1 else 0)- |
| (if decide (z.1.2.1=z.2.1) && decide (z.1.2.2=z.2.2) then 1 else 0):ℤ)) := by fun_prop |
| have hm := Poly.mapWith (fun z : List ℕ×(ℕ×ℕ) => z.1.zip z.1.tail) _ (by fun_prop) h |
| exact (Poly.comp List.sum _ Poly.listIntSum hm).congr (fun z => by simp only [Bool.and_eq_true,decide_eq_true_eq]) |
| @[fun_prop] theorem augment_poly : Poly (fun z : FlowState => |
| augment z.1.1 z.1.2.1 z.1.2.2.1 z.1.2.2.2 z.2) := by |
| have hp : Poly (fun z : FlowState => nth (search z.1.1 z.1.2.1 z.2 z.1.2.2.1 z.1.1) z.1.2.2.2) := by |
| apply Poly.rawNth |
| · exact Poly.comp _ (fun z : FlowState => ((z.1.1,(z.1.2.1,(z.2,z.1.2.2.1))),z.1.1)) |
| search_poly (by fun_prop) |
| · fun_prop |
| have hm : Poly (fun z : FlowState×List ℕ => matrix z.1.1.1 (fun i j => get z.1.2 i j+pathFlow z.2 i j)) := by |
| apply Poly.rawMatrix (fun z : FlowState×List ℕ => z.1.1.1) |
| (fun z : ((FlowState×List ℕ)×ℕ)×ℕ => get z.1.1.1.2 z.1.2 z.2+pathFlow z.1.1.2 z.1.2 z.2) |
| · fun_prop |
| · have hp := Poly.comp _ (fun z : ((FlowState×List ℕ)×ℕ)×ℕ => (z.1.1.2,(z.1.2,z.2))) |
| pathFlow_poly (by fun_prop) |
| fun_prop |
| have h := Poly.optionCasesWith |
| (fun z : FlowState => nth (search z.1.1 z.1.2.1 z.2 z.1.2.2.1 z.1.1) z.1.2.2.2) |
| Prod.snd |
| (fun z => matrix z.1.1.1 (fun i j => get z.1.2 i j+pathFlow z.2 i j)) hp (by fun_prop) hm |
| exact h.congr (fun z => by unfold augment; cases nth (search z.1.1 z.1.2.1 z.2 z.1.2.2.1 z.1.1) z.1.2.2.2 <;> rfl) |
| @[fun_prop] theorem flowStep_poly : Poly flowStep := Poly.pair _ _ (by fun_prop) augment_poly |
| @[fun_prop] theorem flowInitial_poly : Poly flowInitial := by |
| unfold flowInitial |
| apply Poly.pair |
| · fun_prop |
| · exact Poly.rawMatrix (fun z : FlowContext×ℕ => z.1.1) (fun _ => (0:ℤ)) (by fun_prop) (by fun_prop) |
| @[fun_prop] theorem flow_poly : Poly (fun z : FlowContext×ℕ => |
| flow z.1.1 z.1.2.1 z.1.2.2.1 z.1.2.2.2 z.2) := by |
| have hi := Poly.iterateFrom flowStep flowStep_poly Prod.snd flowInitial (by fun_prop) |
| flowInitial_poly (1000*(X+1)^5) (by |
| intro z j hj |
| rw [flowStep_iterate] |
| let N := (encode (z.2,flowInitial z)).length |
| have hctx : (encode z.1).length≤N := by |
| simp only [N,flowInitial,code_pair_length,code_nat_length]; omega |
| have hn : z.1.1≤N := by |
| have := (pair_left_le z.1).trans hctx |
| simpa only [code_nat_length] using this |
| have ha : z.1.2.2.1≤N := by |
| have := (pair_left_le z.1.2.2).trans ((pair_right_le z.1.2).trans ((pair_right_le z.1).trans hctx)) |
| simpa only [code_nat_length] using this |
| have hk : j≤N := by |
| simp only [N,code_pair_length,code_nat_length]; omega |
| have hb := flow_code_bound z.1.1 z.1.2.1 z.1.2.2.1 z.1.2.2.2 j |
| have hm : z.1.1*(2*(z.1.1*(2*(j*(4*z.1.2.2.1+3+z.1.1*(4*z.1.1+2))+3)+1))+1)≤ |
| N*(2*(N*(2*(N*(4*N+3+N*(4*N+2))+3)+1))+1) := by gcongr |
| simp only [eval_mul,eval_ofNat,eval_pow,eval_add,eval_X,eval_one] |
| change (encode (z.1,flow z.1.1 z.1.2.1 z.1.2.2.1 z.1.2.2.2 j)).length≤1000*(N+1)^5 |
| rw [code_pair_length] |
| dsimp only |
| have hbb := hb.trans hm |
| calc |
| _ ≤ 2*N+N*(2*(N*(2*(N*(4*N+3+N*(4*N+2))+3)+1))+1)+1 := by omega |
| _ ≤ 1000*(N+1)^5 := by ring_nf; omega) |
| exact (Poly.second _ hi).congr (fun z => by rw [flowStep_iterate]) |
| @[fun_prop] theorem sourceCapacity_poly : Poly (fun z : ℕ×(Matrix ℕ×ℕ) => sourceCapacity z.1 z.2.1 z.2.2) := by |
| unfold sourceCapacity |
| apply Poly.comp List.sum _ Poly.listNatSum |
| exact Poly.rawTab Prod.fst (fun z : (ℕ×(Matrix ℕ×ℕ))×ℕ => get z.1.2.1 z.1.2.2 z.2) |
| (by fun_prop) (by fun_prop) |
| @[fun_prop] theorem mincut_poly : Poly (fun z : FlowContext => mincut z.1 z.2.1 z.2.2.1 z.2.2.2) := by |
| unfold mincut |
| have hs : Poly (fun z : FlowContext => sourceCapacity z.1 z.2.1 z.2.2.1) := |
| Poly.comp _ (fun z : FlowContext => (z.1,(z.2.1,z.2.2.1))) sourceCapacity_poly (by fun_prop) |
| have hf : Poly (fun z : FlowContext => flow z.1 z.2.1 z.2.2.1 z.2.2.2 (sourceCapacity z.1 z.2.1 z.2.2.1)) := |
| Poly.comp _ (fun z : FlowContext => (z,sourceCapacity z.1 z.2.1 z.2.2.1)) flow_poly (by fun_prop) |
| have hsearch := Poly.comp _ (fun z : FlowContext => |
| ((z.1,(z.2.1,(flow z.1 z.2.1 z.2.2.1 z.2.2.2 (sourceCapacity z.1 z.2.1 z.2.2.1),z.2.2.1))),z.1)) search_poly (by fun_prop) |
| exact Poly.comp _ (fun z : FlowContext => |
| (z.1,search z.1 z.2.1 (flow z.1 z.2.1 z.2.2.1 z.2.2.2 (sourceCapacity z.1 z.2.1 z.2.2.1)) z.2.2.1 z.1)) reached_poly (by fun_prop) |
| @[fun_prop] theorem cutCapacity_poly : Poly (fun z : ℕ×(Matrix ℕ×Cut) => cutCapacity z.1 z.2.1 z.2.2) := by |
| unfold cutCapacity |
| apply Poly.comp List.sum _ Poly.listNatSum |
| apply Poly.rawTab Prod.fst (fun z : (ℕ×(Matrix ℕ×Cut))×ℕ => |
| (tab z.1.1 (fun j => if mem z.1.2.2 z.2 && !mem z.1.2.2 j then get z.1.2.1 z.2 j else 0)).sum) |
| · fun_prop |
| · apply Poly.comp List.sum _ Poly.listNatSum |
| apply Poly.rawTab (fun z : (ℕ×(Matrix ℕ×Cut))×ℕ => z.1.1) |
| (fun z : ((ℕ×(Matrix ℕ×Cut))×ℕ)×ℕ => if mem z.1.1.2.2 z.1.2 && !mem z.1.1.2.2 z.2 then |
| get z.1.1.2.1 z.1.2 z.2 else 0) |
| · fun_prop |
| · fun_prop |
| @[fun_prop] theorem pairs_poly : Poly pairs := by |
| unfold pairs |
| apply Poly.flatMapWith List.range (fun z : ℕ×ℕ => (List.range z.1).map (fun j => (z.2,j))) (by fun_prop) |
| exact Poly.mapWith (fun z : ℕ×ℕ => List.range z.1) (fun z : (ℕ×ℕ)×ℕ => (z.1.2,z.2)) (by fun_prop) (by fun_prop) |
| @[fun_prop] theorem pairCuts_poly : Poly (fun z : ℕ×(Matrix ℕ×Cut) => pairCuts z.1 z.2.1 z.2.2) := by |
| unfold pairCuts |
| apply Poly.mapWith _ (fun z : (ℕ×(Matrix ℕ×Cut))×(ℕ×ℕ) => mincut z.1.1 z.1.2.1 z.2.1 z.2.2) |
| · apply Poly.filterWith _ (fun z : (ℕ×(Matrix ℕ×Cut))×(ℕ×ℕ) => |
| mem z.1.2.2 z.2.1 && mem z.1.2.2 z.2.2 && decide (z.2.1≠z.2.2)) |
| · fun_prop |
| · have h : Poly (fun z : (ℕ×(Matrix ℕ×Cut))×(ℕ×ℕ) => |
| mem z.1.2.2 z.2.1 && mem z.1.2.2 z.2.2 && !decide (z.2.1=z.2.2)) := by fun_prop |
| exact h.congr (fun z => by simp) |
| · exact Poly.comp _ (fun z : (ℕ×(Matrix ℕ×Cut))×(ℕ×ℕ) => (z.1.1,(z.1.2.1,z.2))) mincut_poly (by fun_prop) |
| @[fun_prop] theorem terminalCut_poly : Poly (fun z : ℕ×(Matrix ℕ×Cut) => terminalCut z.1 z.2.1 z.2.2) := by |
| unfold terminalCut |
| have hf := Poly.listArgminParam Poly.natLT |
| (fun z : (ℕ×Matrix ℕ)×Cut => cutCapacity z.1.1 z.1.2 z.2) |
| (Poly.comp _ (fun z : (ℕ×Matrix ℕ)×Cut => (z.1.1,(z.1.2,z.2))) cutCapacity_poly (by fun_prop)) |
| have ha := Poly.comp _ (fun z : ℕ×(Matrix ℕ×Cut) => ((z.1,z.2.1),pairCuts z.1 z.2.1 z.2.2)) hf (by fun_prop) |
| have h : Poly (fun z : ℕ×(Matrix ℕ×Cut) => if ((pairCuts z.1 z.2.1 z.2.2).argmin (cutCapacity z.1 z.2.1)).isSome then |
| ((pairCuts z.1 z.2.1 z.2.2).argmin (cutCapacity z.1 z.2.1)).getD default else empty z.1) := by fun_prop |
| exact h.congr (fun z => by cases (pairCuts z.1 z.2.1 z.2.2).argmin (cutCapacity z.1 z.2.1) <;> rfl) |
| end Compiler |
| end BinaryMatching.Raw |
| end |
|
|
| end OAI |
|
|
