File size: 11,254 Bytes
d5b7741 | 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 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | import OAI.Combinatorics.ContingencyTables.Rooted.RootedForestDataProgram
import OAI.Combinatorics.ContingencyTables.Dense.DenseOffsetWidths
namespace OAI
/-! # Assembling the affine input from ordinary rectangular cell arrays
The baseline and both stored views are binary natural matrices. The
program reads each cell once, computes its row/column vertex indices,
and constructs the offset evaluator input in row-major order.
-/
namespace ContingencyTables.RootedCellDataProgram
open MatchingFPRAS.TreeTyped DensePrograms ProfilePrograms
open FiniteGraphRootProgram FiniteGraphCutProgram
open scoped Classical
abbrev Matrices := (MatrixCode×MatrixCode)×(MatrixCode×MatrixCode)
abbrev Frame := (EdgeInput×ℕ)×(List ℕ×List ℕ)
abbrev Input := Frame×Matrices
abbrev CellInput := Input×(ℕ×ℕ)
def values (z : Matrices×(ℕ×ℕ)) : (ℕ×ℕ)×(ℕ×ℕ) :=
((matrixEntry (z.1.1.1,z.2),matrixEntry (z.1.1.2,z.2)),
(matrixEntry (z.1.2.1,z.2),matrixEntry (z.1.2.2,z.2)))
def valuesRealizer : Realizer values :=
pair
(pair
(composition (pair (composition (composition first first) first) second) matrixEntryRealizer)
(composition (pair (composition (composition first first) second) second) matrixEntryRealizer))
(pair
(composition (pair (composition (composition first second) first) second) matrixEntryRealizer)
(composition (pair (composition (composition first second) second) second) matrixEntryRealizer))
lemma polynomial_values : PolynomialTime valuesRealizer :=
polynomial_pair
(polynomial_pair
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_first)
polynomial_first) polynomial_second) polynomial_matrixEntry)
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_first)
polynomial_second) polynomial_second) polynomial_matrixEntry))
(polynomial_pair
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_first) polynomial_second) polynomial_matrixEntry)
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_second) polynomial_second) polynomial_matrixEntry))
def endpoints (z : Frame×(ℕ×ℕ)) : ℕ×ℕ :=
(z.2.1,z.1.2.1.length+z.2.2)
def endpointsRealizer : Realizer endpoints :=
pair (composition second first)
(composition (pair (composition (composition (composition first second) first) listLength)
(composition second second)) add)
lemma polynomial_endpoints : PolynomialTime endpointsRealizer :=
polynomial_pair (polynomial_composition polynomial_second polynomial_first)
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition
(polynomial_composition polynomial_first polynomial_second) polynomial_first)
polynomial_listLength)
(polynomial_composition polynomial_second polynomial_second)) polynomial_add)
def cellValues (z : CellInput) : (ℕ×ℕ)×(ℕ×ℕ) := values (z.1.2,z.2)
def cellValuesRealizer : Realizer cellValues :=
composition (f := fun z : CellInput => (z.1.2,z.2)) (g := values)
(pair (composition first second) second) valuesRealizer
lemma polynomial_cellValues : PolynomialTime cellValuesRealizer :=
polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_second)
polynomial_second) polynomial_values
def coefficientInput (z : CellInput) : RootedCoefficientProgram.Input :=
((z.1.1.1.1,endpoints (z.1.1,z.2)),(z.1.1.1.2,(cellValues z).1.1))
def coefficientInputRealizer : Realizer coefficientInput :=
pair
(pair (composition (composition (composition first first) first) first)
(composition (pair (composition first first) second) endpointsRealizer))
(pair (composition (composition (composition first first) first) second)
(composition (composition cellValuesRealizer first) first))
lemma polynomial_coefficientInput : PolynomialTime coefficientInputRealizer :=
polynomial_pair
(polynomial_pair
(polynomial_composition (polynomial_composition
(polynomial_composition polynomial_first polynomial_first) polynomial_first) polynomial_first)
(polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_first) polynomial_second) polynomial_endpoints))
(polynomial_pair
(polynomial_composition (polynomial_composition
(polynomial_composition polynomial_first polynomial_first) polynomial_first) polynomial_second)
(polynomial_composition (polynomial_composition polynomial_cellValues polynomial_first)
polynomial_first))
def entry (z : CellInput) : RootedOffsetProgram.Entry :=
((coefficientInput z,(((cellValues z).2.1,0),((cellValues z).2.2,0))),
((cellValues z).1.2,0))
def entryRealizer : Realizer entry :=
pair (pair coefficientInputRealizer
(pair (pair (composition (composition cellValuesRealizer second) first) (constant 0))
(pair (composition (composition cellValuesRealizer second) second) (constant 0))))
(pair (composition (composition cellValuesRealizer first) second) (constant 0))
lemma polynomial_entry : PolynomialTime entryRealizer :=
polynomial_pair (polynomial_pair polynomial_coefficientInput
(polynomial_pair
(polynomial_pair (polynomial_composition (polynomial_composition polynomial_cellValues
polynomial_second) polynomial_first) (polynomial_constant 0))
(polynomial_pair (polynomial_composition (polynomial_composition polynomial_cellValues
polynomial_second) polynomial_second) (polynomial_constant 0))))
(polynomial_pair (polynomial_composition (polynomial_composition polynomial_cellValues
polynomial_first) polynomial_second) (polynomial_constant 0))
def baselineCell (z : Frame) : ℕ×ℕ :=
(z.1.1.2.1,z.1.1.2.2-z.2.1.length)
def baselineCellRealizer : Realizer baselineCell :=
pair (composition (composition (composition first first) second) first)
(composition (pair (composition (composition (composition first first) second) second)
(composition (composition second first) listLength)) subtract)
lemma polynomial_baselineCell : PolynomialTime baselineCellRealizer :=
polynomial_pair (polynomial_composition (polynomial_composition
(polynomial_composition polynomial_first polynomial_first) polynomial_second) polynomial_first)
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition
(polynomial_composition polynomial_first polynomial_first) polynomial_second) polynomial_second)
(polynomial_composition (polynomial_composition polynomial_second polynomial_first)
polynomial_listLength)) polynomial_subtract)
def offsetInput (z : Input) : RootedOffsetProgram.Input :=
((matrixEntry (z.2.1.2,baselineCell z.1),0),
(cellPairs z.1.2).map (fun a => entry (z,a)))
def offsetInputRealizer : Realizer offsetInput :=
pair (pair
(composition (pair (composition (composition second first) second)
(composition first baselineCellRealizer)) matrixEntryRealizer) (constant 0))
(composition (pair identity (composition (composition first second) cellPairsRealizer))
(mapWith entryRealizer))
theorem polynomial_offsetInput : PolynomialTime offsetInputRealizer :=
polynomial_pair
(polynomial_pair (polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_second polynomial_first) polynomial_second)
(polynomial_composition polynomial_first polynomial_baselineCell)) polynomial_matrixEntry)
(polynomial_constant 0))
(polynomial_composition (polynomial_pair polynomial_identity
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_cellPairs)) (polynomial_mapWith polynomial_entry))
open CompanionFactorialApplication RootedCompletion
noncomputable def data {m n : ℕ} (A : Instance (Fin m) (Fin n))
(t : GraphCompletionCounts.TreeCell A.T) (x q : Fin m → Fin n → ℕ) : Input :=
((((graphCode (A.T.comap finSumFinEquiv.symm),
((finSumFinEquiv (m := m) (n := n) (.inl t.val.1)).val,
(finSumFinEquiv (m := m) (n := n) (.inr t.val.2)).val)),A.W),
(List.ofFn (fun i => (A.r i).toNat),List.ofFn (fun j => (A.c j).toNat))),
((matrixCode A.b,matrixCode (fun i j => (A.X i j).toNat)),(matrixCode x,matrixCode q)))
lemma values_data {m n : ℕ} (A : Instance (Fin m) (Fin n))
(t : GraphCompletionCounts.TreeCell A.T) (x q : Fin m → Fin n → ℕ)
(i : Fin m) (j : Fin n) :
values ((data A t x q).2,(i.val,j.val))=
((A.b i j,(A.X i j).toNat),(x i j,q i j)) := by
simp only [values,data,matrixEntry_code]
lemma coefficientInput_data {m n : ℕ} (A : Instance (Fin m) (Fin n))
(t : GraphCompletionCounts.TreeCell A.T) (x q : Fin m → Fin n → ℕ)
(i : Fin m) (j : Fin n) :
coefficientInput (data A t x q,(i.val,j.val))=RootedCoefficientProgram.input A t (i,j) := by
simp only [coefficientInput,cellValues,values_data]
simp only [endpoints,data,List.length_ofFn,RootedCoefficientProgram.input,
finSumFinEquiv_apply_left,finSumFinEquiv_apply_right,Fin.val_castAdd,Fin.val_natAdd]
lemma entry_data {m n : ℕ} (A : Instance (Fin m) (Fin n))
(t : GraphCompletionCounts.TreeCell A.T) (x q : Fin m → Fin n → ℕ)
(i : Fin m) (j : Fin n) :
entry (data A t x q,(i.val,j.val))=RootedOffsetProgram.entry A t
(fun i j => (x i j:ℤ)) (fun i j => (q i j:ℤ)) (i,j) := by
have hx : ForestAffineProgram.signedParts (A.X i j)=((A.X i j).toNat,0) := by
unfold ForestAffineProgram.signedParts
rw [Int.toNat_of_nonpos (neg_nonpos.mpr (A.hX i j).1)]
simp only [entry,coefficientInput_data,cellValues,values_data,RootedOffsetProgram.entry]
rw [hx]
simp only [ForestAffineProgram.signedParts,Int.toNat_natCast,Int.toNat_neg_natCast]
theorem offsetInput_data {m n : ℕ} (A : Instance (Fin m) (Fin n))
(t : GraphCompletionCounts.TreeCell A.T) (x q : Fin m → Fin n → ℕ) :
offsetInput (data A t x q)=RootedOffsetProgram.data A t
(fun i j => (x i j:ℤ)) (fun i j => (q i j:ℤ)) finProdFinEquiv.symm := by
have hx : ForestAffineProgram.signedParts (A.X t.val.1 t.val.2)=
((A.X t.val.1 t.val.2).toNat,0) := by
unfold ForestAffineProgram.signedParts
rw [Int.toNat_of_nonpos (neg_nonpos.mpr (A.hX t.val.1 t.val.2).1)]
unfold offsetInput RootedOffsetProgram.data
apply Prod.ext
· simp only [data,baselineCell,List.length_ofFn,finSumFinEquiv_apply_left,
finSumFinEquiv_apply_right,Fin.val_castAdd,Fin.val_natAdd,
Nat.add_sub_cancel_left,matrixEntry_code,hx]
· change (cellPairs (List.ofFn (fun i => (A.r i).toNat),
List.ofFn (fun j => (A.c j).toNat))).map (fun a => entry (data A t x q,a))=_
rw [DensePrograms.cellPairs_ofFn]
simp only [List.map_ofFn]
congr 1
funext k
exact entry_data A t x q (finProdFinEquiv.symm k).1 (finProdFinEquiv.symm k).2
end ContingencyTables.RootedCellDataProgram
end OAI
|