| import OAI.Computability.MatchingCount.RecursiveCompiler |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.Raw |
| open StackCode RecursiveEval |
|
|
| def ArgGood (n B : ℕ) (a : OddArg) : Prop := |
| ∃ (c : Fin n → Fin n → ℕ) (U : Finset (Fin n)),a=(matrixRep c,cutRep U) ∧ DenseOracle.total c≤B |
| def CutGood (n : ℕ) (S : Cut) : Prop := ∃ U : Finset (Fin n),S=cutRep U |
| def JoinGood (n B : ℕ) (a : OddJoin) : Prop := |
| ∃ (c : Fin n → Fin n → ℕ) (A : Finset (Fin n)) (r q : Fin n), |
| a=(matrixRep c,(cutRep A,(r.val,q.val))) ∧ DenseOracle.total c≤B |
|
|
| lemma oddExpand_good (n B : ℕ) (a : OddArg) (ha : ArgGood n B a) : |
| match oddExpand n a with |
| | .leaf S => CutGood n S |
| | .fork c x y => JoinGood n B c ∧ ArgGood n B x ∧ ArgGood n B y := by |
| obtain ⟨c,U,rfl,hc⟩ := ha |
| simp only [oddExpand,terminalCut_rep,inter_rep,cardinal_rep,compl_rep,outside_rep] |
| split_ifs |
| · exact ⟨_,rfl⟩ |
| · cases hr : OddMincut.outside (TerminalMincut.terminalCut c U) <;> |
| cases hq : OddMincut.outside (TerminalMincut.terminalCut c U)ᶜ <;> |
| simp only [Option.map_none,Option.map_some,contract_rep] |
| · exact ⟨_,empty_rep _⟩ |
| · exact ⟨_,empty_rep _⟩ |
| · exact ⟨_,empty_rep _⟩ |
| · rename_i r q |
| refine ⟨⟨c,_,r,q,rfl,hc⟩,⟨_,_,rfl,?_⟩,⟨_,_,rfl,?_⟩⟩ <;> |
| exact (DenseOracle.push_total_le _ _).trans hc |
|
|
| lemma oddCombine_good (n B : ℕ) (c : OddJoin) (hc : JoinGood n B c) |
| (X : Cut) (hX : CutGood n X) (Y : Cut) (hY : CutGood n Y) : CutGood n (oddCombine n c X Y) := by |
| obtain ⟨c,A,r,q,rfl,hc⟩ := hc |
| obtain ⟨X,rfl⟩ := hX |
| obtain ⟨Y,rfl⟩ := hY |
| simp only [oddCombine,compl_rep,lift_rep,cheaper_rep] |
| exact ⟨_,rfl⟩ |
|
|
| lemma vectorRep_code_bound {α : Type} [Coding α] {n : ℕ} (f : Fin n → α) (M : ℕ) |
| (h : ∀ i,(encode (f i)).length≤M) : |
| (encode (vectorRep f)).length≤n*(2*M+1) := by |
| have hh := list_code_bound (vectorRep f) M (by |
| intro a ha |
| obtain ⟨i,rfl⟩ := List.mem_ofFn.mp ha |
| exact h i) |
| simpa only [vectorRep,List.length_ofFn] using hh |
|
|
| lemma matrixRep_code_bound {n : ℕ} (c : Fin n → Fin n → ℕ) (B : ℕ) |
| (h : DenseOracle.total c≤B) : (encode (matrixRep c)).length≤n*(2*(n*(2*B+1))+1) := by |
| apply vectorRep_code_bound |
| intro i |
| apply vectorRep_code_bound |
| intro j |
| simpa only [code_nat_length] using (DenseOracle.entry_le_total c i j).trans h |
|
|
| lemma cutRep_code_length {n : ℕ} (S : Finset (Fin n)) : (encode (cutRep S)).length=3*n := by |
| rw [cut_code_length] |
| simp only [cutRep,vectorRep,List.length_ofFn] |
|
|
| def oddWordBound (n B : ℕ) : ℕ := 1000*(n+1)^2*(B+1) |
| def oddBudget (n B : ℕ) : ℕ := 100000*(n+1)^3*(B+1) |
|
|
| lemma arg_code_bound (n B : ℕ) (a : OddArg) (ha : ArgGood n B a) : |
| (encode a).length≤100*(n+1)^2*(B+1) := by |
| obtain ⟨c,U,rfl,hc⟩ := ha |
| have hh := matrixRep_code_bound c B hc |
| simp only [code_pair_length,cutRep_code_length] |
| calc |
| _ ≤ 2*(n*(2*(n*(2*B+1))+1))+3*n+1 := by omega |
| _ ≤ _ := by ring_nf; omega |
| lemma join_code_bound (n B : ℕ) (a : OddJoin) (ha : JoinGood n B a) : |
| (encode a).length≤100*(n+1)^2*(B+1) := by |
| obtain ⟨c,A,r,q,rfl,hc⟩ := ha |
| have hh := matrixRep_code_bound c B hc |
| have hr := r.isLt |
| have hq := q.isLt |
| simp only [code_pair_length,cutRep_code_length,code_nat_length] |
| calc |
| _ ≤ 2*(n*(2*(n*(2*B+1))+1))+9*n+3 := by omega |
| _ ≤ _ := by ring_nf; omega |
|
|
| lemma command_code_bound (n B : ℕ) (c : Command OddArg OddJoin) |
| (hc : CommandGood n (ArgGood n B) (JoinGood n B) c) : (encode c).length≤oddWordBound n B := by |
| cases c with |
| | call k a => |
| obtain ⟨hk,ha⟩ := hc |
| have hh := arg_code_bound n B a ha |
| rw [code_call] |
| unfold oddWordBound |
| calc |
| _ ≤ 8*n+4*(100*(n+1)^2*(B+1))+7 := by omega |
| _ ≤ _ := by ring_nf; omega |
| | join c => |
| have hh := join_code_bound n B c hc |
| rw [code_join] |
| unfold oddWordBound |
| calc |
| _ ≤ 2*(100*(n+1)^2*(B+1))+2 := by omega |
| _ ≤ _ := by ring_nf; omega |
| lemma cut_code_bound (n B : ℕ) (S : Cut) (hS : CutGood n S) : (encode S).length≤oddWordBound n B := by |
| obtain ⟨S,rfl⟩ := hS |
| rw [cutRep_code_length] |
| unfold oddWordBound |
| ring_nf |
| omega |
|
|
| lemma oddOrbit_bound {n : ℕ} (c : Fin n → Fin n → ℕ) (U : Finset (Fin n)) |
| (B : ℕ) (hB : DenseOracle.total c≤B) (j : ℕ) (hj : j≤2*n) : |
| (encode ((paramStep empty oddExpand oddCombine)^[j] |
| (n,([Command.call U.card (matrixRep c,cutRep U)],[])))).length≤oddBudget n B := by |
| rw [paramStep_iterate] |
| dsimp only |
| have hz : CutGood n (empty n) := ⟨_,empty_rep _⟩ |
| have hU : U.card≤n := by simpa only [Fintype.card_fin] using Finset.card_le_univ U |
| have hgood : StateGood n (ArgGood n B) (CutGood n) (JoinGood n B) |
| ([Command.call U.card (matrixRep c,cutRep U)],[]) := by |
| constructor |
| · intro a ha |
| obtain rfl := List.mem_singleton.mp ha |
| exact ⟨hU,⟨c,U,rfl,hB⟩⟩ |
| · simp |
| have hg := iterate_good (empty n) (oddExpand n) (oddCombine n) n (ArgGood n B) (CutGood n) (JoinGood n B) |
| hz (fun a ha => by |
| have hh := oddExpand_good n B a ha |
| cases h : oddExpand n a <;> simpa only [h] using hh) (oddCombine_good n B) _ hgood j |
| have hl := iterate_length (empty n) (oddExpand n) (oddCombine n) |
| ([Command.call U.card (matrixRep c,cutRep U)],[]) j |
| simp only [List.length_singleton,List.length_nil,Nat.add_zero] at hl |
| have hs := state_code_bound _ (oddWordBound n B) |
| (fun cmd hc => command_code_bound n B cmd (hg.1 cmd hc)) |
| (fun S hS => cut_code_bound n B S (hg.2 S hS)) |
| have hlen : ((step (empty n) (oddExpand n) (oddCombine n))^[j] |
| ([Command.call U.card (matrixRep c,cutRep U)],[])).1.length+ |
| ((step (empty n) (oddExpand n) (oddCombine n))^[j] |
| ([Command.call U.card (matrixRep c,cutRep U)],[])).2.length≤1+4*n := by omega |
| have hm := Nat.add_le_add_right |
| (Nat.mul_le_mul_right (2*oddWordBound n B+1) (Nat.mul_le_mul_left 2 hlen)) 1 |
| rw [code_pair_length,code_nat_length] |
| dsimp only |
| have hss := hs.trans hm |
| calc |
| _ ≤ 2*n+(2*(1+4*n)*(2*oddWordBound n B+1)+1)+1 := by omega |
| _ ≤ oddBudget n B := by unfold oddWordBound oddBudget; ring_nf; omega |
| end BinaryMatching.Raw |
| end |
|
|
| end OAI |
|
|
