File size: 5,014 Bytes
97c3405 | 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 | import OAI.Combinatorics.ContingencyTables.Transport.BoxCompletion
import OAI.Combinatorics.ContingencyTables.Transport.FiniteGridWords
import OAI.Combinatorics.ContingencyTables.Dense.DenseCanonicalProgram
namespace OAI
/-! # Explicit free-box enumeration with binary completion tests -/
namespace ContingencyTables.DensePrograms
open MatchingFPRAS MatchingFPRAS.TreeTyped ProfilePrograms
open scoped BigOperators Classical
abbrev CompletionMargins := List ℕ×List ℕ
def completionEnumerationData (z : CompletionMargins) : GridEnumerationData :=
((zeroGrid z).map (fun _ => false),z.1.sum+1)
def completionEnumerationDataRealizer : Realizer completionEnumerationData := by
let dims := composition zeroGridRealizer (map (constant false))
let base : Realizer (fun z : CompletionMargins => z.1.sum+1) :=
composition (composition first listSum) successor
exact pair dims base
lemma polynomial_completionEnumerationData : PolynomialTime completionEnumerationDataRealizer := by
unfold completionEnumerationDataRealizer
exact polynomial_pair (polynomial_composition polynomial_zeroGrid
(polynomial_map (polynomial_constant false)))
(polynomial_composition (polynomial_composition polynomial_first polynomial_listSum)
polynomial_successor)
def completionCandidate (z : CompletionMargins×List ℕ) : Option MatrixCode :=
acceptCompletion (z.1,unflattenGrid z)
def completionCandidateRealizer : Realizer completionCandidate :=
composition (pair first unflattenGridRealizer) acceptCompletionRealizer
lemma polynomial_completionCandidate : PolynomialTime completionCandidateRealizer :=
polynomial_composition (polynomial_pair polynomial_first polynomial_unflattenGrid)
polynomial_acceptCompletion
/-- Rejected candidates remain as `none`, allowing later integer sums
to ignore them without adding a second enumeration or an ordering oracle. -/
def completionCandidates (z : CompletionMargins) : List (Option MatrixCode) :=
(gridWords (completionEnumerationData z)).map (fun v => completionCandidate (z,v))
def completionCandidatesRealizer : Realizer completionCandidates :=
composition (pair identity (composition completionEnumerationDataRealizer gridWordsRealizer))
(mapWith completionCandidateRealizer)
def completionEnumerationMeasure (z : CompletionMargins) : ℕ :=
gridStateCount (completionEnumerationData z)+weight z
theorem work_completionCandidates :
WorkBound completionCandidatesRealizer completionEnumerationMeasure := by
have hp : WorkBound completionEnumerationDataRealizer completionEnumerationMeasure :=
work_of_polynomial polynomial_completionEnumerationData Polynomial.X (fun z => by
simp only [completionEnumerationMeasure,Polynomial.eval_X]; omega)
obtain ⟨p,hp'⟩ := hp
have hg : WorkBound (composition completionEnumerationDataRealizer gridWordsRealizer)
completionEnumerationMeasure := by
apply work_composition ⟨p,hp'⟩ work_gridWords (Polynomial.X+p)
intro z
have hw := hp' z
simp only [completionEnumerationMeasure,Polynomial.eval_add,Polynomial.eval_X]
change gridStateCount (completionEnumerationData z)+weight (completionEnumerationData z)≤_
change _≤p.eval (completionEnumerationMeasure z) at hw
unfold completionEnumerationMeasure at hw
omega
unfold completionCandidatesRealizer
apply work_then_polynomial _ (polynomial_mapWith polynomial_completionCandidate)
exact work_pair (work_of_polynomial polynomial_identity Polynomial.X (fun z => by
simp only [completionEnumerationMeasure,Polynomial.eval_X]; omega)) hg Polynomial.X
(fun z => by simp only [completionEnumerationMeasure,Polynomial.eval_X]; omega)
lemma gridWords_finFunctions (xs : List Bool) (N q : ℕ) (hq : xs.length=q) :
gridWords (xs,N+1)=List.ofFn (fun k : Fin ((N+1)^q) =>
List.ofFn (fun i : Fin q => ((finFunctionFinEquiv.symm k) i).val)) := by
rw [gridWords_eq_length xs (N+1) q hq]
rfl
theorem completionCandidates_code {m n : ℕ} (R : Option (Fin m) → ℕ)
(P : Option (Fin n) → ℕ) (htotal : ∑ i,R i=∑ j,P j) :
completionCandidates (marginCode R,marginCode P)=
List.ofFn (fun k : Fin (((∑ i,R i)+1)^(m*n)) =>
(BoxCompletion.decode R P htotal (∑ i,R i) (finFunctionFinEquiv.symm k)).map tableOutput) := by
have hsum : (marginCode R).sum=∑ i,R i := by
simp only [marginCode,List.sum_cons,List.sum_ofFn,Fintype.sum_option]
have hlen : ((zeroGrid (marginCode R,marginCode P)).map (fun _ => false)).length=m*n := by
simp only [zeroGrid,List.length_map,cellPairs,List.length_range,marginCode,
List.tail_cons,List.length_ofFn]
unfold completionCandidates completionEnumerationData
rw [hsum,gridWords_finFunctions _ (∑ i,R i) (m*n) hlen,List.map_ofFn]
apply congrArg List.ofFn
funext k
dsimp only [Function.comp_apply,completionCandidate]
rw [unflattenGrid_code]
exact BoxCompletion.acceptCompletion_eq R P htotal (finFunctionFinEquiv.symm k)
end ContingencyTables.DensePrograms
end OAI
|